libduckdb-sys 1.20000.0

/* automatically generated by rust-bindgen 0.72.1 */

pub const DUCKDB_V2_API_VERSION_MAJOR: u32 = 2;
pub const DUCKDB_V2_API_VERSION_MINOR: u32 = 0;
pub const DUCKDB_V2_API_VERSION_PATCH: u32 = 0;
pub const DUCKDB_V2_API_ALLOW_DEPRECATED: u32 = 1;
pub const DUCKDB_V2_BYTES_INLINE_LENGTH: u32 = 12;
pub type idx_t = u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_extension_info {
    _unused: [u8; 0],
}
pub type duckdb_v2_extension_handle = *mut _duckdb_extension_info;
#[repr(u32)]
#[non_exhaustive]
#[doc = " The order guarantee a producer of rows makes about its output, which decides whether the rows it produces must be\n kept in order downstream."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_ORDER_PRESERVATION {
    #[doc = " The rows have no meaningful order. The engine may reorder them freely, and consumers that otherwise keep\n insertion order, such as query results, INSERT and COPY, run in parallel without ordering them."]
    DUCKDB_V2_ORDER_PRESERVATION_NO_ORDER = 0,
    #[doc = " The rows are produced in insertion order, which the engine keeps unless the `preserve_insertion_order` setting is\n disabled."]
    DUCKDB_V2_ORDER_PRESERVATION_INSERTION_ORDER = 1,
    #[doc = " The rows are produced in an order that must be kept, as if sorted by an `ORDER BY`, even when the\n `preserve_insertion_order` setting is disabled."]
    DUCKDB_V2_ORDER_PRESERVATION_FIXED_ORDER = 2,
    #[doc = " The rows are produced in an order that must be kept, as if sorted by an `ORDER BY`, even when the\n `preserve_insertion_order` setting is disabled."]
    DUCKDB_V2_ORDER_PRESERVATION_MAX_ENUM = 2147483647,
}
#[doc = " An opaque, owned handle to the V2 environment: the required root through which instance handles are created. All\n instances under one environment share an instance cache, so file-level conflicts — the same database file opened\n twice — are detected across them. Destroying the environment refuses with ERROR_RESOURCE_IN_USE while any instance\n created through it is still alive; destroy those first."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_environment {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to the V2 environment: the required root through which instance handles are created. All\n instances under one environment share an instance cache, so file-level conflicts — the same database file opened\n twice — are detected across them. Destroying the environment refuses with ERROR_RESOURCE_IN_USE while any instance\n created through it is still alive; destroy those first."]
pub type duckdb_v2_environment_handle = *mut _duckdb_v2_environment;
#[doc = " An opaque, owned handle to a DuckDB database instance: a buffer pool, a scheduler, a set of GLOBAL settings, and the\n databases attached to it. Created empty by `duckdb_v2_instance_create()`; databases are attached with\n `duckdb_v2_instance_attach()`, made the default with `duckdb_v2_instance_set_default()`, and detached with\n `duckdb_v2_instance_detach()`. Always destroy via `duckdb_v2_instance_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_instance {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to a DuckDB database instance: a buffer pool, a scheduler, a set of GLOBAL settings, and the\n databases attached to it. Created empty by `duckdb_v2_instance_create()`; databases are attached with\n `duckdb_v2_instance_attach()`, made the default with `duckdb_v2_instance_set_default()`, and detached with\n `duckdb_v2_instance_detach()`. Always destroy via `duckdb_v2_instance_destroy()`."]
pub type duckdb_v2_instance_handle = *mut _duckdb_v2_instance;
#[doc = " An opaque, owned handle to a DuckDB connection: a session on a database instance with its own LOCAL settings and\n transaction state. Always destroy via `duckdb_v2_connection_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_connection {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to a DuckDB connection: a session on a database instance with its own LOCAL settings and\n transaction state. Always destroy via `duckdb_v2_connection_destroy()`."]
pub type duckdb_v2_connection_handle = *mut _duckdb_v2_connection;
#[doc = " A borrowed handle to the scope config options are read from and written at. Taken from an instance\n (`duckdb_v2_instance_get_config()`), a connection (`duckdb_v2_connection_get_config()`) or a context\n (`duckdb_v2_context_get_config()`), and valid for as long as its source is; the caller never destroys it. An\n instance's config is the GLOBAL scope alone; a connection's or a context's config reads that client's cascade (its\n SESSION value, else the GLOBAL one, else the default) and writes at any scope the option supports."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_config {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed handle to the scope config options are read from and written at. Taken from an instance\n (`duckdb_v2_instance_get_config()`), a connection (`duckdb_v2_connection_get_config()`) or a context\n (`duckdb_v2_context_get_config()`), and valid for as long as its source is; the caller never destroys it. An\n instance's config is the GLOBAL scope alone; a connection's or a context's config reads that client's cascade (its\n SESSION value, else the GLOBAL one, else the default) and writes at any scope the option supports."]
pub type duckdb_v2_config_handle = *mut _duckdb_v2_config;
#[doc = " An opaque, owned, read-only descriptor of a single config option as registered on an instance: its canonical name,\n default value, description, the scopes it may be written at, and aliases. It carries no current value: read that with\n the *_get_option_value functions, and write it with the *_set_option functions. Returned by the *_get_option_by_name\n and *_get_option_by_index functions; the caller always destroys it via `duckdb_v2_option_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_option {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned, read-only descriptor of a single config option as registered on an instance: its canonical name,\n default value, description, the scopes it may be written at, and aliases. It carries no current value: read that with\n the *_get_option_value functions, and write it with the *_set_option functions. Returned by the *_get_option_by_name\n and *_get_option_by_index functions; the caller always destroys it via `duckdb_v2_option_destroy()`."]
pub type duckdb_v2_option_handle = *mut _duckdb_v2_option;
#[doc = "! Opaque detail for a failed call; destroy with `duckdb_v2_error_info_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_error_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = "! Opaque detail for a failed call; destroy with `duckdb_v2_error_info_destroy()`."]
pub type duckdb_v2_error_info_handle = *mut _duckdb_v2_error_info;
#[doc = " An opaque, owned handle to a logical type. Carries a type id plus any kind-specific metadata: decimal width and\n scale, enum dictionary, list / array / struct / map / union child types, alias. A type is read-only once constructed;\n instances arrive from a query result schema, or from one of the create_type_* constructors. Always destroy via\n `duckdb_v2_logical_type_destroy()`. Borrowed strings returned by the getters are valid only until then."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_logical_type {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to a logical type. Carries a type id plus any kind-specific metadata: decimal width and\n scale, enum dictionary, list / array / struct / map / union child types, alias. A type is read-only once constructed;\n instances arrive from a query result schema, or from one of the create_type_* constructors. Always destroy via\n `duckdb_v2_logical_type_destroy()`. Borrowed strings returned by the getters are valid only until then."]
pub type duckdb_v2_logical_type_handle = *mut _duckdb_v2_logical_type;
#[doc = " An opaque, owned handle to a single SQL value: a logical type plus a typed payload. Always destroy via\n `duckdb_v2_value_destroy()`. The string returned by `duckdb_v2_value_get_varchar()` / `duckdb_v2_value_get_blob()` is\n borrowed and valid only until then. That holds for BIGNUM too, where what is borrowed is the opaque storage form;\n `duckdb_v2_bignum_decode()` translates it into a magnitude and a sign flag, writing into a buffer the caller\n supplies."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_value {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to a single SQL value: a logical type plus a typed payload. Always destroy via\n `duckdb_v2_value_destroy()`. The string returned by `duckdb_v2_value_get_varchar()` / `duckdb_v2_value_get_blob()` is\n borrowed and valid only until then. That holds for BIGNUM too, where what is borrowed is the opaque storage form;\n `duckdb_v2_bignum_decode()` translates it into a magnitude and a sign flag, writing into a buffer the caller\n supplies."]
pub type duckdb_v2_value_handle = *mut _duckdb_v2_value;
#[doc = " An opaque, owned handle to the streaming result of a query. Carries the schema (column names and logical types), the\n statement type, and the result type from prepare time; row data is produced incrementally by stepping\n (`duckdb_v2_result_step()`) or draining (`duckdb_v2_result_fetch_chunk()`). Single consumer: step from one thread at\n a time.\n\n A result is a cursor on the connection's execution, not a box of data. While its statement runs — at most until it is\n finished, cancelled, errored, or destroyed — the connection refuses new queries with ERROR_RESOURCE_IN_USE, and the\n query's transaction stays open, deferring version cleanup and checkpointing, so drain or destroy it promptly.\n Side-effecting statements (PRAGMA, ALTER, ...) take effect only once the result is drained. Always destroy via\n `duckdb_v2_result_destroy()`, which is safe even on a partially consumed stream."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_result {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to the streaming result of a query. Carries the schema (column names and logical types), the\n statement type, and the result type from prepare time; row data is produced incrementally by stepping\n (`duckdb_v2_result_step()`) or draining (`duckdb_v2_result_fetch_chunk()`). Single consumer: step from one thread at\n a time.\n\n A result is a cursor on the connection's execution, not a box of data. While its statement runs — at most until it is\n finished, cancelled, errored, or destroyed — the connection refuses new queries with ERROR_RESOURCE_IN_USE, and the\n query's transaction stays open, deferring version cleanup and checkpointing, so drain or destroy it promptly.\n Side-effecting statements (PRAGMA, ALTER, ...) take effect only once the result is drained. Always destroy via\n `duckdb_v2_result_destroy()`, which is safe even on a partially consumed stream."]
pub type duckdb_v2_result_handle = *mut _duckdb_v2_result;
#[doc = " An opaque, owned handle to a data chunk: a set of vectors of equal logical length plus a cardinality (row count).\n\n A data chunk is the main \"unit of execution\" in DuckDB, and the main unit of data transfer in the API. It may be\n owned or borrowed, depending on the context."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_data_chunk {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to a data chunk: a set of vectors of equal logical length plus a cardinality (row count).\n\n A data chunk is the main \"unit of execution\" in DuckDB, and the main unit of data transfer in the API. It may be\n owned or borrowed, depending on the context."]
pub type duckdb_v2_data_chunk_handle = *mut _duckdb_v2_data_chunk;
#[doc = " A borrowed handle to a vector within a data chunk, carrying a part of a column's values. Vectors are always borrowed\n from a data chunk, and are valid only as long as their parent data chunk is alive."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_vector {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed handle to a vector within a data chunk, carrying a part of a column's values. Vectors are always borrowed\n from a data chunk, and are valid only as long as their parent data chunk is alive."]
pub type duckdb_v2_vector_handle = *mut _duckdb_v2_vector;
#[doc = " A borrowed handle to a \"arena allocator\".\n\n Bytes handed out by `duckdb_v2_arena_allocate()` share the same lifetime as the arena itself.\n `duckdb_v2_vector_get_arena()` yields the arena backing the out-of-line bytes of non-inlined VARCHAR / BLOB / BIT /\n BIGNUM values, valid until the owning vector is flattened, reallocated, or destroyed."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_arena {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed handle to a \"arena allocator\".\n\n Bytes handed out by `duckdb_v2_arena_allocate()` share the same lifetime as the arena itself.\n `duckdb_v2_vector_get_arena()` yields the arena backing the out-of-line bytes of non-inlined VARCHAR / BLOB / BIT /\n BIGNUM values, valid until the owning vector is flattened, reallocated, or destroyed."]
pub type duckdb_v2_arena_handle = *mut _duckdb_v2_arena;
#[doc = " A borrowed handle to a client context: a connection seen from inside DuckDB. Handed out within DuckDB-managed scopes\n — function bind / init / exec callbacks, replacement scans, and the extension entrypoint — and valid only for the\n duration of that scope; the caller never destroys it. Within that scope a transaction is already active. A context\n reaches the same capabilities a connection does, through `duckdb_v2_context_get_factory()`,\n `duckdb_v2_context_get_config()`, `duckdb_v2_context_get_file_system()` and `duckdb_v2_context_log()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_context {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed handle to a client context: a connection seen from inside DuckDB. Handed out within DuckDB-managed scopes\n — function bind / init / exec callbacks, replacement scans, and the extension entrypoint — and valid only for the\n duration of that scope; the caller never destroys it. Within that scope a transaction is already active. A context\n reaches the same capabilities a connection does, through `duckdb_v2_context_get_factory()`,\n `duckdb_v2_context_get_config()`, `duckdb_v2_context_get_file_system()` and `duckdb_v2_context_log()`."]
pub type duckdb_v2_context_handle = *mut _duckdb_v2_context;
#[doc = " A borrowed handle to the scope values, types, data chunks and column data collections are created in. Taken from an\n instance (`duckdb_v2_instance_get_factory()`), a connection (`duckdb_v2_connection_get_factory()`) or a context\n (`duckdb_v2_context_get_factory()`), and valid for as long as its source is; the caller never destroys it. A factory\n resolves in the scope of its source: a connection's or a context's factory reaches the catalog and the client's\n settings, while an instance's factory knows only the built-in types and casts, with default settings, and refuses\n anything that needs a catalog."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_factory {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed handle to the scope values, types, data chunks and column data collections are created in. Taken from an\n instance (`duckdb_v2_instance_get_factory()`), a connection (`duckdb_v2_connection_get_factory()`) or a context\n (`duckdb_v2_context_get_factory()`), and valid for as long as its source is; the caller never destroys it. A factory\n resolves in the scope of its source: a connection's or a context's factory reaches the catalog and the client's\n settings, while an instance's factory knows only the built-in types and casts, with default settings, and refuses\n anything that needs a catalog."]
pub type duckdb_v2_factory_handle = *mut _duckdb_v2_factory;
#[doc = " An entry in a selection-vector.\n\n A selection-vector is a \"dictionary\" represented as an array of indices (sel_t's) mapping \"logical\" row indices to\n the \"physical\" offsets in a vectors primary data buffer. Used by \"dictionary vectors\" to represent a filtered or\n \"sparse\" view of the vector's data."]
pub type duckdb_v2_sel_t = u32;
#[doc = "! VARCHAR storage. The bytes must contain valid UTF-8. Read the transparent bytes fields directly."]
pub type duckdb_v2_varchar_t = duckdb_v2_bytes;
#[doc = "! BLOB storage. Read the transparent bytes fields directly."]
pub type duckdb_v2_blob_t = duckdb_v2_bytes;
#[doc = "! BIT storage. Byte 0 is the padding-bit count, bytes 1.. the data."]
pub type duckdb_v2_bit_t = duckdb_v2_bytes;
#[doc = "! BIGNUM storage. Decode via `duckdb_v2_bignum_decode()`."]
pub type duckdb_v2_bignum_t = duckdb_v2_bytes;
#[doc = " A borrowed name view with the same layout as str, marking a string DuckDB treats as a SQL identifier: one matched\n case-insensitively. Compare two identifiers case-insensitively rather than byte for byte, and render one into SQL\n through the identifier-quoting entry point rather than embedding it raw. The catalog preserves casing; some\n registries (config settings) canonicalize to lowercase.\n\n An identifier passed into the API must be valid UTF-8; otherwise the call fails with `ERROR_INPUT_INVALID`."]
pub type duckdb_v2_identifier_t = duckdb_v2_str;
#[doc = " Receives text produced by DuckDB\n\n Invoked exactly once per producing call, with the complete text in a single view.\n\n The view is borrowed for the duration of the call only. Copy what you need before returning, and do not retain `text`\n or `text->ptr`. The bytes are NOT guaranteed to be null-terminated.\n\n `err` is a live error slot, never NULL. Populate it with `duckdb_v2_error_info_set_code()` /\n `duckdb_v2_error_info_set_text()` to signal failure to DuckDB. Do not destroy it yourself.\n\n The sink runs inside DuckDB's call frame: it must not throw or unwind across the boundary, and it must not re-enter\n the API on the handle being operated on."]
pub type duckdb_v2_text_sink_fn = ::std::option::Option<
    unsafe extern "C" fn(
        text: *const duckdb_v2_str,
        user_data: *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[doc = " Compares two caller-defined resources for equality.\n\n Invoked when DuckDB needs to compare two opaque handles. The callback is responsible for interpreting the pointers\n and comparing the underlying resources. Return true if they are equal, false otherwise.\n\n The callback runs inside DuckDB's call frame: it must not throw or unwind across the boundary, and it must not\n re-enter the API on the handle being operated on."]
pub type duckdb_v2_opaque_equals_fn =
    ::std::option::Option<unsafe extern "C" fn(a: *mut ::std::os::raw::c_void, b: *mut ::std::os::raw::c_void) -> bool>;
#[doc = " Destroys a caller-defined resource.\n\n Invoked when DuckDB needs to destroy an opaque handle. The callback is responsible for interpreting the pointer and\n freeing the underlying resource.\n\n The callback runs inside DuckDB's call frame: it must not throw or unwind across the boundary, and it must not\n re-enter the API on the handle being operated on."]
pub type duckdb_v2_opaque_destroy_fn = ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>;
#[doc = " A borrowed, length-delimited string view: `ptr` points at `len` bytes of character data. The bytes are NOT guaranteed\n to be null-terminated and may contain interior null bytes, so always honor `len` rather than scanning for a\n terminator. The view never owns its bytes; the function that produced it documents how long they live (typically\n \"valid until the owning handle is destroyed\"). `{NULL, 0}` is the canonical empty view, and `ptr` must not be\n dereferenced when `len` is 0. Not to be confused with `bytes`, the transparent 16-byte *storage* format for a\n variable-size value in a vector.\n\n Functions take an input view as a `const str *`, which must not be NULL; a NULL pointer, or a view whose `ptr` is\n NULL while `len` is nonzero, fails with ERROR_INPUT_INVALID. Point at a `{NULL, 0}` view to pass an empty string.\n\n Text inputs, such as VARCHAR values and names, must contain valid UTF-8. The caller is responsible for ensuring this;\n API functions do not necessarily validate the input. Binary inputs, such as BLOB values, do not require valid UTF-8."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_str {
    pub ptr: *const ::std::os::raw::c_char,
    pub len: idx_t,
}
#[doc = " 16-byte storage for a variable-size, byte-backed value: VARCHAR, BLOB, BIT, or BIGNUM. The bytes are inlined when the\n length is at most BYTES_INLINE_LENGTH, in value.inlined.inlined; otherwise value.pointer.ptr holds them and\n value.pointer.prefix repeats the first\n 4. The union is transparent, so read the fields directly. VARCHAR and\n BLOB carry no further encoding; BIT and BIGNUM do. For BIT, byte 0 is the padding-bit count and bytes 1.. are the\n data; BIGNUM is decoded via `duckdb_v2_bignum_decode()`."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct duckdb_v2_bytes {
    pub value: duckdb_v2_bytes__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union duckdb_v2_bytes__bindgen_ty_1 {
    pub pointer: duckdb_v2_bytes__bindgen_ty_1__bindgen_ty_1,
    pub inlined: duckdb_v2_bytes__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_bytes__bindgen_ty_1__bindgen_ty_1 {
    pub length: u32,
    pub prefix: [::std::os::raw::c_char; 4usize],
    pub ptr: *mut ::std::os::raw::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_bytes__bindgen_ty_1__bindgen_ty_2 {
    pub length: u32,
    pub inlined: [::std::os::raw::c_char; 12usize],
}
#[doc = " An opaque, owned handle to a caller-defined resource. Bundles the pointer with optional callbacks that destroy and\n compare the resource."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_opaque {
    pub ptr: *mut ::std::os::raw::c_void,
    pub destroy: duckdb_v2_opaque_destroy_fn,
    pub equals: duckdb_v2_opaque_equals_fn,
}
#[repr(u32)]
#[non_exhaustive]
#[doc = "! Error codes for API calls."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_ERROR {
    #[doc = "! Success."]
    DUCKDB_V2_ERROR_NONE = 0,
    #[doc = "! Generic API error."]
    DUCKDB_V2_ERROR_API = 1,
    #[doc = "! The specified file could not be found."]
    DUCKDB_V2_ERROR_IO_FILE_NOT_FOUND = 1001,
    #[doc = "! Failed to read from the storage device."]
    DUCKDB_V2_ERROR_IO_READ_FAILURE = 1002,
    #[doc = "! Unexpected end of file reached."]
    DUCKDB_V2_ERROR_IO_EOF = 1003,
    #[doc = "! A generic I/O error occurred while reading or writing data."]
    DUCKDB_V2_ERROR_IO_GENERAL = 1004,
    #[doc = "! A network-level failure occurred during an I/O operation."]
    DUCKDB_V2_ERROR_IO_NETWORK = 1005,
    #[doc = "! An HTTP request issued by the database failed."]
    DUCKDB_V2_ERROR_IO_HTTP = 1006,
    #[doc = "! General invalid input error."]
    DUCKDB_V2_ERROR_INPUT_INVALID = 2001,
    #[doc = "! A specific function parameter is malformed."]
    DUCKDB_V2_ERROR_INPUT_PARAMETER_INVALID = 2002,
    #[doc = "! A provided value is outside the acceptable range."]
    DUCKDB_V2_ERROR_INPUT_OUT_OF_RANGE = 2003,
    #[doc = "! An object exceeded its maximum permitted size."]
    DUCKDB_V2_ERROR_INPUT_OBJECT_SIZE = 2004,
    #[doc = " The metadata asked for is known only once execution binds the statement that produces it, because the statement\n expands into several. Step the result and ask again."]
    DUCKDB_V2_ERROR_INPUT_METADATA_DEFERRED = 2005,
    #[doc = "! The requested resource is already in use."]
    DUCKDB_V2_ERROR_RESOURCE_IN_USE = 3001,
    #[doc = "! An allocation failed because the system ran out of memory."]
    DUCKDB_V2_ERROR_RESOURCE_OUT_OF_MEMORY = 3002,
    #[doc = "! A connection-level failure occurred (e.g. the connection has been closed or invalidated)."]
    DUCKDB_V2_ERROR_RESOURCE_CONNECTION = 3003,
    #[doc = "! An operation failed because of an unresolved dependency between catalog objects."]
    DUCKDB_V2_ERROR_RESOURCE_DEPENDENCY = 3004,
    #[doc = "! An extension required by the operation is not loaded."]
    DUCKDB_V2_ERROR_RESOURCE_MISSING_EXTENSION = 3005,
    #[doc = "! Autoloading an extension failed."]
    DUCKDB_V2_ERROR_RESOURCE_AUTOLOAD = 3006,
    #[doc = "! A value could not be converted to the requested type."]
    DUCKDB_V2_ERROR_TYPE_CONVERSION = 4001,
    #[doc = "! An unknown or unsupported type was encountered."]
    DUCKDB_V2_ERROR_TYPE_UNKNOWN = 4002,
    #[doc = "! A type was used in a context where it is not valid."]
    DUCKDB_V2_ERROR_TYPE_INVALID = 4003,
    #[doc = "! Two values or expressions have incompatible types."]
    DUCKDB_V2_ERROR_TYPE_MISMATCH = 4004,
    #[doc = "! A decimal value is out of range or otherwise invalid."]
    DUCKDB_V2_ERROR_TYPE_DECIMAL = 4005,
    #[doc = "! Division by zero was attempted."]
    DUCKDB_V2_ERROR_TYPE_DIVIDE_BY_ZERO = 4006,
    #[doc = "! The query could not be parsed."]
    DUCKDB_V2_ERROR_QUERY_PARSER = 5001,
    #[doc = "! The query contains a syntax error."]
    DUCKDB_V2_ERROR_QUERY_SYNTAX = 5002,
    #[doc = "! Binding the query against the catalog failed (e.g. unknown column or table)."]
    DUCKDB_V2_ERROR_QUERY_BINDER = 5003,
    #[doc = "! The query could not be translated into a logical plan."]
    DUCKDB_V2_ERROR_QUERY_PLANNER = 5004,
    #[doc = "! An error occurred during query optimization."]
    DUCKDB_V2_ERROR_QUERY_OPTIMIZER = 5005,
    #[doc = "! An expression in the query is invalid or could not be evaluated."]
    DUCKDB_V2_ERROR_QUERY_EXPRESSION = 5006,
    #[doc = "! An error occurred while executing the physical plan."]
    DUCKDB_V2_ERROR_QUERY_EXECUTOR = 5007,
    #[doc = "! The task scheduler reported an error while running the query."]
    DUCKDB_V2_ERROR_QUERY_SCHEDULER = 5008,
    #[doc = "! The requested feature or operation is not implemented."]
    DUCKDB_V2_ERROR_QUERY_NOT_IMPLEMENTED = 5009,
    #[doc = "! A prepared-statement parameter has not been bound to a value."]
    DUCKDB_V2_ERROR_QUERY_PARAMETER_NOT_RESOLVED = 5010,
    #[doc = "! A prepared-statement parameter was used in a position where it is not allowed."]
    DUCKDB_V2_ERROR_QUERY_PARAMETER_NOT_ALLOWED = 5011,
    #[doc = "! A catalog operation failed (e.g. object not found or already exists)."]
    DUCKDB_V2_ERROR_DATABASE_CATALOG = 6001,
    #[doc = "! A transaction-level error occurred (e.g. conflict or aborted transaction)."]
    DUCKDB_V2_ERROR_DATABASE_TRANSACTION = 6002,
    #[doc = "! A constraint (primary key, unique, foreign key, NOT NULL, check) was violated."]
    DUCKDB_V2_ERROR_DATABASE_CONSTRAINT = 6003,
    #[doc = "! An index operation failed."]
    DUCKDB_V2_ERROR_DATABASE_INDEX = 6004,
    #[doc = "! A sequence operation failed (e.g. overflow or invalid usage)."]
    DUCKDB_V2_ERROR_DATABASE_SEQUENCE = 6005,
    #[doc = "! An error related to catalog statistics occurred."]
    DUCKDB_V2_ERROR_DATABASE_STATISTICS = 6006,
    #[doc = "! Serializing or deserializing a database object failed."]
    DUCKDB_V2_ERROR_DATABASE_SERIALIZATION = 6007,
    #[doc = "! A settings-related error occurred (e.g. setting an unknown option)."]
    DUCKDB_V2_ERROR_CONFIGURATION_SETTINGS = 7001,
    #[doc = "! The database configuration is invalid."]
    DUCKDB_V2_ERROR_CONFIGURATION_INVALID = 7002,
    #[doc = "! The operation is not permitted under the current configuration."]
    DUCKDB_V2_ERROR_CONFIGURATION_PERMISSION = 7003,
    #[doc = "! An internal invariant was violated; this indicates a bug in DuckDB."]
    DUCKDB_V2_ERROR_RUNTIME_INTERNAL = 8001,
    #[doc = "! A fatal error occurred; the database is no longer usable."]
    DUCKDB_V2_ERROR_RUNTIME_FATAL = 8002,
    #[doc = "! The operation was interrupted (e.g. by a cancel request)."]
    DUCKDB_V2_ERROR_RUNTIME_INTERRUPT = 8003,
    #[doc = "! A required pointer was unexpectedly null."]
    DUCKDB_V2_ERROR_RUNTIME_NULL_POINTER = 8004,
    #[doc = "! A required pointer was unexpectedly null."]
    DUCKDB_V2_ERROR_MAX_ENUM = 2147483647,
}
#[repr(u32)]
#[non_exhaustive]
#[doc = " Identifies a configurable function property. Pass one of these to `duckdb_v2_scalar_function_set_property()` or\n `duckdb_v2_aggregate_function_set_property()` together with a matching `DUCKDB_V2_FUNCTION_PROPERTY_VALUE`. The high\n byte is the function-type group: COMMON (`0x01xxxx`) keys apply to all function types, while group-specific keys\n (e.g. aggregate `0x03xxxx`) are only valid for that function type and are rejected with an error otherwise."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_FUNCTION_PROPERTY_KEY {
    #[doc = " How stable/deterministic the function's result is across rows and queries. Accepts the\n `FUNCTION_PROPERTY_STABILITY_*` values. Defaults to `CONSISTENT`."]
    DUCKDB_V2_FUNCTION_PROPERTY_STABILITY = 65536,
    #[doc = " Whether the function handles NULL inputs itself. Accepts the `FUNCTION_PROPERTY_NULL_HANDLING_*` values. Defaults\n to `DEFAULT` (NULL in, NULL out)."]
    DUCKDB_V2_FUNCTION_PROPERTY_NULL_HANDLING = 65792,
    #[doc = " Whether the function can raise a runtime error. Accepts the `FUNCTION_PROPERTY_FALLIBILITY_*` values. Functions\n created through this API default to `FALLIBLE`, since their callbacks can report errors."]
    DUCKDB_V2_FUNCTION_PROPERTY_FALLIBILITY = 66048,
    #[doc = " How the function interacts with collations on its arguments. Accepts the `FUNCTION_PROPERTY_COLLATION_HANDLING_*`\n values. Defaults to `PROPAGATE`."]
    DUCKDB_V2_FUNCTION_PROPERTY_COLLATION_HANDLING = 66304,
    #[doc = " Aggregate only. Whether the aggregate's result depends on the order in which rows are aggregated. Accepts the\n `FUNCTION_PROPERTY_AGG_ORDER_DEPENDENT_*` values. Defaults to `YES`."]
    DUCKDB_V2_FUNCTION_PROPERTY_AGG_ORDER_DEPENDENT = 196608,
    #[doc = " Aggregate only. Whether the aggregate's result is affected by a DISTINCT modifier. Accepts the\n `FUNCTION_PROPERTY_AGG_DISTINCT_DEPENDENT_*` values. Defaults to `YES`."]
    DUCKDB_V2_FUNCTION_PROPERTY_AGG_DISTINCT_DEPENDENT = 196864,
    #[doc = " Aggregate only. Whether the aggregate's result is affected by a DISTINCT modifier. Accepts the\n `FUNCTION_PROPERTY_AGG_DISTINCT_DEPENDENT_*` values. Defaults to `YES`."]
    DUCKDB_V2_FUNCTION_PROPERTY_KEY_MAX_ENUM = 2147483647,
}
#[repr(u32)]
#[non_exhaustive]
#[doc = " A value for a `DUCKDB_V2_FUNCTION_PROPERTY_KEY`. Each key owns a 256-value block: a value `V` is valid for key `K`\n iff `(V & 0xFFFF00) == K`, and shares the key's function-type group (`V & 0xFF0000`) in its high byte. Passing a\n value that does not match the key is rejected with an error. Boolean-like properties are expressed as named values so\n that additional values can be added later without breaking the ABI."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_FUNCTION_PROPERTY_VALUE {
    #[doc = "! The function always returns the same result given the same input."]
    DUCKDB_V2_FUNCTION_PROPERTY_STABILITY_CONSISTENT = 65536,
    #[doc = "! The result may differ per row (e.g. random())."]
    DUCKDB_V2_FUNCTION_PROPERTY_STABILITY_VOLATILE = 65537,
    #[doc = "! The result is stable within a single query/transaction but may change across queries (e.g. now())."]
    DUCKDB_V2_FUNCTION_PROPERTY_STABILITY_CONSISTENT_WITHIN_QUERY = 65538,
    #[doc = "! Default NULL handling: if any argument is NULL the result is NULL and the function is not invoked for that row."]
    DUCKDB_V2_FUNCTION_PROPERTY_NULL_HANDLING_DEFAULT = 65792,
    #[doc = "! The function handles NULL inputs itself and is invoked even when arguments are NULL."]
    DUCKDB_V2_FUNCTION_PROPERTY_NULL_HANDLING_SPECIAL = 65793,
    #[doc = " The function never raises a runtime error. Declaring this promises that the callbacks never report an error; an\n error reported anyway becomes an internal error."]
    DUCKDB_V2_FUNCTION_PROPERTY_FALLIBILITY_INFALLIBLE = 66048,
    #[doc = "! The function may raise a runtime error for some inputs."]
    DUCKDB_V2_FUNCTION_PROPERTY_FALLIBILITY_FALLIBLE = 66049,
    #[doc = "! The function combines collations from its inputs and propagates them to its result (default)."]
    DUCKDB_V2_FUNCTION_PROPERTY_COLLATION_HANDLING_PROPAGATE = 66304,
    #[doc = "! Combinable collations are executed on the input arguments before the function runs."]
    DUCKDB_V2_FUNCTION_PROPERTY_COLLATION_HANDLING_PUSH_COMBINABLE = 66305,
    #[doc = "! Collations are ignored by the function."]
    DUCKDB_V2_FUNCTION_PROPERTY_COLLATION_HANDLING_IGNORE = 66306,
    #[doc = "! The aggregate's result depends on the order in which rows are aggregated (default)."]
    DUCKDB_V2_FUNCTION_PROPERTY_AGG_ORDER_DEPENDENT_YES = 196608,
    #[doc = "! The aggregate's result does not depend on input order."]
    DUCKDB_V2_FUNCTION_PROPERTY_AGG_ORDER_DEPENDENT_NO = 196609,
    #[doc = "! The aggregate's result is affected by a DISTINCT modifier (default)."]
    DUCKDB_V2_FUNCTION_PROPERTY_AGG_DISTINCT_DEPENDENT_YES = 196864,
    #[doc = "! The aggregate's result is not affected by a DISTINCT modifier."]
    DUCKDB_V2_FUNCTION_PROPERTY_AGG_DISTINCT_DEPENDENT_NO = 196865,
    #[doc = "! The aggregate's result is not affected by a DISTINCT modifier."]
    DUCKDB_V2_FUNCTION_PROPERTY_VALUE_MAX_ENUM = 2147483647,
}
#[repr(u32)]
#[non_exhaustive]
#[doc = " The mode a cast is being executed in. A normal cast must either succeed for every row or report an error, which\n aborts the query. A \"try\" cast (SQL TRY_CAST, and implicit casts the engine probes speculatively) tolerates per-row\n failures: the callback writes NULL for the rows it could not convert instead of aborting. Read with\n `duckdb_v2_cast_function_exec_get_mode()`, and passed to `duckdb_v2_vector_cast()`."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_CAST_MODE {
    #[doc = "! A regular cast. A conversion failure reported through the error slot aborts the query."]
    DUCKDB_V2_CAST_MODE_NORMAL = 0,
    #[doc = " A \"try\" cast. Conversion failures should be written as NULLs into the output vector; an error reported through\n the slot is swallowed and the affected rows are left NULL."]
    DUCKDB_V2_CAST_MODE_TRY = 1,
    #[doc = " A \"try\" cast. Conversion failures should be written as NULLs into the output vector; an error reported through\n the slot is swallowed and the affected rows are left NULL."]
    DUCKDB_V2_CAST_MODE_MAX_ENUM = 2147483647,
}
#[doc = " An owned opaque handle to a cast function being built. Created with `duckdb_v2_cast_function_create()`, configured\n with the setter functions (e.g. `duckdb_v2_cast_function_set_source_type()`,\n `duckdb_v2_cast_function_set_exec_callback()`, etc.), made available with\n `duckdb_v2_connection_register_cast_function()` or `duckdb_v2_extension_register_cast_function()`, and destroyed with\n `duckdb_v2_cast_function_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_cast_function {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a cast function being built. Created with `duckdb_v2_cast_function_create()`, configured\n with the setter functions (e.g. `duckdb_v2_cast_function_set_source_type()`,\n `duckdb_v2_cast_function_set_exec_callback()`, etc.), made available with\n `duckdb_v2_connection_register_cast_function()` or `duckdb_v2_extension_register_cast_function()`, and destroyed with\n `duckdb_v2_cast_function_destroy()`."]
pub type duckdb_v2_cast_function_handle = *mut _duckdb_v2_cast_function;
#[doc = " A borrowed opaque handle to the arguments supplied to a cast function during the execution \"exec\" phase. The \"exec\"\n callback receives this handle and can use it to access the input vector, the output vector to write into, the number\n of rows to convert, and the mode the cast is running in."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_cast_function_exec_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a cast function during the execution \"exec\" phase. The \"exec\"\n callback receives this handle and can use it to access the input vector, the output vector to write into, the number\n of rows to convert, and the mode the cast is running in."]
pub type duckdb_v2_cast_function_exec_info_handle = *mut _duckdb_v2_cast_function_exec_info;
pub type duckdb_v2_cast_function_exec_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_cast_function_exec_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[doc = " A column data collection represents a set of (buffer-managed) data chunks.\n\n You can append chunks to the collection iteratively, and then scan the collection back to retrieve the chunks in\n order. DuckDB will manage the memory for the chunks, and transparently offload chunks to disk if necessary. A\n collection shall not be scanned while it is being appended to, and vice versa. A collection shall not be appended to\n concurrently, but it can be scanned concurrently by multiple threads using a shared scan state and per-thread worker\n scan states. For concurrent appends, consider creating multiple collections and \"combining\" them into one collection\n at the end."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_column_data_collection {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A column data collection represents a set of (buffer-managed) data chunks.\n\n You can append chunks to the collection iteratively, and then scan the collection back to retrieve the chunks in\n order. DuckDB will manage the memory for the chunks, and transparently offload chunks to disk if necessary. A\n collection shall not be scanned while it is being appended to, and vice versa. A collection shall not be appended to\n concurrently, but it can be scanned concurrently by multiple threads using a shared scan state and per-thread worker\n scan states. For concurrent appends, consider creating multiple collections and \"combining\" them into one collection\n at the end."]
pub type duckdb_v2_column_data_collection_handle = *mut _duckdb_v2_column_data_collection;
#[doc = " Opaque state handle for shared state across multiple threads scanning a column data collection. This is used to\n coordinate work distribution, track global progress, or store any other state that needs to be shared across threads\n during the scan of the collection."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_column_data_collection_shared_scan_state {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " Opaque state handle for shared state across multiple threads scanning a column data collection. This is used to\n coordinate work distribution, track global progress, or store any other state that needs to be shared across threads\n during the scan of the collection."]
pub type duckdb_v2_column_data_collection_shared_scan_state_handle =
    *mut _duckdb_v2_column_data_collection_shared_scan_state;
#[doc = " Opaque state handle for local state while scanning a column data collection. This is used to track progress and any\n other state that needs to be maintained on a per-thread basis across calls while scanning the collection. It also\n keeps the buffers backing the most recently scanned chunk alive: chunks are scanned zero-copy, so a scanned chunk's\n data is only valid until the worker state's next scan call or its destruction."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_column_data_collection_worker_scan_state {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " Opaque state handle for local state while scanning a column data collection. This is used to track progress and any\n other state that needs to be maintained on a per-thread basis across calls while scanning the collection. It also\n keeps the buffers backing the most recently scanned chunk alive: chunks are scanned zero-copy, so a scanned chunk's\n data is only valid until the worker state's next scan call or its destruction."]
pub type duckdb_v2_column_data_collection_worker_scan_state_handle =
    *mut _duckdb_v2_column_data_collection_worker_scan_state;
#[doc = " Opaque state handle for appending to a column data collection. This is used to track progress and any other state\n that needs to be maintained across calls while appending to the collection."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_column_data_collection_append_state {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " Opaque state handle for appending to a column data collection. This is used to track progress and any other state\n that needs to be maintained across calls while appending to the collection."]
pub type duckdb_v2_column_data_collection_append_state_handle = *mut _duckdb_v2_column_data_collection_append_state;
#[repr(u32)]
#[non_exhaustive]
#[doc = " The scope of an option's value. Writes take DEFAULT, GLOBAL or SESSION: DEFAULT writes to the option's default scope\n (`duckdb_v2_option_get_default_scope()`), like SQL `SET name = value`; GLOBAL writes through to the instance, visible\n to all connections, like `SET GLOBAL`; SESSION writes to one connection's session only, like `SET SESSION`. Reads\n report GLOBAL or SESSION, as DuckDB attributes the value: an option no scope sets reads as GLOBAL, its default, and a\n legacy option read through a connection or context reads as SESSION."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_SETTING_SCOPE {
    #[doc = "! Write only: the option's default scope (`duckdb_v2_option_get_default_scope()`), not its default value."]
    DUCKDB_V2_SETTING_SCOPE_DEFAULT = 0,
    #[doc = "! The instance's value, visible to all connections."]
    DUCKDB_V2_SETTING_SCOPE_GLOBAL = 1,
    #[doc = "! A connection's session value."]
    DUCKDB_V2_SETTING_SCOPE_SESSION = 2,
    #[doc = "! A connection's session value."]
    DUCKDB_V2_SETTING_SCOPE_MAX_ENUM = 2147483647,
}
#[doc = " An owned opaque handle to a custom type being built. Created with `duckdb_v2_custom_type_create()`, configured with\n `duckdb_v2_custom_type_set_name()` and `duckdb_v2_custom_type_set_base_type()`, made available with\n `duckdb_v2_connection_register_custom_type()` or `duckdb_v2_extension_register_custom_type()`, and destroyed with\n `duckdb_v2_custom_type_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_custom_type {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a custom type being built. Created with `duckdb_v2_custom_type_create()`, configured with\n `duckdb_v2_custom_type_set_name()` and `duckdb_v2_custom_type_set_base_type()`, made available with\n `duckdb_v2_connection_register_custom_type()` or `duckdb_v2_extension_register_custom_type()`, and destroyed with\n `duckdb_v2_custom_type_destroy()`."]
pub type duckdb_v2_custom_type_handle = *mut _duckdb_v2_custom_type;
#[doc = " Hands back the function-pointer table for the API version the extension was built against, or NULL if this DuckDB\n cannot serve it.\n\n The extension calls it exactly once, first, through DUCKDB_EXTENSION_API_INIT; nothing else in the API may be called\n before it succeeds. A NULL return means the load has already failed and DuckDB has recorded why, so the entrypoint\n must return without touching the error slot. Statically linked extensions resolve DuckDB's symbols at link time and\n never call it, so for those the field is NULL."]
pub type duckdb_v2_extension_get_api_fn = ::std::option::Option<
    unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        version: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_void,
>;
#[doc = " The single argument to a V2 C extension entrypoint. Borrowed for the duration of the call: none of its fields outlive\n the entrypoint, and the extension destroys none of them."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_extension_input {
    #[doc = "! Fetches the versioned function-pointer table. NULL for a statically linked extension."]
    pub get_api: duckdb_v2_extension_get_api_fn,
    #[doc = "! The extension being loaded, and the token get_api takes."]
    pub extension: duckdb_v2_extension_handle,
    #[doc = " A borrowed context to read and run queries through, with a transaction already active. Valid only until the\n extension entrypoint returns; do not retain or destroy it."]
    pub context: duckdb_v2_context_handle,
    #[doc = " A live error slot: never NULL, and never pointing at NULL. Populate it with error_info_set_code, and optionally\n error_info_set_text, to fail the load. Do not destroy it -- DuckDB owns it. Pass a slot of your own to calls\n whose failure you intend to handle, so only a failure you mean to abort the load with lands here."]
    pub err: *mut duckdb_v2_error_info_handle,
}
#[repr(u32)]
#[non_exhaustive]
#[doc = " How `duckdb_v2_file_system_open()` opens a file. These are not a bitmask -- apply them one at a time with\n `duckdb_v2_file_open_options_set_flag()`, calling it once per behaviour you want, e.g. `FILE_FLAG_WRITE` then\n `FILE_FLAG_CREATE` to write to a file and create it when it does not exist."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_FILE_FLAG {
    #[doc = "! Not a flag. The zero value, so that an uninitialized variable does not name a behaviour; applying it is an\n! error."]
    DUCKDB_V2_FILE_FLAG_INVALID = 0,
    #[doc = "! Open the file with \"read\" capabilities."]
    DUCKDB_V2_FILE_FLAG_READ = 1,
    #[doc = "! Open the file with \"write\" capabilities."]
    DUCKDB_V2_FILE_FLAG_WRITE = 2,
    #[doc = "! Create the file if it does not exist, and open it as it is if it does."]
    DUCKDB_V2_FILE_FLAG_CREATE = 3,
    #[doc = " Create the file if it does not exist, and truncate it to empty if it does. To fail instead of truncating, combine\n `FILE_FLAG_CREATE` with `FILE_FLAG_EXCLUSIVE_CREATE`."]
    DUCKDB_V2_FILE_FLAG_CREATE_NEW = 4,
    #[doc = "! Open the file in \"append\" mode."]
    DUCKDB_V2_FILE_FLAG_APPEND = 5,
    #[doc = "! Fail if the file already exists. A modifier on `FILE_FLAG_CREATE`, and meaningless without it."]
    DUCKDB_V2_FILE_FLAG_EXCLUSIVE_CREATE = 6,
    #[doc = " The file will be read and written at explicit offsets from several threads at once. Pass it whenever\n `duckdb_v2_file_read_at()` or `duckdb_v2_file_write_at()` are used concurrently -- a file system that would\n otherwise assume sequential access, by caching, buffering, or keeping a single cursor, needs to know not to."]
    DUCKDB_V2_FILE_FLAG_PARALLEL_ACCESS = 7,
    #[doc = " Read the file through DuckDB's external file cache, which keeps the bytes that were read in memory, so that later\n reads of the same file - also by later queries - do not have to read them again. Whether a local file is cached\n is decided by the `cache_local_files` setting. Only meaningful for reading."]
    DUCKDB_V2_FILE_FLAG_EXTERNAL_FILE_CACHE = 8,
    #[doc = " Read the file through DuckDB's external file cache, which keeps the bytes that were read in memory, so that later\n reads of the same file - also by later queries - do not have to read them again. Whether a local file is cached\n is decided by the `cache_local_files` setting. Only meaningful for reading."]
    DUCKDB_V2_FILE_FLAG_MAX_ENUM = 2147483647,
}
#[doc = " A borrowed opaque handle to a file system. Obtained from `duckdb_v2_instance_get_file_system()`,\n `duckdb_v2_connection_get_file_system()` or `duckdb_v2_context_get_file_system()`, and used to open files with\n `duckdb_v2_file_system_open()`. Borrowed: the handle belongs to the instance, connection or context it came from, is\n valid only for as long as that is, and must not be destroyed."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_file_system {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to a file system. Obtained from `duckdb_v2_instance_get_file_system()`,\n `duckdb_v2_connection_get_file_system()` or `duckdb_v2_context_get_file_system()`, and used to open files with\n `duckdb_v2_file_system_open()`. Borrowed: the handle belongs to the instance, connection or context it came from, is\n valid only for as long as that is, and must not be destroyed."]
pub type duckdb_v2_file_system_handle = *mut _duckdb_v2_file_system;
#[doc = " An owned opaque handle to the options a file is opened with. Created with `duckdb_v2_file_open_options_create()`,\n configured with `duckdb_v2_file_open_options_set_flag()` and `duckdb_v2_file_open_options_set_value()`, passed to\n `duckdb_v2_file_system_open()`, and destroyed with `duckdb_v2_file_open_options_destroy()`. One options object can\n open any number of files, and destroying it does not affect files already opened with it."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_file_open_options {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to the options a file is opened with. Created with `duckdb_v2_file_open_options_create()`,\n configured with `duckdb_v2_file_open_options_set_flag()` and `duckdb_v2_file_open_options_set_value()`, passed to\n `duckdb_v2_file_system_open()`, and destroyed with `duckdb_v2_file_open_options_destroy()`. One options object can\n open any number of files, and destroying it does not affect files already opened with it."]
pub type duckdb_v2_file_open_options_handle = *mut _duckdb_v2_file_open_options;
#[doc = " An owned opaque handle to an open file, produced by `duckdb_v2_file_system_open()` and destroyed with\n `duckdb_v2_file_destroy()`. Read, write, seek and sync through the `file_*` functions. Only usable while the file\n system it was opened through is still valid."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_file {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to an open file, produced by `duckdb_v2_file_system_open()` and destroyed with\n `duckdb_v2_file_destroy()`. Read, write, seek and sync through the `file_*` functions. Only usable while the file\n system it was opened through is still valid."]
pub type duckdb_v2_file_handle = *mut _duckdb_v2_file;
#[doc = " Receives one path matched by `duckdb_v2_file_system_path_glob()`.\n\n The view is borrowed for the duration of the call only, and is not guaranteed to be null-terminated. Report an error\n through `err`, a live slot that must not be destroyed, to stop the glob: `duckdb_v2_file_system_path_glob()` then\n fails with that error. The callback must not throw or unwind across the boundary."]
pub type duckdb_v2_file_system_path_glob_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        path: *const duckdb_v2_str,
        user_data: *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[doc = " A borrowed opaque handle to the call site a bind callback is binding. Every function family's bind callback receives\n this handle next to its own bind info. It gives access to the arguments of the call, the function's user data, and\n the bind data.\n\n The arguments form one list in four parts, in this order: one argument per positional-only and standard parameter, in\n declaration order; the arguments `*args` received, in call order; one argument per named-only parameter, in\n declaration order; and the arguments `**kwargs` received, in call order. How the caller passed an argument does not\n matter: a standard parameter passed by name is at its declared position. A parameter the call omitted is present with\n its default value. See `duckdb_v2_function_bind_get_arg_count()` for the size of each part."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_function_bind_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the call site a bind callback is binding. Every function family's bind callback receives\n this handle next to its own bind info. It gives access to the arguments of the call, the function's user data, and\n the bind data.\n\n The arguments form one list in four parts, in this order: one argument per positional-only and standard parameter, in\n declaration order; the arguments `*args` received, in call order; one argument per named-only parameter, in\n declaration order; and the arguments `**kwargs` received, in call order. How the caller passed an argument does not\n matter: a standard parameter passed by name is at its declared position. A parameter the call omitted is present with\n its default value. See `duckdb_v2_function_bind_get_arg_count()` for the size of each part."]
pub type duckdb_v2_function_bind_info_handle = *mut _duckdb_v2_function_bind_info;
#[doc = " A borrowed opaque handle to the documentation of a function overload. Taken from the function it documents with\n `duckdb_v2_scalar_function_get_docs()`, `duckdb_v2_aggregate_function_get_docs()`,\n `duckdb_v2_table_function_get_docs()`, `duckdb_v2_pragma_function_get_docs()` or\n `duckdb_v2_macro_function_get_docs()`, and valid for as long as that function handle is; the caller never destroys\n it."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_function_docs {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the documentation of a function overload. Taken from the function it documents with\n `duckdb_v2_scalar_function_get_docs()`, `duckdb_v2_aggregate_function_get_docs()`,\n `duckdb_v2_table_function_get_docs()`, `duckdb_v2_pragma_function_get_docs()` or\n `duckdb_v2_macro_function_get_docs()`, and valid for as long as that function handle is; the caller never destroys\n it."]
pub type duckdb_v2_function_docs_handle = *mut _duckdb_v2_function_docs;
#[repr(u32)]
#[non_exhaustive]
#[doc = " How a caller passes the argument for a parameter, following Python's parameter kinds. A signature orders its\n parameters by kind, in the order the values are listed here. Pass one of these to\n `duckdb_v2_function_signature_add_parameter()`."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_FUNCTION_PARAMETER_KIND {
    #[doc = " Passed by position only. The name is invisible to a caller: a named argument with the same name is received by\n `**kwargs`, or rejected when the signature has none."]
    DUCKDB_V2_FUNCTION_PARAMETER_KIND_POSITIONAL_ONLY = 0,
    #[doc = "! Passed by position or by name."]
    DUCKDB_V2_FUNCTION_PARAMETER_KIND_STANDARD = 1,
    #[doc = " `*args`: receives the positional arguments left over after the positional-only and standard parameters, each cast\n to the parameter type. ANY leaves them un-cast."]
    DUCKDB_V2_FUNCTION_PARAMETER_KIND_POSITIONAL_VARIADIC = 2,
    #[doc = "! Passed by name only."]
    DUCKDB_V2_FUNCTION_PARAMETER_KIND_NAMED_ONLY = 3,
    #[doc = " `**kwargs`: receives the named arguments that match no other parameter, each cast to the parameter type. ANY\n leaves them un-cast."]
    DUCKDB_V2_FUNCTION_PARAMETER_KIND_NAMED_VARIADIC = 4,
    #[doc = " `**kwargs`: receives the named arguments that match no other parameter, each cast to the parameter type. ANY\n leaves them un-cast."]
    DUCKDB_V2_FUNCTION_PARAMETER_KIND_MAX_ENUM = 2147483647,
}
#[doc = "! An opaque handle to a function signature. Carries the function's parameters and return type."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_function_signature {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = "! An opaque handle to a function signature. Carries the function's parameters and return type."]
pub type duckdb_v2_function_signature_handle = *mut _duckdb_v2_function_signature;
#[doc = " An opaque, owned handle to the `(KEY value)` options of one `duckdb_v2_instance_attach()` call, as SQL `ATTACH`\n accepts them. Created from the instance handle it will be used with via `duckdb_v2_attach_options_create()`; destroy\n it via `duckdb_v2_attach_options_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_attach_options {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to the `(KEY value)` options of one `duckdb_v2_instance_attach()` call, as SQL `ATTACH`\n accepts them. Created from the instance handle it will be used with via `duckdb_v2_attach_options_create()`; destroy\n it via `duckdb_v2_attach_options_destroy()`."]
pub type duckdb_v2_attach_options_handle = *mut _duckdb_v2_attach_options;
#[repr(u32)]
#[non_exhaustive]
#[doc = " Severity of a log message. Mirrors DuckDB's own log levels, and is compared against the configured threshold: an\n entry below it is dropped."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_LOG_LEVEL {
    #[doc = "! Finest detail; off in any default configuration."]
    DUCKDB_V2_LOG_LEVEL_TRACE = 10,
    #[doc = "! Diagnostic detail."]
    DUCKDB_V2_LOG_LEVEL_DEBUG = 20,
    #[doc = "! Ordinary progress information."]
    DUCKDB_V2_LOG_LEVEL_INFO = 30,
    #[doc = "! A recoverable problem."]
    DUCKDB_V2_LOG_LEVEL_WARNING = 40,
    #[doc = "! An operation failed."]
    DUCKDB_V2_LOG_LEVEL_ERROR = 50,
    #[doc = "! An unrecoverable failure."]
    DUCKDB_V2_LOG_LEVEL_FATAL = 60,
    #[doc = "! An unrecoverable failure."]
    DUCKDB_V2_LOG_LEVEL_MAX_ENUM = 2147483647,
}
#[doc = " An owned qualified name: an ordered path of one to three non-empty identifier parts whose last element is the object\n name. Construct with `duckdb_v2_qname_parse()` or `duckdb_v2_qname_create()`, read with\n `duckdb_v2_qname_get_part_count()` and `duckdb_v2_qname_get_part()`, render back to SQL with\n `duckdb_v2_qname_render()`, compare with `duckdb_v2_qname_equals()`, and destroy with `duckdb_v2_qname_destroy()`.\n Two handles are compared with `duckdb_v2_qname_equals()`, never by pointer."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_qname {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned qualified name: an ordered path of one to three non-empty identifier parts whose last element is the object\n name. Construct with `duckdb_v2_qname_parse()` or `duckdb_v2_qname_create()`, read with\n `duckdb_v2_qname_get_part_count()` and `duckdb_v2_qname_get_part()`, render back to SQL with\n `duckdb_v2_qname_render()`, compare with `duckdb_v2_qname_equals()`, and destroy with `duckdb_v2_qname_destroy()`.\n Two handles are compared with `duckdb_v2_qname_equals()`, never by pointer."]
pub type duckdb_v2_qname_handle = *mut _duckdb_v2_qname;
#[doc = " An owned snapshot of the metrics of a query. Taken with `duckdb_v2_connection_get_query_metrics()`, read from its\n root node via `duckdb_v2_query_metrics_get_root()`, and destroyed with `duckdb_v2_query_metrics_destroy()`. Later\n queries do not update it."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_query_metrics {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned snapshot of the metrics of a query. Taken with `duckdb_v2_connection_get_query_metrics()`, read from its\n root node via `duckdb_v2_query_metrics_get_root()`, and destroyed with `duckdb_v2_query_metrics_destroy()`. Later\n queries do not update it."]
pub type duckdb_v2_query_metrics_handle = *mut _duckdb_v2_query_metrics;
#[doc = " A borrowed opaque handle to one node of a query metrics snapshot, valid for as long as the snapshot is. Read its name\n with `duckdb_v2_query_metrics_node_get_name()`, its metrics with `duckdb_v2_query_metrics_node_get_metric()` or by\n index, and its children with `duckdb_v2_query_metrics_node_get_child()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_query_metrics_node {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to one node of a query metrics snapshot, valid for as long as the snapshot is. Read its name\n with `duckdb_v2_query_metrics_node_get_name()`, its metrics with `duckdb_v2_query_metrics_node_get_metric()` or by\n index, and its children with `duckdb_v2_query_metrics_node_get_child()`."]
pub type duckdb_v2_query_metrics_node_handle = *mut _duckdb_v2_query_metrics_node;
#[doc = " An owned, ordered list of (name, type) fields. Read with schema_get_count and schema_get_field. Destroy via\n schema_destroy."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_schema {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned, ordered list of (name, type) fields. Read with schema_get_count and schema_get_field. Destroy via\n schema_destroy."]
pub type duckdb_v2_schema_handle = *mut _duckdb_v2_schema;
#[repr(u32)]
#[non_exhaustive]
#[doc = "! The lexical class of a token."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_TOKEN_TYPE {
    #[doc = "! Not an actual token class; out_type is set to this when `duckdb_v2_token_iterator_next()` fails."]
    DUCKDB_V2_TOKEN_TYPE_INVALID = 0,
    #[doc = "! A keyword of the connection's grammar."]
    DUCKDB_V2_TOKEN_TYPE_KEYWORD = 1,
    #[doc = "! A bare or double-quoted identifier, quotes included."]
    DUCKDB_V2_TOKEN_TYPE_IDENTIFIER = 2,
    #[doc = "! A quoted or dollar-quoted string, delimiters included."]
    DUCKDB_V2_TOKEN_TYPE_STRING_LITERAL = 3,
    #[doc = "! A numeric literal."]
    DUCKDB_V2_TOKEN_TYPE_NUMBER_LITERAL = 4,
    #[doc = "! An operator or punctuation run other than the statement terminator."]
    DUCKDB_V2_TOKEN_TYPE_OPERATOR = 5,
    #[doc = "! A line or block comment, delimiters included."]
    DUCKDB_V2_TOKEN_TYPE_COMMENT = 6,
    #[doc = "! A statement-terminating semicolon."]
    DUCKDB_V2_TOKEN_TYPE_TERMINATOR = 7,
    #[doc = " Not a token; reported by token_iterator_next once the input is exhausted, with start equal to the input length\n and length 0."]
    DUCKDB_V2_TOKEN_TYPE_END_OF_INPUT = 8,
    #[doc = " Not a token; reported by token_iterator_next once the input is exhausted, with start equal to the input length\n and length 0."]
    DUCKDB_V2_TOKEN_TYPE_MAX_ENUM = 2147483647,
}
#[doc = "! An opaque, owned handle to an iterator over the tokens of a SQL string, produced by tokenize_sql."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_token_iterator {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = "! An opaque, owned handle to an iterator over the tokens of a SQL string, produced by tokenize_sql."]
pub type duckdb_v2_token_iterator_handle = *mut _duckdb_v2_token_iterator;
#[doc = " An owned opaque handle to a custom aggregate function being built. Created with\n `duckdb_v2_aggregate_function_create()`, configured with the setter functions (e.g.\n `duckdb_v2_aggregate_function_set_name()`, `duckdb_v2_aggregate_function_set_update_callback()`, etc.) and the\n signature obtained via `duckdb_v2_aggregate_function_get_signature()`, made available with\n `duckdb_v2_connection_register_aggregate_function()` or `duckdb_v2_extension_register_aggregate_function()`, and\n destroyed with `duckdb_v2_aggregate_function_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_aggregate_function {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a custom aggregate function being built. Created with\n `duckdb_v2_aggregate_function_create()`, configured with the setter functions (e.g.\n `duckdb_v2_aggregate_function_set_name()`, `duckdb_v2_aggregate_function_set_update_callback()`, etc.) and the\n signature obtained via `duckdb_v2_aggregate_function_get_signature()`, made available with\n `duckdb_v2_connection_register_aggregate_function()` or `duckdb_v2_extension_register_aggregate_function()`, and\n destroyed with `duckdb_v2_aggregate_function_destroy()`."]
pub type duckdb_v2_aggregate_function_handle = *mut _duckdb_v2_aggregate_function;
#[doc = " A borrowed opaque handle to the result of an aggregate function's \"bind\" phase. The \"bind\" callback receives this\n handle next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments, the user data and the\n bind data, and can use it to set the return type of the call site being bound."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_aggregate_function_bind_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the result of an aggregate function's \"bind\" phase. The \"bind\" callback receives this\n handle next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments, the user data and the\n bind data, and can use it to set the return type of the call site being bound."]
pub type duckdb_v2_aggregate_function_bind_info_handle = *mut _duckdb_v2_aggregate_function_bind_info;
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the state sizing \"size\" phase. The\n \"size\" callback receives this handle and must use it to report the size of a single aggregate state in bytes."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_aggregate_function_size_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the state sizing \"size\" phase. The\n \"size\" callback receives this handle and must use it to report the size of a single aggregate state in bytes."]
pub type duckdb_v2_aggregate_function_size_info_handle = *mut _duckdb_v2_aggregate_function_size_info;
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the state initialization \"init\"\n phase. The \"init\" callback receives this handle and can use it to access the array of aggregate states it must\n initialize in place."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_aggregate_function_init_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the state initialization \"init\"\n phase. The \"init\" callback receives this handle and can use it to access the array of aggregate states it must\n initialize in place."]
pub type duckdb_v2_aggregate_function_init_info_handle = *mut _duckdb_v2_aggregate_function_init_info;
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the \"update\" phase. The \"update\"\n callback receives this handle and can use it to access the input argument vectors, the number of rows to process, and\n the aggregate state each row must be aggregated into."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_aggregate_function_update_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the \"update\" phase. The \"update\"\n callback receives this handle and can use it to access the input argument vectors, the number of rows to process, and\n the aggregate state each row must be aggregated into."]
pub type duckdb_v2_aggregate_function_update_info_handle = *mut _duckdb_v2_aggregate_function_update_info;
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the \"combine\" phase. The \"combine\"\n callback receives this handle and can use it to access the source and target aggregate state arrays to merge."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_aggregate_function_combine_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the \"combine\" phase. The \"combine\"\n callback receives this handle and can use it to access the source and target aggregate state arrays to merge."]
pub type duckdb_v2_aggregate_function_combine_info_handle = *mut _duckdb_v2_aggregate_function_combine_info;
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the \"finalize\" phase. The\n \"finalize\" callback receives this handle and can use it to access the aggregate states and the result vector and\n offset to write their final values to."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_aggregate_function_finalize_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the \"finalize\" phase. The\n \"finalize\" callback receives this handle and can use it to access the aggregate states and the result vector and\n offset to write their final values to."]
pub type duckdb_v2_aggregate_function_finalize_info_handle = *mut _duckdb_v2_aggregate_function_finalize_info;
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the state destruction \"destroy\"\n phase. The \"destroy\" callback receives this handle and can use it to access the array of aggregate states whose\n resources must be released."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_aggregate_function_destroy_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to an aggregate function during the state destruction \"destroy\"\n phase. The \"destroy\" callback receives this handle and can use it to access the array of aggregate states whose\n resources must be released."]
pub type duckdb_v2_aggregate_function_destroy_info_handle = *mut _duckdb_v2_aggregate_function_destroy_info;
pub type duckdb_v2_aggregate_function_bind_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        result: duckdb_v2_aggregate_function_bind_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_aggregate_function_size_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(info: duckdb_v2_aggregate_function_size_info_handle, err: *mut duckdb_v2_error_info_handle),
>;
pub type duckdb_v2_aggregate_function_init_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(info: duckdb_v2_aggregate_function_init_info_handle, err: *mut duckdb_v2_error_info_handle),
>;
pub type duckdb_v2_aggregate_function_update_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(info: duckdb_v2_aggregate_function_update_info_handle, err: *mut duckdb_v2_error_info_handle),
>;
pub type duckdb_v2_aggregate_function_combine_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(info: duckdb_v2_aggregate_function_combine_info_handle, err: *mut duckdb_v2_error_info_handle),
>;
pub type duckdb_v2_aggregate_function_finalize_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_finalize_info_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_aggregate_function_destroy_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(info: duckdb_v2_aggregate_function_destroy_info_handle, err: *mut duckdb_v2_error_info_handle),
>;
#[doc = " An owned snapshot of one base table taken at creation: where the name resolved, the table's columns, and per-column\n catalog facts. Later DDL does not update it. Create with `duckdb_v2_connection_describe_table()`, read the resolved\n location via `duckdb_v2_table_description_get_qname()`, and the columns via\n `duckdb_v2_table_description_get_column_count()` and `duckdb_v2_table_description_get_column()`. Destroy via\n `duckdb_v2_table_description_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_description {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned snapshot of one base table taken at creation: where the name resolved, the table's columns, and per-column\n catalog facts. Later DDL does not update it. Create with `duckdb_v2_connection_describe_table()`, read the resolved\n location via `duckdb_v2_table_description_get_qname()`, and the columns via\n `duckdb_v2_table_description_get_column_count()` and `duckdb_v2_table_description_get_column()`. Destroy via\n `duckdb_v2_table_description_destroy()`."]
pub type duckdb_v2_table_description_handle = *mut _duckdb_v2_table_description;
#[doc = " An owned snapshot of one column of a described table: its name, type, and catalog facts. Obtain with\n `duckdb_v2_table_description_get_column()`, read with `duckdb_v2_column_description_get_name()`,\n `duckdb_v2_column_description_get_type()`, `duckdb_v2_column_description_has_default()` and\n `duckdb_v2_column_description_has_generated()`, and destroy with `duckdb_v2_column_description_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_column_description {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned snapshot of one column of a described table: its name, type, and catalog facts. Obtain with\n `duckdb_v2_table_description_get_column()`, read with `duckdb_v2_column_description_get_name()`,\n `duckdb_v2_column_description_get_type()`, `duckdb_v2_column_description_has_default()` and\n `duckdb_v2_column_description_has_generated()`, and destroy with `duckdb_v2_column_description_destroy()`."]
pub type duckdb_v2_column_description_handle = *mut _duckdb_v2_column_description;
#[doc = " An owned opaque handle to a custom copy function being built: an output format for `COPY ... TO`, an input format for\n `COPY ... FROM`, or both. Created with `duckdb_v2_copy_function_create()`, configured with the setter functions (e.g.\n `duckdb_v2_copy_function_set_name()`, `duckdb_v2_copy_to_set_batch_callback()`,\n `duckdb_v2_copy_from_set_exec_callback()`, etc.), made available with `duckdb_v2_connection_register_copy_function()`\n or `duckdb_v2_extension_register_copy_function()`, and destroyed with `duckdb_v2_copy_function_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_function {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a custom copy function being built: an output format for `COPY ... TO`, an input format for\n `COPY ... FROM`, or both. Created with `duckdb_v2_copy_function_create()`, configured with the setter functions (e.g.\n `duckdb_v2_copy_function_set_name()`, `duckdb_v2_copy_to_set_batch_callback()`,\n `duckdb_v2_copy_from_set_exec_callback()`, etc.), made available with `duckdb_v2_connection_register_copy_function()`\n or `duckdb_v2_extension_register_copy_function()`, and destroyed with `duckdb_v2_copy_function_destroy()`."]
pub type duckdb_v2_copy_function_handle = *mut _duckdb_v2_copy_function;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the query preparation \"bind\" phase of a\n `COPY ... TO` statement. The \"bind\" callback receives this handle and can use it to e.g. inspect the names and types\n of the columns being written, read the statement's options and initialize some constant state."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_to_bind_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the query preparation \"bind\" phase of a\n `COPY ... TO` statement. The \"bind\" callback receives this handle and can use it to e.g. inspect the names and types\n of the columns being written, read the statement's options and initialize some constant state."]
pub type duckdb_v2_copy_to_bind_info_handle = *mut _duckdb_v2_copy_to_bind_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the \"batch size\" phase of a `COPY ...\n TO` statement. The \"batch size\" callback receives this handle and must use it to report how many rows a batch should\n carry."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_to_batch_size_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the \"batch size\" phase of a `COPY ...\n TO` statement. The \"batch size\" callback receives this handle and must use it to report how many rows a batch should\n carry."]
pub type duckdb_v2_copy_to_batch_size_info_handle = *mut _duckdb_v2_copy_to_batch_size_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the per-file \"init\" phase of a `COPY ...\n TO` statement. The \"init\" callback receives this handle and can use it to e.g. read the path of the file being\n written and set up the state shared by every batch written to that file."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_to_init_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the per-file \"init\" phase of a `COPY ...\n TO` statement. The \"init\" callback receives this handle and can use it to e.g. read the path of the file being\n written and set up the state shared by every batch written to that file."]
pub type duckdb_v2_copy_to_init_info_handle = *mut _duckdb_v2_copy_to_init_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the \"batch\" phase of a `COPY ... TO`\n statement. The \"batch\" callback receives this handle and can use it to take ownership of the rows of the batch and to\n set the prepared form of the batch handed to the \"flush\" callback."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_to_batch_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the \"batch\" phase of a `COPY ... TO`\n statement. The \"batch\" callback receives this handle and can use it to take ownership of the rows of the batch and to\n set the prepared form of the batch handed to the \"flush\" callback."]
pub type duckdb_v2_copy_to_batch_info_handle = *mut _duckdb_v2_copy_to_batch_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the \"flush\" phase of a `COPY ... TO`\n statement. The \"flush\" callback receives this handle and can use it to access the prepared batch and write it to the\n output."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_to_flush_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the \"flush\" phase of a `COPY ... TO`\n statement. The \"flush\" callback receives this handle and can use it to access the prepared batch and write it to the\n output."]
pub type duckdb_v2_copy_to_flush_info_handle = *mut _duckdb_v2_copy_to_flush_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the per-file \"finalize\" phase of a `COPY\n ... TO` statement. The \"finalize\" callback receives this handle and can use it to e.g. close the file after every\n batch has been flushed to it."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_to_finalize_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the per-file \"finalize\" phase of a `COPY\n ... TO` statement. The \"finalize\" callback receives this handle and can use it to e.g. close the file after every\n batch has been flushed to it."]
pub type duckdb_v2_copy_to_finalize_info_handle = *mut _duckdb_v2_copy_to_finalize_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function when a `COPY ... TO` statement reports\n statistics about the files it wrote (e.g. with `RETURN_STATS`). The \"statistics\" callback receives this handle and\n uses it to report the statistics of one written file."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_to_statistics_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function when a `COPY ... TO` statement reports\n statistics about the files it wrote (e.g. with `RETURN_STATS`). The \"statistics\" callback receives this handle and\n uses it to report the statistics of one written file."]
pub type duckdb_v2_copy_to_statistics_info_handle = *mut _duckdb_v2_copy_to_statistics_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the query preparation \"bind\" phase of a\n `COPY ... FROM` statement. The \"bind\" callback receives this handle and can use it to e.g. read the path of the file\n to read, inspect the names and types of the columns the target table expects, read the statement's options, hint at\n the number of rows the read will produce and initialize some constant state."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_from_bind_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the query preparation \"bind\" phase of a\n `COPY ... FROM` statement. The \"bind\" callback receives this handle and can use it to e.g. read the path of the file\n to read, inspect the names and types of the columns the target table expects, read the statement's options, hint at\n the number of rows the read will produce and initialize some constant state."]
pub type duckdb_v2_copy_from_bind_info_handle = *mut _duckdb_v2_copy_from_bind_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the global state initialization \"init\n global\" phase of a `COPY ... FROM` statement. The \"init global\" callback receives this handle and can use it to e.g.\n set up the state shared by every thread reading the file, and to declare how many threads may read it."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_from_init_global_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the global state initialization \"init\n global\" phase of a `COPY ... FROM` statement. The \"init global\" callback receives this handle and can use it to e.g.\n set up the state shared by every thread reading the file, and to declare how many threads may read it."]
pub type duckdb_v2_copy_from_init_global_info_handle = *mut _duckdb_v2_copy_from_init_global_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the local state initialization \"init\n local\" phase of a `COPY ... FROM` statement. The \"init local\" callback receives this handle and can use it to e.g.\n set up worker-local state, typically by claiming work from the shared global state."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_from_init_local_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the local state initialization \"init\n local\" phase of a `COPY ... FROM` statement. The \"init local\" callback receives this handle and can use it to e.g.\n set up worker-local state, typically by claiming work from the shared global state."]
pub type duckdb_v2_copy_from_init_local_info_handle = *mut _duckdb_v2_copy_from_init_local_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the execution \"exec\" phase of a `COPY\n ... FROM` statement. The \"exec\" callback receives this handle and can use it to e.g. access the global and local\n state and write the next batch of rows to the output chunk."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_from_exec_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the execution \"exec\" phase of a `COPY\n ... FROM` statement. The \"exec\" callback receives this handle and can use it to e.g. access the global and local\n state and write the next batch of rows to the output chunk."]
pub type duckdb_v2_copy_from_exec_info_handle = *mut _duckdb_v2_copy_from_exec_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the \"progress\" phase of a `COPY ...\n FROM` statement. The \"progress\" callback receives this handle and can use it to report how far the read has advanced."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_copy_from_progress_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a copy function during the \"progress\" phase of a `COPY ...\n FROM` statement. The \"progress\" callback receives this handle and can use it to report how far the read has advanced."]
pub type duckdb_v2_copy_from_progress_info_handle = *mut _duckdb_v2_copy_from_progress_info;
pub type duckdb_v2_copy_to_bind_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_to_batch_size_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_size_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_to_init_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_to_init_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_to_batch_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_to_flush_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_to_flush_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_to_finalize_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_to_finalize_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_to_statistics_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_to_statistics_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_from_bind_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_from_init_global_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_global_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_from_init_local_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_local_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_from_exec_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_from_exec_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_copy_from_progress_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_copy_from_progress_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[doc = " An owned opaque handle to a custom option being built. Created with `duckdb_v2_custom_option_create()`, configured\n with the setter functions (e.g. `duckdb_v2_custom_option_set_name()`, `duckdb_v2_custom_option_set_type()`, etc.),\n made available with `duckdb_v2_connection_register_custom_option()` or\n `duckdb_v2_extension_register_custom_option()`, and destroyed with `duckdb_v2_custom_option_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_custom_option {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a custom option being built. Created with `duckdb_v2_custom_option_create()`, configured\n with the setter functions (e.g. `duckdb_v2_custom_option_set_name()`, `duckdb_v2_custom_option_set_type()`, etc.),\n made available with `duckdb_v2_connection_register_custom_option()` or\n `duckdb_v2_extension_register_custom_option()`, and destroyed with `duckdb_v2_custom_option_destroy()`."]
pub type duckdb_v2_custom_option_handle = *mut _duckdb_v2_custom_option;
#[doc = " A borrowed opaque handle to an update of a custom option, received by its update callback. It gives access to the new\n value, the scope it is written at and the user data, and can replace the value."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_custom_option_update_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to an update of a custom option, received by its update callback. It gives access to the new\n value, the scope it is written at and the user data, and can replace the value."]
pub type duckdb_v2_custom_option_update_info_handle = *mut _duckdb_v2_custom_option_update_info;
pub type duckdb_v2_custom_option_update_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_custom_option_update_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[repr(u32)]
#[non_exhaustive]
#[doc = " The type of a bound expression node. The values mirror the engine's own expression types, restricted to the node\n types a filter predicate can contain; every other node type is reported as `EXPRESSION_TYPE_INVALID`.\n\n Comparisons, `BETWEEN` and casts are regular scalar function calls once bound: they have the function's children and\n name, and only their type tells them apart from any other function. A `CAST` therefore has one child, the value being\n cast, and its target type is the node's return type."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_EXPRESSION_TYPE {
    #[doc = "! A node type this API does not model. Its children can still be walked."]
    DUCKDB_V2_EXPRESSION_TYPE_INVALID = 0,
    #[doc = " A cast. One child; the target type is the node's return type and `duckdb_v2_expression_cast_get_mode()` tells a\n `TRY_CAST` apart."]
    DUCKDB_V2_EXPRESSION_TYPE_OPERATOR_CAST = 12,
    #[doc = "! Logical `NOT`. One child."]
    DUCKDB_V2_EXPRESSION_TYPE_OPERATOR_NOT = 13,
    #[doc = "! `IS NULL`. One child."]
    DUCKDB_V2_EXPRESSION_TYPE_OPERATOR_IS_NULL = 14,
    #[doc = "! `IS NOT NULL`. One child."]
    DUCKDB_V2_EXPRESSION_TYPE_OPERATOR_IS_NOT_NULL = 15,
    #[doc = "! `=`. Two children."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_EQUAL = 25,
    #[doc = "! `<>`. Two children."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_NOTEQUAL = 26,
    #[doc = "! `<`. Two children."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_LESSTHAN = 27,
    #[doc = "! `>`. Two children."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_GREATERTHAN = 28,
    #[doc = "! `<=`. Two children."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_LESSTHANOREQUALTO = 29,
    #[doc = "! `>=`. Two children."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_GREATERTHANOREQUALTO = 30,
    #[doc = "! `IN`. The first child is the value tested, the remaining children are the candidates."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_IN = 35,
    #[doc = "! `NOT IN`. The first child is the value tested, the remaining children are the candidates."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_NOT_IN = 36,
    #[doc = "! `IS DISTINCT FROM`. Two children."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_DISTINCT_FROM = 37,
    #[doc = "! `BETWEEN`. Three children: the value tested, the lower bound and the upper bound."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_BETWEEN = 38,
    #[doc = "! `IS NOT DISTINCT FROM`. Two children."]
    DUCKDB_V2_EXPRESSION_TYPE_COMPARE_NOT_DISTINCT_FROM = 40,
    #[doc = "! Logical `AND`. Two or more children."]
    DUCKDB_V2_EXPRESSION_TYPE_CONJUNCTION_AND = 50,
    #[doc = "! Logical `OR`. Two or more children."]
    DUCKDB_V2_EXPRESSION_TYPE_CONJUNCTION_OR = 51,
    #[doc = "! A constant. No children; read it with `duckdb_v2_expression_constant_get_value()`."]
    DUCKDB_V2_EXPRESSION_TYPE_VALUE_CONSTANT = 75,
    #[doc = "! A prepared statement parameter whose value is not known yet. No children."]
    DUCKDB_V2_EXPRESSION_TYPE_VALUE_PARAMETER = 76,
    #[doc = " A call to a scalar function other than the ones listed above. The children are its arguments; read the name with\n `duckdb_v2_expression_function_get_name()`."]
    DUCKDB_V2_EXPRESSION_TYPE_BOUND_FUNCTION = 141,
    #[doc = "! A `CASE` expression. The children are each `WHEN` condition followed by its `THEN` result, then the `ELSE`\n! result."]
    DUCKDB_V2_EXPRESSION_TYPE_CASE_EXPR = 150,
    #[doc = "! `COALESCE`. One or more children."]
    DUCKDB_V2_EXPRESSION_TYPE_OPERATOR_COALESCE = 152,
    #[doc = "! A reference to a column. No children; read it with `duckdb_v2_expression_column_ref_get_index()`."]
    DUCKDB_V2_EXPRESSION_TYPE_BOUND_COLUMN_REF = 228,
    #[doc = "! A reference to a column. No children; read it with `duckdb_v2_expression_column_ref_get_index()`."]
    DUCKDB_V2_EXPRESSION_TYPE_MAX_ENUM = 2147483647,
}
#[doc = " A borrowed opaque handle to a node of a bound expression tree. Read-only and owned by the engine: valid only for the\n duration of the callback that handed it out, and never destroyed by the caller. Child nodes borrowed via\n `duckdb_v2_expression_get_child()` share their parent's lifetime."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_expression {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to a node of a bound expression tree. Read-only and owned by the engine: valid only for the\n duration of the callback that handed it out, and never destroyed by the caller. Child nodes borrowed via\n `duckdb_v2_expression_get_child()` share their parent's lifetime."]
pub type duckdb_v2_expression_handle = *mut _duckdb_v2_expression;
#[repr(u32)]
#[non_exhaustive]
#[doc = "! The scope a log entry was written in, which decides which of its ids are present."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_LOG_SCOPE {
    #[doc = "! Written for the database as a whole, carrying no connection, transaction or query id."]
    DUCKDB_V2_LOG_SCOPE_DATABASE = 10,
    #[doc = "! Written by a connection, carrying its connection id and, inside one, the transaction and query ids."]
    DUCKDB_V2_LOG_SCOPE_CONNECTION = 20,
    #[doc = "! Written by a thread executing a query, carrying the thread id next to the connection's ids."]
    DUCKDB_V2_LOG_SCOPE_THREAD = 30,
    #[doc = "! Written by a thread executing a query, carrying the thread id next to the connection's ids."]
    DUCKDB_V2_LOG_SCOPE_MAX_ENUM = 2147483647,
}
#[doc = " An owned opaque handle to a log sink being built. Created with `duckdb_v2_log_sink_create()`, configured with\n `duckdb_v2_log_sink_set_name()`, `duckdb_v2_log_sink_set_write_callback()` and the other setters, made available with\n `duckdb_v2_instance_register_log_sink()` or `duckdb_v2_extension_register_log_sink()`, and destroyed with\n `duckdb_v2_log_sink_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_log_sink {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a log sink being built. Created with `duckdb_v2_log_sink_create()`, configured with\n `duckdb_v2_log_sink_set_name()`, `duckdb_v2_log_sink_set_write_callback()` and the other setters, made available with\n `duckdb_v2_instance_register_log_sink()` or `duckdb_v2_extension_register_log_sink()`, and destroyed with\n `duckdb_v2_log_sink_destroy()`."]
pub type duckdb_v2_log_sink_handle = *mut _duckdb_v2_log_sink;
#[doc = " A borrowed opaque handle to the context of a log entry, received by a log sink's write callback next to the entry\n itself, and valid only for the duration of that call. Read the ids `duckdb_logs` reports for the entry through its\n getters, e.g. `duckdb_v2_log_sink_write_info_get_connection_id()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_log_sink_write_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the context of a log entry, received by a log sink's write callback next to the entry\n itself, and valid only for the duration of that call. Read the ids `duckdb_logs` reports for the entry through its\n getters, e.g. `duckdb_v2_log_sink_write_info_get_connection_id()`."]
pub type duckdb_v2_log_sink_write_info_handle = *mut _duckdb_v2_log_sink_write_info;
#[doc = " A borrowed opaque handle received by a log sink's flush callback, and valid only for the duration of that call. It\n carries nothing yet."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_log_sink_flush_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle received by a log sink's flush callback, and valid only for the duration of that call. It\n carries nothing yet."]
pub type duckdb_v2_log_sink_flush_info_handle = *mut _duckdb_v2_log_sink_flush_info;
pub type duckdb_v2_log_sink_write_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_log_sink_write_info_handle,
        user_data: *mut ::std::os::raw::c_void,
        timestamp: i64,
        level: DUCKDB_V2_LOG_LEVEL,
        scope: DUCKDB_V2_LOG_SCOPE,
        type_: *const duckdb_v2_str,
        message: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_log_sink_flush_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_log_sink_flush_info_handle,
        user_data: *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[repr(u32)]
#[non_exhaustive]
#[doc = " Logical type identifier. The values are the same integers DuckDB uses internally, so round-tripping is lossless. The\n bind- and UDF-only ids (UNKNOWN, ANY, TEMPLATE) appear here for completeness; they do not show up in result column\n types in practice."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_LOGICAL_TYPE_ID {
    #[doc = "! Invalid / unset."]
    DUCKDB_V2_LOGICAL_TYPE_ID_INVALID = 0,
    #[doc = "! NULL constant type."]
    DUCKDB_V2_LOGICAL_TYPE_ID_SQLNULL = 1,
    #[doc = "! Unknown — used for unresolved parameter expressions."]
    DUCKDB_V2_LOGICAL_TYPE_ID_UNKNOWN = 2,
    #[doc = "! ANY — used for functions that accept any type."]
    DUCKDB_V2_LOGICAL_TYPE_ID_ANY = 3,
    #[doc = "! A type carried as a value (type parameters). Values of this type are built via value_create_type."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TYPE = 6,
    #[doc = "! A type carried as a value (type parameters). Values of this type are built via value_create_type."]
    DUCKDB_V2_LOGICAL_TYPE_ID_BOOLEAN = 10,
    #[doc = "! A type carried as a value (type parameters). Values of this type are built via value_create_type."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TINYINT = 11,
    #[doc = "! A type carried as a value (type parameters). Values of this type are built via value_create_type."]
    DUCKDB_V2_LOGICAL_TYPE_ID_SMALLINT = 12,
    #[doc = "! A type carried as a value (type parameters). Values of this type are built via value_create_type."]
    DUCKDB_V2_LOGICAL_TYPE_ID_INTEGER = 13,
    #[doc = "! A type carried as a value (type parameters). Values of this type are built via value_create_type."]
    DUCKDB_V2_LOGICAL_TYPE_ID_BIGINT = 14,
    #[doc = "! 32-bit days since epoch."]
    DUCKDB_V2_LOGICAL_TYPE_ID_DATE = 15,
    #[doc = "! 64-bit microseconds since midnight."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIME = 16,
    #[doc = "! 64-bit seconds since epoch."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIMESTAMP_SEC = 17,
    #[doc = "! 64-bit milliseconds since epoch."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIMESTAMP_MS = 18,
    #[doc = "! 64-bit microseconds since epoch."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIMESTAMP = 19,
    #[doc = "! 64-bit nanoseconds since epoch."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIMESTAMP_NS = 20,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_DECIMAL = 21,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_FLOAT = 22,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_DOUBLE = 23,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_VARCHAR = 25,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_BLOB = 26,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_INTERVAL = 27,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_UTINYINT = 28,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_USMALLINT = 29,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_UINTEGER = 30,
    #[doc = "! Decimal with width and scale parameters."]
    DUCKDB_V2_LOGICAL_TYPE_ID_UBIGINT = 31,
    #[doc = "! 64-bit microseconds since epoch, timezone-aware."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIMESTAMP_TZ = 32,
    #[doc = "! 64-bit nanoseconds since epoch, timezone-aware."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIMESTAMP_TZ_NS = 33,
    #[doc = "! 64-bit microseconds since midnight + 32-bit offset."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIME_TZ = 34,
    #[doc = "! 64-bit nanoseconds since midnight."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TIME_NS = 35,
    #[doc = "! 64-bit nanoseconds since midnight."]
    DUCKDB_V2_LOGICAL_TYPE_ID_BIT = 36,
    #[doc = "! Arbitrary-precision integer (VARINT-encoded)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_BIGNUM = 39,
    #[doc = "! Arbitrary-precision integer (VARINT-encoded)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_UHUGEINT = 49,
    #[doc = "! Arbitrary-precision integer (VARINT-encoded)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_HUGEINT = 50,
    #[doc = "! Arbitrary-precision integer (VARINT-encoded)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_UUID = 54,
    #[doc = "! Geometry (spatial extension)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_GEOMETRY = 60,
    #[doc = "! Geometry (spatial extension)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_STRUCT = 100,
    #[doc = "! Geometry (spatial extension)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_LIST = 101,
    #[doc = "! Geometry (spatial extension)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_MAP = 102,
    #[doc = "! Geometry (spatial extension)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_ENUM = 104,
    #[doc = "! Geometry (spatial extension)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_UNION = 107,
    #[doc = "! Geometry (spatial extension)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_ARRAY = 108,
    #[doc = "! Geometry (spatial extension)."]
    DUCKDB_V2_LOGICAL_TYPE_ID_VARIANT = 109,
    #[doc = "! Unnamed struct; shares the physical representation of STRUCT."]
    DUCKDB_V2_LOGICAL_TYPE_ID_TUPLE = 110,
    #[doc = "! Unnamed struct; shares the physical representation of STRUCT."]
    DUCKDB_V2_LOGICAL_TYPE_ID_MAX_ENUM = 2147483647,
}
#[repr(u32)]
#[non_exhaustive]
#[doc = "! The kind of a macro function, deciding how its body is read. Pass one to `duckdb_v2_macro_function_create()`."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_MACRO_FUNCTION_TYPE {
    #[doc = "! A scalar macro. The body is a single expression, and the macro is called like a scalar function."]
    DUCKDB_V2_MACRO_FUNCTION_TYPE_SCALAR = 0,
    #[doc = "! A table macro. The body is a single SELECT query, and the macro is called like a table function."]
    DUCKDB_V2_MACRO_FUNCTION_TYPE_TABLE = 1,
    #[doc = "! A table macro. The body is a single SELECT query, and the macro is called like a table function."]
    DUCKDB_V2_MACRO_FUNCTION_TYPE_MAX_ENUM = 2147483647,
}
#[doc = " An owned opaque handle to a macro function being built. Created with `duckdb_v2_macro_function_create()`, configured\n with `duckdb_v2_macro_function_set_name()`, `duckdb_v2_macro_function_set_body()` and the signature obtained via\n `duckdb_v2_macro_function_get_signature()`, made available with `duckdb_v2_extension_register_macro_function()`, and\n destroyed with `duckdb_v2_macro_function_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_macro_function {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a macro function being built. Created with `duckdb_v2_macro_function_create()`, configured\n with `duckdb_v2_macro_function_set_name()`, `duckdb_v2_macro_function_set_body()` and the signature obtained via\n `duckdb_v2_macro_function_get_signature()`, made available with `duckdb_v2_extension_register_macro_function()`, and\n destroyed with `duckdb_v2_macro_function_destroy()`."]
pub type duckdb_v2_macro_function_handle = *mut _duckdb_v2_macro_function;
#[doc = " An owned opaque handle to a custom pragma function being built. Created with `duckdb_v2_pragma_function_create()`,\n configured with the setter functions (e.g. `duckdb_v2_pragma_function_set_name()`,\n `duckdb_v2_pragma_function_set_query_callback()`, etc.) and the signature obtained via\n `duckdb_v2_pragma_function_get_signature()`, made available with `duckdb_v2_connection_register_pragma_function()` or\n `duckdb_v2_extension_register_pragma_function()`, and destroyed with `duckdb_v2_pragma_function_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_pragma_function {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a custom pragma function being built. Created with `duckdb_v2_pragma_function_create()`,\n configured with the setter functions (e.g. `duckdb_v2_pragma_function_set_name()`,\n `duckdb_v2_pragma_function_set_query_callback()`, etc.) and the signature obtained via\n `duckdb_v2_pragma_function_get_signature()`, made available with `duckdb_v2_connection_register_pragma_function()` or\n `duckdb_v2_extension_register_pragma_function()`, and destroyed with `duckdb_v2_pragma_function_destroy()`."]
pub type duckdb_v2_pragma_function_handle = *mut _duckdb_v2_pragma_function;
#[doc = " A borrowed opaque handle to the result of a pragma function's \"query\" callback. The query callback receives this\n handle next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments and the user data, and\n uses it to set the query to run in place of the `PRAGMA` statement."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_pragma_function_query_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the result of a pragma function's \"query\" callback. The query callback receives this\n handle next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments and the user data, and\n uses it to set the query to run in place of the `PRAGMA` statement."]
pub type duckdb_v2_pragma_function_query_info_handle = *mut _duckdb_v2_pragma_function_query_info;
pub type duckdb_v2_pragma_function_query_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        result: duckdb_v2_pragma_function_query_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_pragma_function_exec_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[doc = " An owned opaque handle to a replacement scan being built. Created with `duckdb_v2_replacement_scan_create()`,\n configured with `duckdb_v2_replacement_scan_set_callback()` and `duckdb_v2_replacement_scan_set_user_data()`, made\n available with `duckdb_v2_connection_register_replacement_scan()`, `duckdb_v2_instance_register_replacement_scan()`\n or `duckdb_v2_extension_register_replacement_scan()`, and destroyed with `duckdb_v2_replacement_scan_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_replacement_scan {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a replacement scan being built. Created with `duckdb_v2_replacement_scan_create()`,\n configured with `duckdb_v2_replacement_scan_set_callback()` and `duckdb_v2_replacement_scan_set_user_data()`, made\n available with `duckdb_v2_connection_register_replacement_scan()`, `duckdb_v2_instance_register_replacement_scan()`\n or `duckdb_v2_extension_register_replacement_scan()`, and destroyed with `duckdb_v2_replacement_scan_destroy()`."]
pub type duckdb_v2_replacement_scan_handle = *mut _duckdb_v2_replacement_scan;
#[doc = " A borrowed opaque handle to the arguments supplied to a replacement scan when the binder consults it. The callback\n receives this handle and can use it to inspect the unresolved name and to claim it by naming what to read instead.\n Valid only for the duration of the callback; the name it hands out is owned separately and outlives it."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_replacement_scan_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a replacement scan when the binder consults it. The callback\n receives this handle and can use it to inspect the unresolved name and to claim it by naming what to read instead.\n Valid only for the duration of the callback; the name it hands out is owned separately and outlives it."]
pub type duckdb_v2_replacement_scan_info_handle = *mut _duckdb_v2_replacement_scan_info;
pub type duckdb_v2_replacement_scan_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[doc = " An owned opaque handle to a custom scalar function being built. Created with `duckdb_v2_scalar_function_create()`,\n configured with the setter functions (e.g. `duckdb_v2_scalar_function_set_name()`,\n `duckdb_v2_scalar_function_set_exec_callback()`, etc.) and the signature obtained via\n `duckdb_v2_scalar_function_get_signature()`, made available with `duckdb_v2_connection_register_scalar_function()` or\n `duckdb_v2_extension_register_scalar_function()`, and destroyed with `duckdb_v2_scalar_function_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_scalar_function {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a custom scalar function being built. Created with `duckdb_v2_scalar_function_create()`,\n configured with the setter functions (e.g. `duckdb_v2_scalar_function_set_name()`,\n `duckdb_v2_scalar_function_set_exec_callback()`, etc.) and the signature obtained via\n `duckdb_v2_scalar_function_get_signature()`, made available with `duckdb_v2_connection_register_scalar_function()` or\n `duckdb_v2_extension_register_scalar_function()`, and destroyed with `duckdb_v2_scalar_function_destroy()`."]
pub type duckdb_v2_scalar_function_handle = *mut _duckdb_v2_scalar_function;
#[doc = " A borrowed opaque handle to the result of a scalar function's \"resolve types\" phase. The \"resolve types\" callback\n receives this handle next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments and the\n user data, and can use it to set the return type of the call site being bound."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_scalar_function_resolve_types_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the result of a scalar function's \"resolve types\" phase. The \"resolve types\" callback\n receives this handle next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments and the\n user data, and can use it to set the return type of the call site being bound."]
pub type duckdb_v2_scalar_function_resolve_types_info_handle = *mut _duckdb_v2_scalar_function_resolve_types_info;
#[doc = " A borrowed opaque handle to the result of a scalar function's \"bind\" phase. The \"bind\" callback receives this handle\n next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments and the user data, and can use\n it to set the bind data of the call site being bound."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_scalar_function_bind_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the result of a scalar function's \"bind\" phase. The \"bind\" callback receives this handle\n next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments and the user data, and can use\n it to set the bind data of the call site being bound."]
pub type duckdb_v2_scalar_function_bind_info_handle = *mut _duckdb_v2_scalar_function_bind_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a scalar function during the local state initialization \"init\"\n phase. The \"init\" callback receives this handle and can use it to e.g. set up local state reusable across invocations\n of the \"exec\" execution callback."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_scalar_function_init_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a scalar function during the local state initialization \"init\"\n phase. The \"init\" callback receives this handle and can use it to e.g. set up local state reusable across invocations\n of the \"exec\" execution callback."]
pub type duckdb_v2_scalar_function_init_info_handle = *mut _duckdb_v2_scalar_function_init_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a scalar function during the execution \"exec\" phase. The \"exec\"\n callback receives this handle and can use it to e.g. access the input argument vectors, retrieve the number of rows\n to process, and write results to the output vector."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_scalar_function_exec_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a scalar function during the execution \"exec\" phase. The \"exec\"\n callback receives this handle and can use it to e.g. access the input argument vectors, retrieve the number of rows\n to process, and write results to the output vector."]
pub type duckdb_v2_scalar_function_exec_info_handle = *mut _duckdb_v2_scalar_function_exec_info;
pub type duckdb_v2_scalar_function_resolve_types_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        result: duckdb_v2_scalar_function_resolve_types_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_scalar_function_bind_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        result: duckdb_v2_scalar_function_bind_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_scalar_function_init_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_init_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_scalar_function_exec_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_exec_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[repr(u32)]
#[non_exhaustive]
#[doc = "! SQL statement type of a parsed statement or an executed query."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_STATEMENT_TYPE {
    DUCKDB_V2_STATEMENT_TYPE_INVALID = 0,
    DUCKDB_V2_STATEMENT_TYPE_SELECT = 1,
    DUCKDB_V2_STATEMENT_TYPE_INSERT = 2,
    DUCKDB_V2_STATEMENT_TYPE_UPDATE = 3,
    DUCKDB_V2_STATEMENT_TYPE_CREATE = 4,
    DUCKDB_V2_STATEMENT_TYPE_DELETE = 5,
    DUCKDB_V2_STATEMENT_TYPE_PREPARE = 6,
    DUCKDB_V2_STATEMENT_TYPE_EXECUTE = 7,
    DUCKDB_V2_STATEMENT_TYPE_ALTER = 8,
    DUCKDB_V2_STATEMENT_TYPE_TRANSACTION = 9,
    DUCKDB_V2_STATEMENT_TYPE_COPY = 10,
    DUCKDB_V2_STATEMENT_TYPE_ANALYZE = 11,
    DUCKDB_V2_STATEMENT_TYPE_VARIABLE_SET = 12,
    DUCKDB_V2_STATEMENT_TYPE_CREATE_FUNC = 13,
    DUCKDB_V2_STATEMENT_TYPE_EXPLAIN = 14,
    DUCKDB_V2_STATEMENT_TYPE_DROP = 15,
    DUCKDB_V2_STATEMENT_TYPE_EXPORT = 16,
    DUCKDB_V2_STATEMENT_TYPE_PRAGMA = 17,
    DUCKDB_V2_STATEMENT_TYPE_VACUUM = 18,
    DUCKDB_V2_STATEMENT_TYPE_CALL = 19,
    DUCKDB_V2_STATEMENT_TYPE_SET = 20,
    DUCKDB_V2_STATEMENT_TYPE_LOAD = 21,
    DUCKDB_V2_STATEMENT_TYPE_RELATION = 22,
    DUCKDB_V2_STATEMENT_TYPE_EXTENSION = 23,
    DUCKDB_V2_STATEMENT_TYPE_LOGICAL_PLAN = 24,
    DUCKDB_V2_STATEMENT_TYPE_ATTACH = 25,
    DUCKDB_V2_STATEMENT_TYPE_DETACH = 26,
    DUCKDB_V2_STATEMENT_TYPE_MULTI = 27,
    DUCKDB_V2_STATEMENT_TYPE_COPY_DATABASE = 28,
    DUCKDB_V2_STATEMENT_TYPE_UPDATE_EXTENSIONS = 29,
    DUCKDB_V2_STATEMENT_TYPE_MERGE_INTO = 30,
    DUCKDB_V2_STATEMENT_TYPE_CONNECT = 31,
    DUCKDB_V2_STATEMENT_TYPE_DISCONNECT = 32,
    DUCKDB_V2_STATEMENT_TYPE_EXTERNAL_RESOURCE = 33,
    DUCKDB_V2_STATEMENT_TYPE_PASSTHROUGH = 34,
    DUCKDB_V2_STATEMENT_TYPE_MAX_ENUM = 2147483647,
}
#[doc = " An opaque, owned handle to a single parsed SQL statement, produced by statement_iterator_next. statement_execute runs\n it without consuming it; the caller always destroys it via sql_statement_destroy."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_sql_statement {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to a single parsed SQL statement, produced by statement_iterator_next. statement_execute runs\n it without consuming it; the caller always destroys it via sql_statement_destroy."]
pub type duckdb_v2_sql_statement_handle = *mut _duckdb_v2_sql_statement;
#[doc = " An opaque, owned handle to an iterator over the statements of a SQL string, produced by parse_sql. Destroy it via\n statement_iterator_destroy; statements it already yielded are independently owned and unaffected."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_statement_iterator {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An opaque, owned handle to an iterator over the statements of a SQL string, produced by parse_sql. Destroy it via\n statement_iterator_destroy; statements it already yielded are independently owned and unaffected."]
pub type duckdb_v2_statement_iterator_handle = *mut _duckdb_v2_statement_iterator;
#[repr(u32)]
#[non_exhaustive]
#[doc = " Internal representation of a vector, with FSST / SEQUENCE / SHREDDED collapsed into OTHER: the view getter rejects\n those and requires an explicit vector_flatten first. OTHER is the 0-value, so a zero-initialized out-param reads as\n \"unspecified, needs flatten\" rather than silently looking like FLAT."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_VECTOR_TYPE {
    #[doc = "! Default for zero-init. Covers FSST / SEQUENCE / SHREDDED — call vector_flatten first."]
    DUCKDB_V2_VECTOR_TYPE_OTHER = 0,
    #[doc = "! Standard per-row storage."]
    DUCKDB_V2_VECTOR_TYPE_FLAT = 1,
    #[doc = "! A single value applies to every row in the vector."]
    DUCKDB_V2_VECTOR_TYPE_CONSTANT = 2,
    #[doc = "! Data + selection vector indirection into another vector."]
    DUCKDB_V2_VECTOR_TYPE_DICTIONARY = 3,
    #[doc = "! Data + selection vector indirection into another vector."]
    DUCKDB_V2_VECTOR_TYPE_MAX_ENUM = 2147483647,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_vector_view {
    pub data: *const ::std::os::raw::c_void,
    pub validity: *const u64,
    pub sel: *const duckdb_v2_sel_t,
    pub count: idx_t,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_list_entry {
    pub offset: idx_t,
    pub length: idx_t,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_hugeint_t {
    pub lower: u64,
    pub upper: i64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_uhugeint_t {
    pub lower: u64,
    pub upper: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_v2_interval_t {
    pub months: i32,
    pub days: i32,
    pub micros: i64,
}
#[doc = " An owned handle to a statement bound and planned once, executable repeatedly via\n `duckdb_v2_prepared_statement_execute()`. Construct with `duckdb_v2_prepared_statement_create()` and destroy with\n `duckdb_v2_prepared_statement_destroy()`. It keeps its connection's session alive, so it stays usable across\n executions and even after the connection is disconnected."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_prepared_statement {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned handle to a statement bound and planned once, executable repeatedly via\n `duckdb_v2_prepared_statement_execute()`. Construct with `duckdb_v2_prepared_statement_create()` and destroy with\n `duckdb_v2_prepared_statement_destroy()`. It keeps its connection's session alive, so it stays usable across\n executions and even after the connection is disconnected."]
pub type duckdb_v2_prepared_statement_handle = *mut _duckdb_v2_prepared_statement;
#[repr(u32)]
#[non_exhaustive]
#[doc = " Shape of a query result. QUERY_RESULT carries rows and columns; CHANGED_ROWS carries an affected row count, as an\n INSERT, UPDATE, or DELETE without RETURNING produces; NOTHING covers DDL and other statements with no row output."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_RESULT_TYPE {
    DUCKDB_V2_RESULT_TYPE_QUERY_RESULT = 0,
    DUCKDB_V2_RESULT_TYPE_CHANGED_ROWS = 1,
    DUCKDB_V2_RESULT_TYPE_NOTHING = 2,
    DUCKDB_V2_RESULT_TYPE_MAX_ENUM = 2147483647,
}
#[repr(u32)]
#[non_exhaustive]
#[doc = " Outcome of a result_step call. WAITING is the 0-value, so a zero-initialized out-param reads as \"no work product yet\"\n rather than CHUNK, the same convention VECTOR_TYPE_OTHER follows. The four states are the ones a consumer acts on;\n they are deliberately not a projection of any internal enum."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_RESULT_STEP_STATUS {
    #[doc = "! No chunk yet; step again, or block in result_wait."]
    DUCKDB_V2_RESULT_STEP_STATUS_WAITING = 0,
    #[doc = "! A caller-owned chunk was written to *out_chunk, or an array to *out_array."]
    DUCKDB_V2_RESULT_STEP_STATUS_CHUNK = 1,
    #[doc = "! Stream exhausted. Sticky."]
    DUCKDB_V2_RESULT_STEP_STATUS_FINISHED = 2,
    #[doc = "! Query was interrupted. Sticky."]
    DUCKDB_V2_RESULT_STEP_STATUS_CANCELLED = 3,
    #[doc = "! Query was interrupted. Sticky."]
    DUCKDB_V2_RESULT_STEP_STATUS_MAX_ENUM = 2147483647,
}
#[repr(u32)]
#[non_exhaustive]
#[doc = " Whether a table function's scan is partitioned by a given set of columns, and how. Reported by\n `duckdb_v2_table_function_set_partitioning_callback()` via\n `duckdb_v2_table_function_partitioning_set_partition_info()`."]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DUCKDB_V2_TABLE_PARTITION_INFO {
    #[doc = "! The scan is not known to be partitioned by the requested columns."]
    DUCKDB_V2_TABLE_PARTITION_INFO_NOT_PARTITIONED = 0,
    #[doc = "! Each partition the scan produces carries exactly one distinct value for the requested columns."]
    DUCKDB_V2_TABLE_PARTITION_INFO_SINGLE_VALUE_PARTITIONS = 1,
    #[doc = "! The partitions the scan produces overlap only at their boundaries."]
    DUCKDB_V2_TABLE_PARTITION_INFO_OVERLAPPING_PARTITIONS = 2,
    #[doc = "! The partitions the scan produces are disjoint ranges."]
    DUCKDB_V2_TABLE_PARTITION_INFO_DISJOINT_PARTITIONS = 3,
    #[doc = "! The partitions the scan produces are disjoint ranges."]
    DUCKDB_V2_TABLE_PARTITION_INFO_MAX_ENUM = 2147483647,
}
#[doc = " An owned opaque handle to a custom table function being built. Created with `duckdb_v2_table_function_create()`,\n configured with the setter functions (e.g. `duckdb_v2_table_function_set_name()`,\n `duckdb_v2_table_function_set_exec_callback()`, etc.) and the signature obtained via\n `duckdb_v2_table_function_get_signature()`, made available with `duckdb_v2_connection_register_table_function()` or\n `duckdb_v2_extension_register_table_function()`, and destroyed with `duckdb_v2_table_function_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a custom table function being built. Created with `duckdb_v2_table_function_create()`,\n configured with the setter functions (e.g. `duckdb_v2_table_function_set_name()`,\n `duckdb_v2_table_function_set_exec_callback()`, etc.) and the signature obtained via\n `duckdb_v2_table_function_get_signature()`, made available with `duckdb_v2_connection_register_table_function()` or\n `duckdb_v2_extension_register_table_function()`, and destroyed with `duckdb_v2_table_function_destroy()`."]
pub type duckdb_v2_table_function_handle = *mut _duckdb_v2_table_function;
#[doc = " A borrowed opaque handle to the result of a table function's \"bind\" phase. The \"bind\" callback receives this handle\n next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments, the user data and the bind\n data. It must use this handle to declare the columns the function returns, and can use it to hint at the number of\n rows the scan will produce."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_bind_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the result of a table function's \"bind\" phase. The \"bind\" callback receives this handle\n next to a `duckdb_v2_function_bind_info_handle`, which gives access to the arguments, the user data and the bind\n data. It must use this handle to declare the columns the function returns, and can use it to hint at the number of\n rows the scan will produce."]
pub type duckdb_v2_table_function_bind_info_handle = *mut _duckdb_v2_table_function_bind_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the global state initialization \"init\n global\" phase. The \"init global\" callback receives this handle and can use it to e.g. set up the state shared by\n every thread scanning the function, and to declare how many threads may scan it."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_init_global_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the global state initialization \"init\n global\" phase. The \"init global\" callback receives this handle and can use it to e.g. set up the state shared by\n every thread scanning the function, and to declare how many threads may scan it."]
pub type duckdb_v2_table_function_init_global_info_handle = *mut _duckdb_v2_table_function_init_global_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the local state initialization \"init\n local\" phase. The \"init local\" callback receives this handle and can use it to e.g. set up worker-local state,\n typically by claiming work from the shared global state."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_init_local_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the local state initialization \"init\n local\" phase. The \"init local\" callback receives this handle and can use it to e.g. set up worker-local state,\n typically by claiming work from the shared global state."]
pub type duckdb_v2_table_function_init_local_info_handle = *mut _duckdb_v2_table_function_init_local_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the execution \"exec\" phase. The \"exec\"\n callback receives this handle and can use it to e.g. access the global and local state and write the next batch of\n rows to the output chunk."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_exec_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the execution \"exec\" phase. The \"exec\"\n callback receives this handle and can use it to e.g. access the global and local state and write the next batch of\n rows to the output chunk."]
pub type duckdb_v2_table_function_exec_info_handle = *mut _duckdb_v2_table_function_exec_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the \"progress\" phase. The \"progress\"\n callback receives this handle and can use it to report how far the scan has advanced."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_progress_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the \"progress\" phase. The \"progress\"\n callback receives this handle and can use it to report how far the scan has advanced."]
pub type duckdb_v2_table_function_progress_info_handle = *mut _duckdb_v2_table_function_progress_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the \"filter pushdown\" phase of query\n optimization. The \"filter pushdown\" callback receives this handle and can use it to inspect the filter predicates the\n query applies to the function's rows, and to accept the ones it will apply itself."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_filter_pushdown_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the \"filter pushdown\" phase of query\n optimization. The \"filter pushdown\" callback receives this handle and can use it to inspect the filter predicates the\n query applies to the function's rows, and to accept the ones it will apply itself."]
pub type duckdb_v2_table_function_filter_pushdown_info_handle = *mut _duckdb_v2_table_function_filter_pushdown_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the \"partition data\" phase. The engine\n invokes the callback on the worker thread that just produced a batch of rows, once per batch, only when a downstream\n operator needs to know the batch's ordering position, the values of a set of partitioning columns, or both; the\n handle reports which of those were actually requested and receives the answer."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_partition_data_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the \"partition data\" phase. The engine\n invokes the callback on the worker thread that just produced a batch of rows, once per batch, only when a downstream\n operator needs to know the batch's ordering position, the values of a set of partitioning columns, or both; the\n handle reports which of those were actually requested and receives the answer."]
pub type duckdb_v2_table_function_partition_data_info_handle = *mut _duckdb_v2_table_function_partition_data_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the \"partitioning\" phase of query\n optimization. The engine invokes the callback once per candidate `GROUP BY` column set, before execution starts, to\n decide whether the scan can feed a partitioned aggregate directly instead of hashing."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_partitioning_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function during the \"partitioning\" phase of query\n optimization. The engine invokes the callback once per candidate `GROUP BY` column set, before execution starts, to\n decide whether the scan can feed a partitioned aggregate directly instead of hashing."]
pub type duckdb_v2_table_function_partitioning_info_handle = *mut _duckdb_v2_table_function_partitioning_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function when a scanning thread claims its next batch\n of work. The \"claim batch\" callback receives this handle and can use it to claim the next part of the scan from the\n shared global state for the thread's local state, and to report whether it claimed one."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_claim_batch_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function when a scanning thread claims its next batch\n of work. The \"claim batch\" callback receives this handle and can use it to claim the next part of the scan from the\n shared global state for the thread's local state, and to report whether it claimed one."]
pub type duckdb_v2_table_function_claim_batch_info_handle = *mut _duckdb_v2_table_function_claim_batch_info;
#[doc = " A borrowed opaque handle to the arguments supplied to a table function when the engine asks it to describe a bound\n call. The \"get bind info\" callback receives this handle, and can use it to describe the call in more detail than its\n columns: with identifiers of its columns (e.g. field ids), and with options - key-value facts about what the call\n reads."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_table_function_get_bind_info_info {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A borrowed opaque handle to the arguments supplied to a table function when the engine asks it to describe a bound\n call. The \"get bind info\" callback receives this handle, and can use it to describe the call in more detail than its\n columns: with identifiers of its columns (e.g. field ids), and with options - key-value facts about what the call\n reads."]
pub type duckdb_v2_table_function_get_bind_info_info_handle = *mut _duckdb_v2_table_function_get_bind_info_info;
#[doc = " An owned opaque handle to a multi-file table function being built. A multi-file function wraps an already registered\n table function that reads a single file, and adds everything that is needed to read many files at once on top of it:\n globbing, lists of files, hive partitioning, the `filename` column, `union_by_name` and the like. Created with\n `duckdb_v2_multi_file_function_create()`, configured with the setter functions (e.g.\n `duckdb_v2_multi_file_function_set_name()`, `duckdb_v2_multi_file_function_set_single_file_function()`), made\n available with `duckdb_v2_connection_register_multi_file_function()` or\n `duckdb_v2_extension_register_multi_file_function()`, and destroyed with `duckdb_v2_multi_file_function_destroy()`."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_multi_file_function {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " An owned opaque handle to a multi-file table function being built. A multi-file function wraps an already registered\n table function that reads a single file, and adds everything that is needed to read many files at once on top of it:\n globbing, lists of files, hive partitioning, the `filename` column, `union_by_name` and the like. Created with\n `duckdb_v2_multi_file_function_create()`, configured with the setter functions (e.g.\n `duckdb_v2_multi_file_function_set_name()`, `duckdb_v2_multi_file_function_set_single_file_function()`), made\n available with `duckdb_v2_connection_register_multi_file_function()` or\n `duckdb_v2_extension_register_multi_file_function()`, and destroyed with `duckdb_v2_multi_file_function_destroy()`."]
pub type duckdb_v2_multi_file_function_handle = *mut _duckdb_v2_multi_file_function;
pub type duckdb_v2_table_function_bind_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        result: duckdb_v2_table_function_bind_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_init_global_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_global_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_init_local_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_local_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_exec_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_exec_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_progress_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_progress_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_filter_pushdown_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_filter_pushdown_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_partition_data_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_partitioning_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_partitioning_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_claim_batch_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_claim_batch_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
pub type duckdb_v2_table_function_get_bind_info_callback_fn = ::std::option::Option<
    unsafe extern "C" fn(
        info: duckdb_v2_table_function_get_bind_info_info_handle,
        context: duckdb_v2_context_handle,
        err: *mut duckdb_v2_error_info_handle,
    ),
>;
#[doc = " Converts Arrow arrays into DuckDB data chunks, against one resolved ArrowSchema. Create it with\n `duckdb_v2_arrow_importer_create()`, which resolves every column's DuckDB type once, so the same importer serves any\n number of arrays of that shape. `duckdb_v2_arrow_importer_get_schema()` reports the resolved DuckDB schema.\n `duckdb_v2_arrow_importer_append()` takes an array, `duckdb_v2_arrow_importer_next_chunk()` produces chunks from it,\n and `duckdb_v2_arrow_importer_destroy()` frees the importer.\n\n The importer borrows the context it was created with and must not outlive it. One array is in flight at a time, and\n an importer must not be used from two threads at once."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_arrow_importer {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " Converts Arrow arrays into DuckDB data chunks, against one resolved ArrowSchema. Create it with\n `duckdb_v2_arrow_importer_create()`, which resolves every column's DuckDB type once, so the same importer serves any\n number of arrays of that shape. `duckdb_v2_arrow_importer_get_schema()` reports the resolved DuckDB schema.\n `duckdb_v2_arrow_importer_append()` takes an array, `duckdb_v2_arrow_importer_next_chunk()` produces chunks from it,\n and `duckdb_v2_arrow_importer_destroy()` frees the importer.\n\n The importer borrows the context it was created with and must not outlive it. One array is in flight at a time, and\n an importer must not be used from two threads at once."]
pub type duckdb_v2_arrow_importer_handle = *mut _duckdb_v2_arrow_importer;
#[doc = " Converts DuckDB data chunks into Arrow arrays, for one fixed list of columns. Create it with\n `duckdb_v2_arrow_exporter_create()`, which captures the session's Arrow settings and resolves the extension types\n once. `duckdb_v2_arrow_exporter_get_schema()` reports the Arrow schema. `duckdb_v2_arrow_exporter_append()` takes a\n chunk, `duckdb_v2_arrow_exporter_next_array()` produces arrays from it, and `duckdb_v2_arrow_exporter_destroy()`\n frees the exporter.\n\n An exporter must not be used from two threads at once."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_arrow_exporter {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " Converts DuckDB data chunks into Arrow arrays, for one fixed list of columns. Create it with\n `duckdb_v2_arrow_exporter_create()`, which captures the session's Arrow settings and resolves the extension types\n once. `duckdb_v2_arrow_exporter_get_schema()` reports the Arrow schema. `duckdb_v2_arrow_exporter_append()` takes a\n chunk, `duckdb_v2_arrow_exporter_next_array()` produces arrays from it, and `duckdb_v2_arrow_exporter_destroy()`\n frees the exporter.\n\n An exporter must not be used from two threads at once."]
pub type duckdb_v2_arrow_exporter_handle = *mut _duckdb_v2_arrow_exporter;
#[doc = " A query result that produces Arrow arrays. Works like a result, which produces data chunks. Create it with\n `duckdb_v2_statement_execute_arrow()` or `duckdb_v2_prepared_statement_execute_arrow()`.\n\n - Use it from one thread at a time.\n - `duckdb_v2_connection_interrupt()` cancels it: `duckdb_v2_arrow_result_step()` reports `CANCELLED`, and\n `duckdb_v2_arrow_result_fetch_array()` and a stream's `get_next` fail.\n - Arrays and schemas it hands out belong to the caller and stay valid after the result is destroyed."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _duckdb_v2_arrow_result {
    pub internal_ptr: *mut ::std::os::raw::c_void,
}
#[doc = " A query result that produces Arrow arrays. Works like a result, which produces data chunks. Create it with\n `duckdb_v2_statement_execute_arrow()` or `duckdb_v2_prepared_statement_execute_arrow()`.\n\n - Use it from one thread at a time.\n - `duckdb_v2_connection_interrupt()` cancels it: `duckdb_v2_arrow_result_step()` reports `CANCELLED`, and\n `duckdb_v2_arrow_result_fetch_array()` and a stream's `get_next` fail.\n - Arrays and schemas it hands out belong to the caller and stay valid after the result is destroyed."]
pub type duckdb_v2_arrow_result_handle = *mut _duckdb_v2_arrow_result;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct duckdb_ext_api_v2 {
    pub duckdb_v2_arena_allocate: ::std::option::Option<
        unsafe extern "C" fn(
            arena: duckdb_v2_arena_handle,
            byte_len: idx_t,
            out_ptr: *mut *mut u8,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_bignum_decode: ::std::option::Option<
        unsafe extern "C" fn(
            in_data: *const u8,
            in_length: idx_t,
            out_data: *mut u8,
            out_capacity: idx_t,
            out_length: *mut idx_t,
            out_is_negative: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_bignum_encode: ::std::option::Option<
        unsafe extern "C" fn(
            in_data: *const u8,
            in_length: idx_t,
            is_negative: bool,
            out_data: *mut u8,
            out_capacity: idx_t,
            out_length: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_append: ::std::option::Option<
        unsafe extern "C" fn(
            collection: duckdb_v2_column_data_collection_handle,
            state: duckdb_v2_column_data_collection_append_state_handle,
            chunk: duckdb_v2_data_chunk_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_append_state_create: ::std::option::Option<
        unsafe extern "C" fn(
            collection: duckdb_v2_column_data_collection_handle,
            out_state: *mut duckdb_v2_column_data_collection_append_state_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_append_state_destroy: ::std::option::Option<
        unsafe extern "C" fn(state: *mut duckdb_v2_column_data_collection_append_state_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_combine: ::std::option::Option<
        unsafe extern "C" fn(
            target: duckdb_v2_column_data_collection_handle,
            source: *mut duckdb_v2_column_data_collection_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            types_array: *const duckdb_v2_logical_type_handle,
            types_count: idx_t,
            out_collection: *mut duckdb_v2_column_data_collection_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_destroy: ::std::option::Option<
        unsafe extern "C" fn(collection: *mut duckdb_v2_column_data_collection_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_reset: ::std::option::Option<
        unsafe extern "C" fn(
            collection: duckdb_v2_column_data_collection_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_row_count: ::std::option::Option<
        unsafe extern "C" fn(
            collection: duckdb_v2_column_data_collection_handle,
            out_row_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_scan: ::std::option::Option<
        unsafe extern "C" fn(
            collection: duckdb_v2_column_data_collection_handle,
            shared_state: duckdb_v2_column_data_collection_shared_scan_state_handle,
            worker_state: duckdb_v2_column_data_collection_worker_scan_state_handle,
            out_chunk: duckdb_v2_data_chunk_handle,
            did_produce_chunk: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_shared_scan_state_create: ::std::option::Option<
        unsafe extern "C" fn(
            collection: duckdb_v2_column_data_collection_handle,
            out_state: *mut duckdb_v2_column_data_collection_shared_scan_state_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_shared_scan_state_destroy: ::std::option::Option<
        unsafe extern "C" fn(state: *mut duckdb_v2_column_data_collection_shared_scan_state_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_worker_scan_state_create: ::std::option::Option<
        unsafe extern "C" fn(
            collection: duckdb_v2_column_data_collection_handle,
            out_state: *mut duckdb_v2_column_data_collection_worker_scan_state_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_worker_scan_state_destroy: ::std::option::Option<
        unsafe extern "C" fn(state: *mut duckdb_v2_column_data_collection_worker_scan_state_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_config_get_option_by_index: ::std::option::Option<
        unsafe extern "C" fn(
            config: duckdb_v2_config_handle,
            index: idx_t,
            out_option: *mut duckdb_v2_option_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_config_get_option_by_name: ::std::option::Option<
        unsafe extern "C" fn(
            config: duckdb_v2_config_handle,
            name: *const duckdb_v2_identifier_t,
            out_option: *mut duckdb_v2_option_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_config_get_option_count: ::std::option::Option<
        unsafe extern "C" fn(
            config: duckdb_v2_config_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_create: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            out_conn: *mut duckdb_v2_connection_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_destroy:
        ::std::option::Option<unsafe extern "C" fn(conn: *mut duckdb_v2_connection_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_connection_interrupt: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_progress_get: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            out_percentage: *mut f64,
            out_rows_processed: *mut u64,
            out_total_rows_to_process: *mut u64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_data_chunk_copy: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            chunk: duckdb_v2_data_chunk_handle,
            out_chunk: *mut duckdb_v2_data_chunk_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_data_chunk_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            types: *const duckdb_v2_logical_type_handle,
            column_count: idx_t,
            out_chunk: *mut duckdb_v2_data_chunk_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_data_chunk_destroy:
        ::std::option::Option<unsafe extern "C" fn(chunk: *mut duckdb_v2_data_chunk_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_data_chunk_get_size: ::std::option::Option<
        unsafe extern "C" fn(
            chunk: duckdb_v2_data_chunk_handle,
            out_size: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_data_chunk_get_vector: ::std::option::Option<
        unsafe extern "C" fn(
            chunk: duckdb_v2_data_chunk_handle,
            index: idx_t,
            out_vector: *mut duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_data_chunk_get_vector_count: ::std::option::Option<
        unsafe extern "C" fn(
            chunk: duckdb_v2_data_chunk_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_environment_create: ::std::option::Option<
        unsafe extern "C" fn(
            out_env: *mut duckdb_v2_environment_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_environment_destroy:
        ::std::option::Option<unsafe extern "C" fn(env: *mut duckdb_v2_environment_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_environment_get_instance_count: ::std::option::Option<
        unsafe extern "C" fn(
            env: duckdb_v2_environment_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_error_info_destroy:
        ::std::option::Option<unsafe extern "C" fn(info: *mut duckdb_v2_error_info_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_error_info_get_code: ::std::option::Option<
        unsafe extern "C" fn(info: duckdb_v2_error_info_handle, out_code: *mut DUCKDB_V2_ERROR) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_error_info_get_raw_text: ::std::option::Option<
        unsafe extern "C" fn(info: duckdb_v2_error_info_handle, out_raw_text: *mut duckdb_v2_str) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_error_info_get_text: ::std::option::Option<
        unsafe extern "C" fn(info: duckdb_v2_error_info_handle, out_text: *mut duckdb_v2_str) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_error_info_set_code: ::std::option::Option<
        unsafe extern "C" fn(info: duckdb_v2_error_info_handle, code: DUCKDB_V2_ERROR) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_error_info_set_text: ::std::option::Option<
        unsafe extern "C" fn(info: duckdb_v2_error_info_handle, text: *const duckdb_v2_str) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_factory_create_type_from_id: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            type_id: DUCKDB_V2_LOGICAL_TYPE_ID,
            param_names: *const duckdb_v2_identifier_t,
            param_values: *const duckdb_v2_value_handle,
            param_count: idx_t,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_factory_create_type_from_name: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            name: duckdb_v2_qname_handle,
            param_names: *const duckdb_v2_identifier_t,
            param_values: *const duckdb_v2_value_handle,
            param_count: idx_t,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_factory_create_type_from_text: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            text: *const duckdb_v2_str,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_factory_create_type_with_alias: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            base_type: duckdb_v2_logical_type_handle,
            alias_name: *const duckdb_v2_identifier_t,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_attach: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            name: *const duckdb_v2_identifier_t,
            path: *const duckdb_v2_str,
            options: duckdb_v2_attach_options_handle,
            make_default: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_create: ::std::option::Option<
        unsafe extern "C" fn(
            env: duckdb_v2_environment_handle,
            out_instance: *mut duckdb_v2_instance_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_create_with_options: ::std::option::Option<
        unsafe extern "C" fn(
            env: duckdb_v2_environment_handle,
            option_names: *const duckdb_v2_str,
            option_values: *const duckdb_v2_str,
            option_count: idx_t,
            out_instance: *mut duckdb_v2_instance_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_destroy:
        ::std::option::Option<unsafe extern "C" fn(instance: *mut duckdb_v2_instance_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_instance_detach: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_library_version: ::std::option::Option<
        unsafe extern "C" fn(out_version: *mut duckdb_v2_str, err: *mut duckdb_v2_error_info_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_logical_type_copy: ::std::option::Option<
        unsafe extern "C" fn(
            type_: duckdb_v2_logical_type_handle,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_logical_type_destroy:
        ::std::option::Option<unsafe extern "C" fn(type_: *mut duckdb_v2_logical_type_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_logical_type_get_id: ::std::option::Option<
        unsafe extern "C" fn(
            type_: duckdb_v2_logical_type_handle,
            out_id: *mut DUCKDB_V2_LOGICAL_TYPE_ID,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_logical_type_get_name: ::std::option::Option<
        unsafe extern "C" fn(
            type_: duckdb_v2_logical_type_handle,
            out_name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_logical_type_get_param: ::std::option::Option<
        unsafe extern "C" fn(
            type_: duckdb_v2_logical_type_handle,
            index: idx_t,
            out_name: *mut duckdb_v2_identifier_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_logical_type_get_param_count: ::std::option::Option<
        unsafe extern "C" fn(
            type_: duckdb_v2_logical_type_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_logical_type_is_equal: ::std::option::Option<
        unsafe extern "C" fn(
            left: duckdb_v2_logical_type_handle,
            right: duckdb_v2_logical_type_handle,
            result: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_logical_type_to_text: ::std::option::Option<
        unsafe extern "C" fn(
            type_: duckdb_v2_logical_type_handle,
            out_text: *mut ::std::os::raw::c_char,
            out_capacity: idx_t,
            out_length: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_option_destroy:
        ::std::option::Option<unsafe extern "C" fn(option: *mut duckdb_v2_option_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_option_get_alias: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_option_handle,
            index: idx_t,
            out_alias: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_option_get_alias_count: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_option_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_option_get_default_value: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_option_handle,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_option_get_description: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_option_handle,
            out_description: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_option_get_name: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_option_handle,
            out_name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_parse_sql: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            sql: *const ::std::os::raw::c_char,
            out_iterator: *mut duckdb_v2_statement_iterator_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_result_destroy:
        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_v2_result_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_result_drain: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_result_handle,
            out_rows_changed: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_result_fetch_chunk: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_result_handle,
            out_chunk: *mut duckdb_v2_data_chunk_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_result_get_result_type: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_result_handle,
            out_type: *mut DUCKDB_V2_RESULT_TYPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_result_get_schema: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_result_handle,
            out_schema: *mut duckdb_v2_schema_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_result_get_statement_type: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_result_handle,
            out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_result_render_box: ::std::option::Option<
        unsafe extern "C" fn(
            result: *mut duckdb_v2_result_handle,
            max_rows: idx_t,
            max_width: idx_t,
            max_col_width: idx_t,
            null_value: *const duckdb_v2_str,
            render_mode: idx_t,
            limit: idx_t,
            sink: duckdb_v2_text_sink_fn,
            user_data: *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_result_step: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_result_handle,
            out_chunk: *mut duckdb_v2_data_chunk_handle,
            out_status: *mut DUCKDB_V2_RESULT_STEP_STATUS,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_result_wait: ::std::option::Option<
        unsafe extern "C" fn(result: duckdb_v2_result_handle, err: *mut duckdb_v2_error_info_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_schema_destroy:
        ::std::option::Option<unsafe extern "C" fn(schema: *mut duckdb_v2_schema_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_schema_get_count: ::std::option::Option<
        unsafe extern "C" fn(
            schema: duckdb_v2_schema_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_schema_get_field: ::std::option::Option<
        unsafe extern "C" fn(
            schema: duckdb_v2_schema_handle,
            index: idx_t,
            out_name: *mut duckdb_v2_identifier_t,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_sql_statement_destroy:
        ::std::option::Option<unsafe extern "C" fn(statement: *mut duckdb_v2_sql_statement_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_statement_bind: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            statement: duckdb_v2_sql_statement_handle,
            out_schema: *mut duckdb_v2_schema_handle,
            out_parameters: *mut duckdb_v2_schema_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_statement_execute: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            statement: duckdb_v2_sql_statement_handle,
            parameter_names: *const duckdb_v2_identifier_t,
            parameter_values: *const duckdb_v2_value_handle,
            parameter_count: idx_t,
            out_result: *mut duckdb_v2_result_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_statement_iterator_destroy: ::std::option::Option<
        unsafe extern "C" fn(iterator: *mut duckdb_v2_statement_iterator_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_statement_iterator_next: ::std::option::Option<
        unsafe extern "C" fn(
            iterator: duckdb_v2_statement_iterator_handle,
            out_statement: *mut duckdb_v2_sql_statement_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_cast: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            value: duckdb_v2_value_handle,
            target_type: duckdb_v2_logical_type_handle,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_array: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            child_type: duckdb_v2_logical_type_handle,
            children: *const duckdb_v2_value_handle,
            child_count: idx_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_bigint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_bignum: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_str,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_bit: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_str,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_blob: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_str,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_bool: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: bool,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_date: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i32,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_decimal: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_hugeint_t,
            width: u8,
            scale: u8,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_double: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: f64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_float: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: f32,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_hugeint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_hugeint_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_int: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i32,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_interval: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_interval_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_list: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            child_type: duckdb_v2_logical_type_handle,
            children: *const duckdb_v2_value_handle,
            child_count: idx_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_map: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            key_type: duckdb_v2_logical_type_handle,
            value_type: duckdb_v2_logical_type_handle,
            keys: *const duckdb_v2_value_handle,
            values: *const duckdb_v2_value_handle,
            entry_count: idx_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_null: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            type_: duckdb_v2_logical_type_handle,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_smallint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i16,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_struct: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            names: *const duckdb_v2_identifier_t,
            children: *const duckdb_v2_value_handle,
            field_count: idx_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_time: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_time_ns: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_time_tz: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: u64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_timestamp: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_timestamp_ms: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_timestamp_ns: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_timestamp_sec: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_timestamp_tz: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_timestamp_tz_ns: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_tinyint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: i8,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_tuple: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            children: *const duckdb_v2_value_handle,
            field_count: idx_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_type: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_type: duckdb_v2_logical_type_handle,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_ubigint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: u64,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_uhugeint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_uhugeint_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_uint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: u32,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_usmallint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: u16,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_utinyint: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: u8,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_uuid: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_hugeint_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_create_varchar: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            in_value: *const duckdb_v2_str,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_destroy:
        ::std::option::Option<unsafe extern "C" fn(value: *mut duckdb_v2_value_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_value_get_bigint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_blob: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_bool: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_child: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            index: idx_t,
            out_child: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_child_count: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_date: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i32,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_decimal: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut duckdb_v2_hugeint_t,
            out_width: *mut u8,
            out_scale: *mut u8,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_double: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut f64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_float: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut f32,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_hugeint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut duckdb_v2_hugeint_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_int: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i32,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_interval: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut duckdb_v2_interval_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_logical_type: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_smallint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i16,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_time: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_time_ns: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_time_tz: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut u64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_timestamp: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_timestamp_ms: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_timestamp_ns: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_timestamp_sec: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_timestamp_tz: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_timestamp_tz_ns: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_tinyint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut i8,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_type: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_ubigint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut u64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_uhugeint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut duckdb_v2_uhugeint_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_uint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut u32,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_usmallint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut u16,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_utinyint: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut u8,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_uuid: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut duckdb_v2_hugeint_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_get_varchar: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_is_null: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out_is_null: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_value_to_string: ::std::option::Option<
        unsafe extern "C" fn(
            value: duckdb_v2_value_handle,
            out_string: *mut ::std::os::raw::c_char,
            out_capacity: idx_t,
            out_length: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_constant_set_valid: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            validity: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_flat_get_validity_mutable: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            out_validity: *mut *mut u64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_flatten: ::std::option::Option<
        unsafe extern "C" fn(vector: duckdb_v2_vector_handle, err: *mut duckdb_v2_error_info_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_arena: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            out_arena: *mut duckdb_v2_arena_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_child: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            index: idx_t,
            out_child: *mut duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_child_count: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_data_mutable: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            out_data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_logical_type: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_size: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            out_size: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_value: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            row: idx_t,
            out_value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_vector_type: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            out_type: *mut DUCKDB_V2_VECTOR_TYPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_get_view: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            out_view: *mut duckdb_v2_vector_view,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_make_constant: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            value: duckdb_v2_value_handle,
            count: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_make_sequence: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            start: i64,
            increment: i64,
            count: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_reference: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            source: duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_set_null: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            row: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_set_size: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            size: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_set_value: ::std::option::Option<
        unsafe extern "C" fn(
            vector: duckdb_v2_vector_handle,
            row: idx_t,
            value: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_scalar_function: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            function: duckdb_v2_scalar_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_context_log: ::std::option::Option<
        unsafe extern "C" fn(
            ctx: duckdb_v2_context_handle,
            level: DUCKDB_V2_LOG_LEVEL,
            log_type: *const duckdb_v2_str,
            message: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_scalar_function: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            function: duckdb_v2_scalar_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_signature_add_parameter: ::std::option::Option<
        unsafe extern "C" fn(
            sig: duckdb_v2_function_signature_handle,
            name: *const duckdb_v2_identifier_t,
            type_: duckdb_v2_logical_type_handle,
            value: duckdb_v2_value_handle,
            kind: DUCKDB_V2_FUNCTION_PARAMETER_KIND,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_signature_set_return_type: ::std::option::Option<
        unsafe extern "C" fn(
            sig: duckdb_v2_function_signature_handle,
            type_: duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            function: *mut duckdb_v2_scalar_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_destroy:
        ::std::option::Option<unsafe extern "C" fn(function: *mut duckdb_v2_scalar_function_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_scalar_function_exec_get_arg: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_exec_info_handle,
            index: idx_t,
            vector: *mut duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_exec_get_arg_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_exec_info_handle,
            positional_fixed: *mut idx_t,
            positional_variadic: *mut idx_t,
            named_fixed: *mut idx_t,
            named_variadic: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_exec_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_exec_get_init_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_exec_get_result: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_exec_info_handle,
            vector: *mut duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_exec_get_row_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_exec_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_exec_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_get_signature: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            sig: *mut duckdb_v2_function_signature_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_init_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_init_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_init_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_init_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_init_set_init_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_init_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_set_bind_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            callback: duckdb_v2_scalar_function_bind_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_set_exec_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            callback: duckdb_v2_scalar_function_exec_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_set_init_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            callback: duckdb_v2_scalar_function_init_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_bind_set_return_type: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_bind_info_handle,
            return_type: duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_combine_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_combine_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_combine_get_sources: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_combine_info_handle,
            states: *mut *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_combine_get_state_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_combine_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_combine_get_targets: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_combine_info_handle,
            states: *mut *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_combine_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_combine_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            function: *mut duckdb_v2_aggregate_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_destroy: ::std::option::Option<
        unsafe extern "C" fn(function: *mut duckdb_v2_aggregate_function_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_destroy_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_destroy_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_destroy_get_state_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_destroy_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_destroy_get_states: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_destroy_info_handle,
            states: *mut *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_destroy_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_destroy_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_finalize_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_finalize_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_finalize_get_result: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_finalize_info_handle,
            vector: *mut duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_finalize_get_result_offset: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_finalize_info_handle,
            offset: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_finalize_get_state_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_finalize_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_finalize_get_states: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_finalize_info_handle,
            states: *mut *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_finalize_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_finalize_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_get_signature: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            sig: *mut duckdb_v2_function_signature_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_init_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_init_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_init_get_state_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_init_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_init_get_states: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_init_info_handle,
            states: *mut *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_init_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_init_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_bind_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            callback: duckdb_v2_aggregate_function_bind_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_combine_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            callback: duckdb_v2_aggregate_function_combine_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_destroy_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            callback: duckdb_v2_aggregate_function_destroy_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_finalize_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            callback: duckdb_v2_aggregate_function_finalize_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_init_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            callback: duckdb_v2_aggregate_function_init_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_size_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            callback: duckdb_v2_aggregate_function_size_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_update_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            callback: duckdb_v2_aggregate_function_update_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_size_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_size_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_size_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_size_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_size_set_state_size: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_size_info_handle,
            size: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_update_get_arg: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_update_info_handle,
            index: idx_t,
            vector: *mut duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_update_get_arg_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_update_info_handle,
            positional_fixed: *mut idx_t,
            positional_variadic: *mut idx_t,
            named_fixed: *mut idx_t,
            named_variadic: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_update_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_update_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_update_get_row_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_update_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_update_get_states: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_update_info_handle,
            states: *mut *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_update_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_aggregate_function_update_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_aggregate_function: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            function: duckdb_v2_aggregate_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_aggregate_function: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            function: duckdb_v2_aggregate_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_set_property: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            key: DUCKDB_V2_FUNCTION_PROPERTY_KEY,
            value: DUCKDB_V2_FUNCTION_PROPERTY_VALUE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_set_property: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            key: DUCKDB_V2_FUNCTION_PROPERTY_KEY,
            value: DUCKDB_V2_FUNCTION_PROPERTY_VALUE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_table_function: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            function: duckdb_v2_table_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_table_function: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            function: duckdb_v2_table_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_bind_add_result_column: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_bind_info_handle,
            name: *const duckdb_v2_identifier_t,
            type_: duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_bind_set_cardinality: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_bind_info_handle,
            cardinality: idx_t,
            is_exact: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            function: *mut duckdb_v2_table_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_destroy:
        ::std::option::Option<unsafe extern "C" fn(function: *mut duckdb_v2_table_function_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_table_function_exec_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_exec_get_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_exec_get_local_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_exec_get_output_chunk: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_exec_info_handle,
            chunk: *mut duckdb_v2_data_chunk_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_exec_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_get_signature: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            sig: *mut duckdb_v2_function_signature_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_global_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_global_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_global_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_global_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_global_set_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_global_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_global_set_max_threads: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_global_info_handle,
            max_threads: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_local_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_local_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_local_get_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_local_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_local_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_local_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_local_set_local_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_local_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_progress_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_progress_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_progress_get_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_progress_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_progress_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_progress_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_progress_set_progress: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_progress_info_handle,
            progress: f64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_bind_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_bind_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_exec_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_exec_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_init_global_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_init_global_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_init_local_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_init_local_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_progress_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_progress_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            function: *mut duckdb_v2_cast_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_destroy:
        ::std::option::Option<unsafe extern "C" fn(function: *mut duckdb_v2_cast_function_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_cast_function_exec_get_input: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_cast_function_exec_info_handle,
            vector: *mut duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_exec_get_mode: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_cast_function_exec_info_handle,
            mode: *mut DUCKDB_V2_CAST_MODE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_exec_get_output: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_cast_function_exec_info_handle,
            vector: *mut duckdb_v2_vector_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_exec_get_row_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_cast_function_exec_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_exec_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_cast_function_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_set_exec_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_cast_function_handle,
            callback: duckdb_v2_cast_function_exec_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_set_implicit_cast_cost: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_cast_function_handle,
            cost: i64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_set_source_type: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_cast_function_handle,
            source_type: duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_set_target_type: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_cast_function_handle,
            target_type: duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_cast_function_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_cast_function_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_data_collection_clear: ::std::option::Option<
        unsafe extern "C" fn(
            collection: duckdb_v2_column_data_collection_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_cast_function: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            function: duckdb_v2_cast_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_custom_type: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            type_: duckdb_v2_custom_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_replacement_scan: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            scan: duckdb_v2_replacement_scan_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_context_get_file_system: ::std::option::Option<
        unsafe extern "C" fn(
            context: duckdb_v2_context_handle,
            file_system: *mut duckdb_v2_file_system_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_type_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            type_: *mut duckdb_v2_custom_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_type_destroy:
        ::std::option::Option<unsafe extern "C" fn(type_: *mut duckdb_v2_custom_type_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_custom_type_set_base_type: ::std::option::Option<
        unsafe extern "C" fn(
            type_: duckdb_v2_custom_type_handle,
            base_type: duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_type_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            type_: duckdb_v2_custom_type_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_cast_function: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            function: duckdb_v2_cast_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_custom_type: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            type_: duckdb_v2_custom_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_replacement_scan: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            scan: duckdb_v2_replacement_scan_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_close: ::std::option::Option<
        unsafe extern "C" fn(file: duckdb_v2_file_handle, err: *mut duckdb_v2_error_info_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_destroy:
        ::std::option::Option<unsafe extern "C" fn(file: *mut duckdb_v2_file_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_file_open_options_create: ::std::option::Option<
        unsafe extern "C" fn(
            file_system: duckdb_v2_file_system_handle,
            options: *mut duckdb_v2_file_open_options_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_open_options_destroy: ::std::option::Option<
        unsafe extern "C" fn(options: *mut duckdb_v2_file_open_options_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_open_options_set_flag: ::std::option::Option<
        unsafe extern "C" fn(
            options: duckdb_v2_file_open_options_handle,
            flag: DUCKDB_V2_FILE_FLAG,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_open_options_set_value: ::std::option::Option<
        unsafe extern "C" fn(
            options: duckdb_v2_file_open_options_handle,
            name: *const duckdb_v2_str,
            value: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_read: ::std::option::Option<
        unsafe extern "C" fn(
            file: duckdb_v2_file_handle,
            buffer: *mut ::std::os::raw::c_void,
            buffer_size: idx_t,
            bytes_read: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_read_at: ::std::option::Option<
        unsafe extern "C" fn(
            file: duckdb_v2_file_handle,
            buffer: *mut ::std::os::raw::c_void,
            buffer_size: idx_t,
            location: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_seek: ::std::option::Option<
        unsafe extern "C" fn(
            file: duckdb_v2_file_handle,
            position: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_size: ::std::option::Option<
        unsafe extern "C" fn(
            file: duckdb_v2_file_handle,
            size: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_sync: ::std::option::Option<
        unsafe extern "C" fn(file: duckdb_v2_file_handle, err: *mut duckdb_v2_error_info_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_system_open: ::std::option::Option<
        unsafe extern "C" fn(
            file_system: duckdb_v2_file_system_handle,
            file_path: *const duckdb_v2_str,
            options: duckdb_v2_file_open_options_handle,
            file: *mut duckdb_v2_file_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_tell: ::std::option::Option<
        unsafe extern "C" fn(
            file: duckdb_v2_file_handle,
            position: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_write: ::std::option::Option<
        unsafe extern "C" fn(
            file: duckdb_v2_file_handle,
            buffer: *const ::std::os::raw::c_void,
            buffer_size: idx_t,
            bytes_written: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_write_at: ::std::option::Option<
        unsafe extern "C" fn(
            file: duckdb_v2_file_handle,
            buffer: *const ::std::os::raw::c_void,
            buffer_size: idx_t,
            location: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_register_replacement_scan: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            scan: duckdb_v2_replacement_scan_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_qname_create: ::std::option::Option<
        unsafe extern "C" fn(
            parts: *const duckdb_v2_identifier_t,
            part_count: idx_t,
            name: *mut duckdb_v2_qname_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_qname_destroy:
        ::std::option::Option<unsafe extern "C" fn(name: *mut duckdb_v2_qname_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_qname_equals: ::std::option::Option<
        unsafe extern "C" fn(
            left: duckdb_v2_qname_handle,
            right: duckdb_v2_qname_handle,
            result: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_qname_get_part: ::std::option::Option<
        unsafe extern "C" fn(
            name: duckdb_v2_qname_handle,
            index: idx_t,
            part: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_qname_get_part_count: ::std::option::Option<
        unsafe extern "C" fn(
            name: duckdb_v2_qname_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_qname_hash: ::std::option::Option<
        unsafe extern "C" fn(
            name: duckdb_v2_qname_handle,
            hash: *mut u64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_qname_parse: ::std::option::Option<
        unsafe extern "C" fn(
            text: *const duckdb_v2_str,
            name: *mut duckdb_v2_qname_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_qname_render: ::std::option::Option<
        unsafe extern "C" fn(
            name: duckdb_v2_qname_handle,
            out_text: *mut ::std::os::raw::c_char,
            out_capacity: idx_t,
            out_length: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_add_argument: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_replacement_scan_info_handle,
            value: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_add_named_argument: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_replacement_scan_info_handle,
            name: *const duckdb_v2_identifier_t,
            value: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            scan: *mut duckdb_v2_replacement_scan_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_destroy:
        ::std::option::Option<unsafe extern "C" fn(scan: *mut duckdb_v2_replacement_scan_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_replacement_scan_get_name: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_replacement_scan_info_handle,
            name: *mut duckdb_v2_qname_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_replacement_scan_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_set_alias: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_replacement_scan_info_handle,
            alias: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_set_callback: ::std::option::Option<
        unsafe extern "C" fn(
            scan: duckdb_v2_replacement_scan_handle,
            callback: duckdb_v2_replacement_scan_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_set_collection: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_replacement_scan_info_handle,
            collection: duckdb_v2_column_data_collection_handle,
            column_names: *const duckdb_v2_identifier_t,
            column_count: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_set_function_name: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_replacement_scan_info_handle,
            name: duckdb_v2_qname_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_set_subquery: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_replacement_scan_info_handle,
            sql: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_replacement_scan_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            scan: duckdb_v2_replacement_scan_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_exporter_append: ::std::option::Option<
        unsafe extern "C" fn(
            exporter: duckdb_v2_arrow_exporter_handle,
            chunk: *mut duckdb_v2_data_chunk_handle,
            consume: bool,
            flush: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_exporter_create: ::std::option::Option<
        unsafe extern "C" fn(
            context: duckdb_v2_context_handle,
            types: *const duckdb_v2_logical_type_handle,
            names: *const duckdb_v2_str,
            count: idx_t,
            batch_size: idx_t,
            out_exporter: *mut duckdb_v2_arrow_exporter_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_exporter_destroy:
        ::std::option::Option<unsafe extern "C" fn(exporter: *mut duckdb_v2_arrow_exporter_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_arrow_exporter_get_schema: ::std::option::Option<
        unsafe extern "C" fn(
            exporter: duckdb_v2_arrow_exporter_handle,
            out_schema: *mut ArrowSchema,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_exporter_next_array: ::std::option::Option<
        unsafe extern "C" fn(
            exporter: duckdb_v2_arrow_exporter_handle,
            out_array: *mut ArrowArray,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_importer_append: ::std::option::Option<
        unsafe extern "C" fn(
            importer: duckdb_v2_arrow_importer_handle,
            array: *mut ArrowArray,
            consume: bool,
            flush: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_importer_create: ::std::option::Option<
        unsafe extern "C" fn(
            context: duckdb_v2_context_handle,
            schema: *mut ArrowSchema,
            batch_size: idx_t,
            out_importer: *mut duckdb_v2_arrow_importer_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_importer_destroy:
        ::std::option::Option<unsafe extern "C" fn(importer: *mut duckdb_v2_arrow_importer_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_arrow_importer_get_schema: ::std::option::Option<
        unsafe extern "C" fn(
            importer: duckdb_v2_arrow_importer_handle,
            out_schema: *mut duckdb_v2_schema_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_importer_next_chunk: ::std::option::Option<
        unsafe extern "C" fn(
            importer: duckdb_v2_arrow_importer_handle,
            out_chunk: *mut duckdb_v2_data_chunk_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_description_destroy: ::std::option::Option<
        unsafe extern "C" fn(column: *mut duckdb_v2_column_description_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_description_get_name: ::std::option::Option<
        unsafe extern "C" fn(
            column: duckdb_v2_column_description_handle,
            name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_description_get_type: ::std::option::Option<
        unsafe extern "C" fn(
            column: duckdb_v2_column_description_handle,
            type_: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_description_has_default: ::std::option::Option<
        unsafe extern "C" fn(
            column: duckdb_v2_column_description_handle,
            has_default: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_column_description_has_generated: ::std::option::Option<
        unsafe extern "C" fn(
            column: duckdb_v2_column_description_handle,
            has_generated: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_describe_table: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            name: duckdb_v2_qname_handle,
            desc: *mut duckdb_v2_table_description_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_copy_function: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            function: duckdb_v2_copy_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_get_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_get_column_name: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            index: idx_t,
            name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_get_column_type: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            index: idx_t,
            type_: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_get_file_path: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            path: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_get_option_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_get_option_name: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            index: idx_t,
            name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_get_option_value: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            index: idx_t,
            value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_set_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_bind_set_cardinality: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_bind_info_handle,
            cardinality: idx_t,
            is_exact: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_exec_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_exec_get_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_exec_get_local_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_exec_get_output_chunk: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_exec_info_handle,
            chunk: *mut duckdb_v2_data_chunk_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_exec_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_exec_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_init_global_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_init_global_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_init_global_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_init_global_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_init_global_set_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_init_global_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_init_global_set_max_threads: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_init_global_info_handle,
            max_threads: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_init_local_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_init_local_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_init_local_get_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_init_local_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_init_local_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_init_local_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_init_local_set_local_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_init_local_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_progress_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_progress_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_progress_get_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_progress_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_progress_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_progress_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_progress_set_progress: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_from_progress_info_handle,
            progress: f64,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_set_bind_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_from_bind_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_set_exec_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_from_exec_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_set_init_global_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_from_init_global_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_set_init_local_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_from_init_local_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_from_set_progress_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_from_progress_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_function_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            function: *mut duckdb_v2_copy_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_function_destroy:
        ::std::option::Option<unsafe extern "C" fn(function: *mut duckdb_v2_copy_function_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_copy_function_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_function_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_batch_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_batch_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_batch_get_init_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_batch_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_batch_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_batch_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_batch_set_batch_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_batch_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_batch_size_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_batch_size_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_batch_size_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_batch_size_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_batch_size_set_target: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_batch_size_info_handle,
            rows: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_batch_take_input: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_batch_info_handle,
            collection: *mut duckdb_v2_column_data_collection_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_get_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_get_column_name: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            index: idx_t,
            name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_get_column_type: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            index: idx_t,
            type_: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_get_file_path: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            path: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_get_option_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_get_option_name: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            index: idx_t,
            name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_get_option_value: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            index: idx_t,
            value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_bind_set_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_bind_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_finalize_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_finalize_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_finalize_get_init_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_finalize_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_finalize_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_finalize_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_flush_get_batch_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_flush_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_flush_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_flush_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_flush_get_init_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_flush_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_flush_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_flush_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_init_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_init_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_init_get_file_path: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_init_info_handle,
            path: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_init_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_init_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_init_set_init_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_init_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_set_batch_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_to_batch_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_set_batch_size_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_to_batch_size_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_set_bind_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_to_bind_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_set_finalize_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_to_finalize_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_set_flush_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_to_flush_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_set_init_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_to_init_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_cast_get_mode: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            mode: *mut DUCKDB_V2_CAST_MODE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_column_ref_get_index: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            index: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_constant_get_value: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_function_get_name: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_function_get_qname: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            name: *mut duckdb_v2_qname_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_get_child: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            index: idx_t,
            child: *mut duckdb_v2_expression_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_get_child_count: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_get_return_type: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            type_: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_expression_get_type: ::std::option::Option<
        unsafe extern "C" fn(
            expression: duckdb_v2_expression_handle,
            type_: *mut DUCKDB_V2_EXPRESSION_TYPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_copy_function: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            function: duckdb_v2_copy_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_identifier_render_quoted: ::std::option::Option<
        unsafe extern "C" fn(
            name: *const duckdb_v2_identifier_t,
            out_text: *mut ::std::os::raw::c_char,
            out_capacity: idx_t,
            out_length: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_prepared_statement_create: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            statement: duckdb_v2_sql_statement_handle,
            require_cacheable: bool,
            out_prepared: *mut duckdb_v2_prepared_statement_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_prepared_statement_destroy: ::std::option::Option<
        unsafe extern "C" fn(prepared: *mut duckdb_v2_prepared_statement_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_prepared_statement_execute: ::std::option::Option<
        unsafe extern "C" fn(
            prepared: duckdb_v2_prepared_statement_handle,
            parameter_names: *const duckdb_v2_identifier_t,
            parameter_values: *const duckdb_v2_value_handle,
            parameter_count: idx_t,
            out_result: *mut duckdb_v2_result_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_prepared_statement_reuses_plan: ::std::option::Option<
        unsafe extern "C" fn(
            prepared: duckdb_v2_prepared_statement_handle,
            out_reuses: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_description_destroy:
        ::std::option::Option<unsafe extern "C" fn(desc: *mut duckdb_v2_table_description_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_table_description_get_column: ::std::option::Option<
        unsafe extern "C" fn(
            desc: duckdb_v2_table_description_handle,
            index: idx_t,
            column: *mut duckdb_v2_column_description_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_description_get_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            desc: duckdb_v2_table_description_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_description_get_qname: ::std::option::Option<
        unsafe extern "C" fn(
            desc: duckdb_v2_table_description_handle,
            name: *mut duckdb_v2_qname_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_description_is_readonly: ::std::option::Option<
        unsafe extern "C" fn(
            desc: duckdb_v2_table_description_handle,
            readonly: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_exec_get_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_exec_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_exec_get_column_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_exec_info_handle,
            index: idx_t,
            column_index: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_filter_pushdown_accept: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_filter_pushdown_info_handle,
            index: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_filter_pushdown_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_filter_pushdown_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_filter_pushdown_get_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_filter_pushdown_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_filter_pushdown_get_column_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_filter_pushdown_info_handle,
            index: idx_t,
            column_index: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_filter_pushdown_get_filter: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_filter_pushdown_info_handle,
            index: idx_t,
            filter: *mut duckdb_v2_expression_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_filter_pushdown_get_filter_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_filter_pushdown_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_filter_pushdown_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_filter_pushdown_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_global_get_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_global_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_global_get_column_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_global_info_handle,
            index: idx_t,
            column_index: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_local_get_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_local_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_init_local_get_column_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_init_local_info_handle,
            index: idx_t,
            column_index: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_filter_pushdown_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_filter_pushdown_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_projection_pushdown: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            enable: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_sql_statement_get_parameter_count: ::std::option::Option<
        unsafe extern "C" fn(
            statement: duckdb_v2_sql_statement_handle,
            out_count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_sql_statement_get_parameter_name: ::std::option::Option<
        unsafe extern "C" fn(
            statement: duckdb_v2_sql_statement_handle,
            index: idx_t,
            out_name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_sql_statement_get_text: ::std::option::Option<
        unsafe extern "C" fn(
            statement: duckdb_v2_sql_statement_handle,
            out_text: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_sql_statement_get_type: ::std::option::Option<
        unsafe extern "C" fn(
            statement: duckdb_v2_sql_statement_handle,
            out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_token_iterator_destroy:
        ::std::option::Option<unsafe extern "C" fn(iterator: *mut duckdb_v2_token_iterator_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_token_iterator_ends_unterminated: ::std::option::Option<
        unsafe extern "C" fn(
            iterator: duckdb_v2_token_iterator_handle,
            out_ends_unterminated: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_token_iterator_next: ::std::option::Option<
        unsafe extern "C" fn(
            iterator: duckdb_v2_token_iterator_handle,
            out_type: *mut DUCKDB_V2_TOKEN_TYPE,
            out_start: *mut idx_t,
            out_length: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_tokenize_sql: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            sql: *const duckdb_v2_str,
            out_iterator: *mut duckdb_v2_token_iterator_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_attach_options_create: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            out_options: *mut duckdb_v2_attach_options_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_attach_options_destroy:
        ::std::option::Option<unsafe extern "C" fn(options: *mut duckdb_v2_attach_options_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_attach_options_set: ::std::option::Option<
        unsafe extern "C" fn(
            options: duckdb_v2_attach_options_handle,
            key: *const duckdb_v2_identifier_t,
            setting: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_set_default: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_get_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_get_local_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_get_partition_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_get_partition_column_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            index: idx_t,
            column_index: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_requires_batch_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            required: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_requires_partition_columns: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            required: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_set_batch_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            batch_index: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partition_data_set_partition_value: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partition_data_info_handle,
            index: idx_t,
            value: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partitioning_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partitioning_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partitioning_get_partition_column_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partitioning_info_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partitioning_get_partition_column_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partitioning_info_handle,
            index: idx_t,
            column_index: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partitioning_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partitioning_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_partitioning_set_partition_info: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_partitioning_info_handle,
            partition_info: DUCKDB_V2_TABLE_PARTITION_INFO,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_partition_data_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_partition_data_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_partitioning_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_partitioning_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_validate_utf8: ::std::option::Option<
        unsafe extern "C" fn(text: *const duckdb_v2_str, err: *mut duckdb_v2_error_info_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_multi_file_function: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            function: duckdb_v2_multi_file_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_set_statistics_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            callback: duckdb_v2_copy_to_statistics_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_statistics_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_statistics_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_statistics_get_init_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_statistics_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_statistics_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_statistics_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_statistics_set_file_size: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_statistics_info_handle,
            file_size_bytes: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_to_statistics_set_row_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_copy_to_statistics_info_handle,
            row_count: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_data_chunk_get_capacity: ::std::option::Option<
        unsafe extern "C" fn(
            chunk: duckdb_v2_data_chunk_handle,
            out_capacity: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_multi_file_function: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            function: duckdb_v2_multi_file_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_multi_file_function_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            function: *mut duckdb_v2_multi_file_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_multi_file_function_destroy: ::std::option::Option<
        unsafe extern "C" fn(function: *mut duckdb_v2_multi_file_function_handle) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_multi_file_function_set_file_extension: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_multi_file_function_handle,
            extension: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_multi_file_function_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_multi_file_function_handle,
            name: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_multi_file_function_set_reader_type: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_multi_file_function_handle,
            reader_type: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_multi_file_function_set_single_file_function: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_multi_file_function_handle,
            name: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_claim_batch_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_claim_batch_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_claim_batch_get_global_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_claim_batch_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_claim_batch_get_local_state: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_claim_batch_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_claim_batch_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_claim_batch_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_claim_batch_set_claimed: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_claim_batch_info_handle,
            claimed: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_claim_batch_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_claim_batch_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_bind_get_arg_count: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_function_bind_info_handle,
            positional_fixed: *mut idx_t,
            positional_variadic: *mut idx_t,
            named_fixed: *mut idx_t,
            named_variadic: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_bind_get_arg_index: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_function_bind_info_handle,
            name: *const duckdb_v2_identifier_t,
            index: *mut idx_t,
            found: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_bind_get_arg_name: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_function_bind_info_handle,
            index: idx_t,
            name: *mut duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_bind_get_arg_type: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_function_bind_info_handle,
            index: idx_t,
            type_: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_bind_get_arg_value: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_function_bind_info_handle,
            index: idx_t,
            value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_bind_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_function_bind_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_bind_set_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_function_bind_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_bind_set_order_preservation: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_bind_info_handle,
            order: DUCKDB_V2_ORDER_PRESERVATION,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_result_destroy:
        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_v2_arrow_result_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_arrow_result_drain: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_arrow_result_handle,
            out_rows_changed: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_result_fetch_array: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_arrow_result_handle,
            out_array: *mut ArrowArray,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_result_get_result_type: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_arrow_result_handle,
            out_type: *mut DUCKDB_V2_RESULT_TYPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_result_get_schema: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_arrow_result_handle,
            out_schema: *mut ArrowSchema,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_result_get_statement_type: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_arrow_result_handle,
            out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_result_step: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_arrow_result_handle,
            out_array: *mut ArrowArray,
            out_status: *mut DUCKDB_V2_RESULT_STEP_STATUS,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_result_to_arrow_c_stream: ::std::option::Option<
        unsafe extern "C" fn(
            result: *mut duckdb_v2_arrow_result_handle,
            out_stream: *mut ArrowArrayStream,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_arrow_result_wait: ::std::option::Option<
        unsafe extern "C" fn(
            result: duckdb_v2_arrow_result_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_prepared_statement_execute_arrow: ::std::option::Option<
        unsafe extern "C" fn(
            prepared: duckdb_v2_prepared_statement_handle,
            parameter_names: *const duckdb_v2_identifier_t,
            parameter_values: *const duckdb_v2_value_handle,
            parameter_count: idx_t,
            batch_size: idx_t,
            out_result: *mut duckdb_v2_arrow_result_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_statement_execute_arrow: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            statement: duckdb_v2_sql_statement_handle,
            parameter_names: *const duckdb_v2_identifier_t,
            parameter_values: *const duckdb_v2_value_handle,
            parameter_count: idx_t,
            batch_size: idx_t,
            out_result: *mut duckdb_v2_arrow_result_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_resolve_types_set_return_type: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_resolve_types_info_handle,
            return_type: duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_set_resolve_types_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            callback: duckdb_v2_scalar_function_resolve_types_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_get_bind_info_get_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_get_bind_info_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_get_bind_info_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_get_bind_info_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_get_bind_info_set_column_identifier: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_get_bind_info_info_handle,
            column_index: idx_t,
            child_path: *const idx_t,
            child_path_length: idx_t,
            identifier: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_get_bind_info_set_option: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_table_function_get_bind_info_info_handle,
            key: *mut duckdb_v2_str,
            value: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_set_get_bind_info_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            callback: duckdb_v2_table_function_get_bind_info_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_get_factory: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            out_factory: *mut duckdb_v2_factory_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_context_get_factory: ::std::option::Option<
        unsafe extern "C" fn(
            ctx: duckdb_v2_context_handle,
            out_factory: *mut duckdb_v2_factory_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_get_factory: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            out_factory: *mut duckdb_v2_factory_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_bind_set_bind_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_scalar_function_bind_info_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_config_get_option_value: ::std::option::Option<
        unsafe extern "C" fn(
            config: duckdb_v2_config_handle,
            name: *const duckdb_v2_identifier_t,
            out_value: *mut duckdb_v2_value_handle,
            out_scope: *mut DUCKDB_V2_SETTING_SCOPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_config_set_option_text: ::std::option::Option<
        unsafe extern "C" fn(
            config: duckdb_v2_config_handle,
            name: *const duckdb_v2_identifier_t,
            setting: *const duckdb_v2_str,
            scope: DUCKDB_V2_SETTING_SCOPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_config_set_option_value: ::std::option::Option<
        unsafe extern "C" fn(
            config: duckdb_v2_config_handle,
            name: *const duckdb_v2_identifier_t,
            value: duckdb_v2_value_handle,
            scope: DUCKDB_V2_SETTING_SCOPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_get_config: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            out_config: *mut duckdb_v2_config_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_get_file_system: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            file_system: *mut duckdb_v2_file_system_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_log: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            level: DUCKDB_V2_LOG_LEVEL,
            log_type: *const duckdb_v2_str,
            message: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_context_get_config: ::std::option::Option<
        unsafe extern "C" fn(
            ctx: duckdb_v2_context_handle,
            out_config: *mut duckdb_v2_config_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_get_config: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            out_config: *mut duckdb_v2_config_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_get_file_system: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            file_system: *mut duckdb_v2_file_system_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_log: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            level: DUCKDB_V2_LOG_LEVEL,
            log_type: *const duckdb_v2_str,
            message: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_option_get_default_scope: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_option_handle,
            out_scope: *mut DUCKDB_V2_SETTING_SCOPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_option_supports_scope: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_option_handle,
            scope: DUCKDB_V2_SETTING_SCOPE,
            out_supported: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_aggregate_function_get_docs: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_aggregate_function_handle,
            docs: *mut duckdb_v2_function_docs_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_pragma_function: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            function: duckdb_v2_pragma_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_pragma_function: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            function: duckdb_v2_pragma_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_factory_create_common_type: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            types: *const duckdb_v2_logical_type_handle,
            type_count: idx_t,
            out_type: *mut duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_docs_add_category: ::std::option::Option<
        unsafe extern "C" fn(
            docs: duckdb_v2_function_docs_handle,
            category: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_docs_add_example: ::std::option::Option<
        unsafe extern "C" fn(
            docs: duckdb_v2_function_docs_handle,
            title: *const duckdb_v2_str,
            example: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_function_docs_set_description: ::std::option::Option<
        unsafe extern "C" fn(
            docs: duckdb_v2_function_docs_handle,
            description: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_pragma_function_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            function: *mut duckdb_v2_pragma_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_pragma_function_destroy:
        ::std::option::Option<unsafe extern "C" fn(function: *mut duckdb_v2_pragma_function_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_pragma_function_get_docs: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_pragma_function_handle,
            docs: *mut duckdb_v2_function_docs_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_pragma_function_get_signature: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_pragma_function_handle,
            sig: *mut duckdb_v2_function_signature_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_pragma_function_query_set_query: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_pragma_function_query_info_handle,
            query: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_pragma_function_set_exec_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_pragma_function_handle,
            callback: duckdb_v2_pragma_function_exec_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_pragma_function_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_pragma_function_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_pragma_function_set_query_callback: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_pragma_function_handle,
            callback: duckdb_v2_pragma_function_query_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_pragma_function_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_pragma_function_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_scalar_function_get_docs: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_scalar_function_handle,
            docs: *mut duckdb_v2_function_docs_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_table_function_get_docs: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_table_function_handle,
            docs: *mut duckdb_v2_function_docs_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_register_custom_option: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            option: duckdb_v2_custom_option_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            option: *mut duckdb_v2_custom_option_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_destroy:
        ::std::option::Option<unsafe extern "C" fn(option: *mut duckdb_v2_custom_option_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_custom_option_set_default_scope: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_custom_option_handle,
            scope: DUCKDB_V2_SETTING_SCOPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_set_default_value: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_custom_option_handle,
            value: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_set_description: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_custom_option_handle,
            description: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_custom_option_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_set_supports_scope: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_custom_option_handle,
            scope: DUCKDB_V2_SETTING_SCOPE,
            supported: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_set_type: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_custom_option_handle,
            type_: duckdb_v2_logical_type_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_set_update_callback: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_custom_option_handle,
            callback: duckdb_v2_custom_option_update_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            option: duckdb_v2_custom_option_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_update_get_scope: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_custom_option_update_info_handle,
            scope: *mut DUCKDB_V2_SETTING_SCOPE,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_update_get_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_custom_option_update_info_handle,
            data: *mut *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_update_get_value: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_custom_option_update_info_handle,
            value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_update_is_reset: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_custom_option_update_info_handle,
            is_reset: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_custom_option_update_set_value: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_custom_option_update_info_handle,
            value: duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_custom_option: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            option: duckdb_v2_custom_option_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_log_sink: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            sink: duckdb_v2_log_sink_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_extension_register_macro_function: ::std::option::Option<
        unsafe extern "C" fn(
            extension: duckdb_v2_extension_handle,
            function: duckdb_v2_macro_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_system_path_exists: ::std::option::Option<
        unsafe extern "C" fn(
            file_system: duckdb_v2_file_system_handle,
            path: *const duckdb_v2_str,
            out_exists: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_system_path_expand: ::std::option::Option<
        unsafe extern "C" fn(
            file_system: duckdb_v2_file_system_handle,
            path: *const duckdb_v2_str,
            sink: duckdb_v2_text_sink_fn,
            user_data: *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_system_path_is_remote: ::std::option::Option<
        unsafe extern "C" fn(
            file_system: duckdb_v2_file_system_handle,
            path: *const duckdb_v2_str,
            out_is_remote: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_instance_register_log_sink: ::std::option::Option<
        unsafe extern "C" fn(
            instance: duckdb_v2_instance_handle,
            sink: duckdb_v2_log_sink_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            sink: *mut duckdb_v2_log_sink_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_destroy:
        ::std::option::Option<unsafe extern "C" fn(sink: *mut duckdb_v2_log_sink_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_log_sink_set_flush_callback: ::std::option::Option<
        unsafe extern "C" fn(
            sink: duckdb_v2_log_sink_handle,
            callback: duckdb_v2_log_sink_flush_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            sink: duckdb_v2_log_sink_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_set_user_data: ::std::option::Option<
        unsafe extern "C" fn(
            sink: duckdb_v2_log_sink_handle,
            data: *mut duckdb_v2_opaque,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_set_write_callback: ::std::option::Option<
        unsafe extern "C" fn(
            sink: duckdb_v2_log_sink_handle,
            callback: duckdb_v2_log_sink_write_callback_fn,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_write_info_get_connection_id: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_log_sink_write_info_handle,
            id: *mut idx_t,
            present: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_write_info_get_query_id: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_log_sink_write_info_handle,
            id: *mut idx_t,
            present: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_write_info_get_thread_id: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_log_sink_write_info_handle,
            id: *mut idx_t,
            present: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_log_sink_write_info_get_transaction_id: ::std::option::Option<
        unsafe extern "C" fn(
            info: duckdb_v2_log_sink_write_info_handle,
            id: *mut idx_t,
            present: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_macro_function_create: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            type_: DUCKDB_V2_MACRO_FUNCTION_TYPE,
            function: *mut duckdb_v2_macro_function_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_macro_function_destroy:
        ::std::option::Option<unsafe extern "C" fn(function: *mut duckdb_v2_macro_function_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_macro_function_get_docs: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_macro_function_handle,
            docs: *mut duckdb_v2_function_docs_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_macro_function_get_signature: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_macro_function_handle,
            sig: *mut duckdb_v2_function_signature_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_macro_function_set_body: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_macro_function_handle,
            body: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_macro_function_set_name: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_macro_function_handle,
            name: *const duckdb_v2_identifier_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_vector_cast: ::std::option::Option<
        unsafe extern "C" fn(
            factory: duckdb_v2_factory_handle,
            source: duckdb_v2_vector_handle,
            target: duckdb_v2_vector_handle,
            mode: DUCKDB_V2_CAST_MODE,
            out_converted: *mut bool,
            cast_err: *mut duckdb_v2_error_info_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_enable_profiling: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            enabled: bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_connection_get_query_metrics: ::std::option::Option<
        unsafe extern "C" fn(
            conn: duckdb_v2_connection_handle,
            metrics: *mut duckdb_v2_query_metrics_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_copy_function_set_file_extension: ::std::option::Option<
        unsafe extern "C" fn(
            function: duckdb_v2_copy_function_handle,
            extension: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_data_chunk_clear: ::std::option::Option<
        unsafe extern "C" fn(
            chunk: duckdb_v2_data_chunk_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_system_path_glob: ::std::option::Option<
        unsafe extern "C" fn(
            file_system: duckdb_v2_file_system_handle,
            pattern: *const duckdb_v2_str,
            callback: duckdb_v2_file_system_path_glob_callback_fn,
            user_data: *mut ::std::os::raw::c_void,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_system_path_move: ::std::option::Option<
        unsafe extern "C" fn(
            file_system: duckdb_v2_file_system_handle,
            source: *const duckdb_v2_str,
            target: *const duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_file_system_path_remove: ::std::option::Option<
        unsafe extern "C" fn(
            file_system: duckdb_v2_file_system_handle,
            path: *const duckdb_v2_str,
            out_removed: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_query_metrics_destroy:
        ::std::option::Option<unsafe extern "C" fn(metrics: *mut duckdb_v2_query_metrics_handle) -> DUCKDB_V2_ERROR>,
    pub duckdb_v2_query_metrics_get_root: ::std::option::Option<
        unsafe extern "C" fn(
            metrics: duckdb_v2_query_metrics_handle,
            node: *mut duckdb_v2_query_metrics_node_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_query_metrics_node_get_child: ::std::option::Option<
        unsafe extern "C" fn(
            node: duckdb_v2_query_metrics_node_handle,
            index: idx_t,
            child: *mut duckdb_v2_query_metrics_node_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_query_metrics_node_get_child_count: ::std::option::Option<
        unsafe extern "C" fn(
            node: duckdb_v2_query_metrics_node_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_query_metrics_node_get_metric: ::std::option::Option<
        unsafe extern "C" fn(
            node: duckdb_v2_query_metrics_node_handle,
            name: *const duckdb_v2_str,
            value: *mut duckdb_v2_value_handle,
            present: *mut bool,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_query_metrics_node_get_metric_count: ::std::option::Option<
        unsafe extern "C" fn(
            node: duckdb_v2_query_metrics_node_handle,
            count: *mut idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_query_metrics_node_get_metric_name: ::std::option::Option<
        unsafe extern "C" fn(
            node: duckdb_v2_query_metrics_node_handle,
            index: idx_t,
            name: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_query_metrics_node_get_metric_value: ::std::option::Option<
        unsafe extern "C" fn(
            node: duckdb_v2_query_metrics_node_handle,
            index: idx_t,
            value: *mut duckdb_v2_value_handle,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_query_metrics_node_get_name: ::std::option::Option<
        unsafe extern "C" fn(
            node: duckdb_v2_query_metrics_node_handle,
            name: *mut duckdb_v2_str,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
    pub duckdb_v2_statement_add_collection: ::std::option::Option<
        unsafe extern "C" fn(
            statement: duckdb_v2_sql_statement_handle,
            name: *const duckdb_v2_identifier_t,
            collection: duckdb_v2_column_data_collection_handle,
            column_names: *const duckdb_v2_identifier_t,
            column_count: idx_t,
            err: *mut duckdb_v2_error_info_handle,
        ) -> DUCKDB_V2_ERROR,
    >,
}
static __DUCKDB_V2_ARENA_ALLOCATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arena_allocate(
    arena: duckdb_v2_arena_handle,
    byte_len: idx_t,
    out_ptr: *mut *mut u8,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARENA_ALLOCATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        arena: duckdb_v2_arena_handle,
        byte_len: idx_t,
        out_ptr: *mut *mut u8,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(arena, byte_len, out_ptr, err)
}

static __DUCKDB_V2_BIGNUM_DECODE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_bignum_decode(
    in_data: *const u8,
    in_length: idx_t,
    out_data: *mut u8,
    out_capacity: idx_t,
    out_length: *mut idx_t,
    out_is_negative: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_BIGNUM_DECODE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        in_data: *const u8,
        in_length: idx_t,
        out_data: *mut u8,
        out_capacity: idx_t,
        out_length: *mut idx_t,
        out_is_negative: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(in_data, in_length, out_data, out_capacity, out_length, out_is_negative, err)
}

static __DUCKDB_V2_BIGNUM_ENCODE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_bignum_encode(
    in_data: *const u8,
    in_length: idx_t,
    is_negative: bool,
    out_data: *mut u8,
    out_capacity: idx_t,
    out_length: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_BIGNUM_ENCODE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        in_data: *const u8,
        in_length: idx_t,
        is_negative: bool,
        out_data: *mut u8,
        out_capacity: idx_t,
        out_length: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(in_data, in_length, is_negative, out_data, out_capacity, out_length, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_data_collection_append(
    collection: duckdb_v2_column_data_collection_handle,
    state: duckdb_v2_column_data_collection_append_state_handle,
    chunk: duckdb_v2_data_chunk_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: duckdb_v2_column_data_collection_handle,
        state: duckdb_v2_column_data_collection_append_state_handle,
        chunk: duckdb_v2_data_chunk_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection, state, chunk, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND_STATE_CREATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_column_data_collection_append_state_create(
    collection: duckdb_v2_column_data_collection_handle,
    out_state: *mut duckdb_v2_column_data_collection_append_state_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND_STATE_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: duckdb_v2_column_data_collection_handle,
        out_state: *mut duckdb_v2_column_data_collection_append_state_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection, out_state, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND_STATE_DESTROY: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_column_data_collection_append_state_destroy(
    state: *mut duckdb_v2_column_data_collection_append_state_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND_STATE_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        state: *mut duckdb_v2_column_data_collection_append_state_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(state)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_COMBINE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_data_collection_combine(
    target: duckdb_v2_column_data_collection_handle,
    source: *mut duckdb_v2_column_data_collection_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_COMBINE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        target: duckdb_v2_column_data_collection_handle,
        source: *mut duckdb_v2_column_data_collection_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(target, source, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_data_collection_create(
    factory: duckdb_v2_factory_handle,
    types_array: *const duckdb_v2_logical_type_handle,
    types_count: idx_t,
    out_collection: *mut duckdb_v2_column_data_collection_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        types_array: *const duckdb_v2_logical_type_handle,
        types_count: idx_t,
        out_collection: *mut duckdb_v2_column_data_collection_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, types_array, types_count, out_collection, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_data_collection_destroy(
    collection: *mut duckdb_v2_column_data_collection_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: *mut duckdb_v2_column_data_collection_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_RESET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_data_collection_reset(
    collection: duckdb_v2_column_data_collection_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_RESET
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: duckdb_v2_column_data_collection_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_ROW_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_column_data_collection_row_count(
    collection: duckdb_v2_column_data_collection_handle,
    out_row_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_ROW_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: duckdb_v2_column_data_collection_handle,
        out_row_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection, out_row_count, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_SCAN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_data_collection_scan(
    collection: duckdb_v2_column_data_collection_handle,
    shared_state: duckdb_v2_column_data_collection_shared_scan_state_handle,
    worker_state: duckdb_v2_column_data_collection_worker_scan_state_handle,
    out_chunk: duckdb_v2_data_chunk_handle,
    did_produce_chunk: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_SCAN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: duckdb_v2_column_data_collection_handle,
        shared_state: duckdb_v2_column_data_collection_shared_scan_state_handle,
        worker_state: duckdb_v2_column_data_collection_worker_scan_state_handle,
        out_chunk: duckdb_v2_data_chunk_handle,
        did_produce_chunk: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection, shared_state, worker_state, out_chunk, did_produce_chunk, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_SHARED_SCAN_STATE_CREATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_column_data_collection_shared_scan_state_create(
    collection: duckdb_v2_column_data_collection_handle,
    out_state: *mut duckdb_v2_column_data_collection_shared_scan_state_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_SHARED_SCAN_STATE_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: duckdb_v2_column_data_collection_handle,
        out_state: *mut duckdb_v2_column_data_collection_shared_scan_state_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection, out_state, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_SHARED_SCAN_STATE_DESTROY: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_column_data_collection_shared_scan_state_destroy(
    state: *mut duckdb_v2_column_data_collection_shared_scan_state_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_SHARED_SCAN_STATE_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        state: *mut duckdb_v2_column_data_collection_shared_scan_state_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(state)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_WORKER_SCAN_STATE_CREATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_column_data_collection_worker_scan_state_create(
    collection: duckdb_v2_column_data_collection_handle,
    out_state: *mut duckdb_v2_column_data_collection_worker_scan_state_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_WORKER_SCAN_STATE_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: duckdb_v2_column_data_collection_handle,
        out_state: *mut duckdb_v2_column_data_collection_worker_scan_state_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection, out_state, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_WORKER_SCAN_STATE_DESTROY: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_column_data_collection_worker_scan_state_destroy(
    state: *mut duckdb_v2_column_data_collection_worker_scan_state_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_WORKER_SCAN_STATE_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        state: *mut duckdb_v2_column_data_collection_worker_scan_state_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(state)
}

static __DUCKDB_V2_CONFIG_GET_OPTION_BY_INDEX: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_config_get_option_by_index(
    config: duckdb_v2_config_handle,
    index: idx_t,
    out_option: *mut duckdb_v2_option_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONFIG_GET_OPTION_BY_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        config: duckdb_v2_config_handle,
        index: idx_t,
        out_option: *mut duckdb_v2_option_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(config, index, out_option, err)
}

static __DUCKDB_V2_CONFIG_GET_OPTION_BY_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_config_get_option_by_name(
    config: duckdb_v2_config_handle,
    name: *const duckdb_v2_identifier_t,
    out_option: *mut duckdb_v2_option_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONFIG_GET_OPTION_BY_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        config: duckdb_v2_config_handle,
        name: *const duckdb_v2_identifier_t,
        out_option: *mut duckdb_v2_option_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(config, name, out_option, err)
}

static __DUCKDB_V2_CONFIG_GET_OPTION_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_config_get_option_count(
    config: duckdb_v2_config_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONFIG_GET_OPTION_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        config: duckdb_v2_config_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(config, out_count, err)
}

static __DUCKDB_V2_CONNECTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_create(
    instance: duckdb_v2_instance_handle,
    out_conn: *mut duckdb_v2_connection_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        out_conn: *mut duckdb_v2_connection_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, out_conn, err)
}

static __DUCKDB_V2_CONNECTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_destroy(
    conn: *mut duckdb_v2_connection_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: *mut duckdb_v2_connection_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn)
}

static __DUCKDB_V2_CONNECTION_INTERRUPT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_interrupt(
    conn: duckdb_v2_connection_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_INTERRUPT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, err)
}

static __DUCKDB_V2_CONNECTION_PROGRESS_GET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_progress_get(
    conn: duckdb_v2_connection_handle,
    out_percentage: *mut f64,
    out_rows_processed: *mut u64,
    out_total_rows_to_process: *mut u64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_PROGRESS_GET
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        out_percentage: *mut f64,
        out_rows_processed: *mut u64,
        out_total_rows_to_process: *mut u64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, out_percentage, out_rows_processed, out_total_rows_to_process, err)
}

static __DUCKDB_V2_DATA_CHUNK_COPY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_data_chunk_copy(
    factory: duckdb_v2_factory_handle,
    chunk: duckdb_v2_data_chunk_handle,
    out_chunk: *mut duckdb_v2_data_chunk_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_DATA_CHUNK_COPY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        chunk: duckdb_v2_data_chunk_handle,
        out_chunk: *mut duckdb_v2_data_chunk_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, chunk, out_chunk, err)
}

static __DUCKDB_V2_DATA_CHUNK_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_data_chunk_create(
    factory: duckdb_v2_factory_handle,
    types: *const duckdb_v2_logical_type_handle,
    column_count: idx_t,
    out_chunk: *mut duckdb_v2_data_chunk_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_DATA_CHUNK_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        types: *const duckdb_v2_logical_type_handle,
        column_count: idx_t,
        out_chunk: *mut duckdb_v2_data_chunk_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, types, column_count, out_chunk, err)
}

static __DUCKDB_V2_DATA_CHUNK_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_data_chunk_destroy(
    chunk: *mut duckdb_v2_data_chunk_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_DATA_CHUNK_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        chunk: *mut duckdb_v2_data_chunk_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(chunk)
}

static __DUCKDB_V2_DATA_CHUNK_GET_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_data_chunk_get_size(
    chunk: duckdb_v2_data_chunk_handle,
    out_size: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_DATA_CHUNK_GET_SIZE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        chunk: duckdb_v2_data_chunk_handle,
        out_size: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(chunk, out_size, err)
}

static __DUCKDB_V2_DATA_CHUNK_GET_VECTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_data_chunk_get_vector(
    chunk: duckdb_v2_data_chunk_handle,
    index: idx_t,
    out_vector: *mut duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_DATA_CHUNK_GET_VECTOR
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        chunk: duckdb_v2_data_chunk_handle,
        index: idx_t,
        out_vector: *mut duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(chunk, index, out_vector, err)
}

static __DUCKDB_V2_DATA_CHUNK_GET_VECTOR_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_data_chunk_get_vector_count(
    chunk: duckdb_v2_data_chunk_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_DATA_CHUNK_GET_VECTOR_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        chunk: duckdb_v2_data_chunk_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(chunk, out_count, err)
}

static __DUCKDB_V2_ENVIRONMENT_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_environment_create(
    out_env: *mut duckdb_v2_environment_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ENVIRONMENT_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        out_env: *mut duckdb_v2_environment_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(out_env, err)
}

static __DUCKDB_V2_ENVIRONMENT_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_environment_destroy(
    env: *mut duckdb_v2_environment_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ENVIRONMENT_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        env: *mut duckdb_v2_environment_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(env)
}

static __DUCKDB_V2_ENVIRONMENT_GET_INSTANCE_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_environment_get_instance_count(
    env: duckdb_v2_environment_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ENVIRONMENT_GET_INSTANCE_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        env: duckdb_v2_environment_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(env, out_count, err)
}

static __DUCKDB_V2_ERROR_INFO_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_error_info_destroy(
    info: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ERROR_INFO_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info)
}

static __DUCKDB_V2_ERROR_INFO_GET_CODE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_error_info_get_code(
    info: duckdb_v2_error_info_handle,
    out_code: *mut DUCKDB_V2_ERROR,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ERROR_INFO_GET_CODE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_error_info_handle,
        out_code: *mut DUCKDB_V2_ERROR,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, out_code)
}

static __DUCKDB_V2_ERROR_INFO_GET_RAW_TEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_error_info_get_raw_text(
    info: duckdb_v2_error_info_handle,
    out_raw_text: *mut duckdb_v2_str,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ERROR_INFO_GET_RAW_TEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_error_info_handle,
        out_raw_text: *mut duckdb_v2_str,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, out_raw_text)
}

static __DUCKDB_V2_ERROR_INFO_GET_TEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_error_info_get_text(
    info: duckdb_v2_error_info_handle,
    out_text: *mut duckdb_v2_str,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ERROR_INFO_GET_TEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_error_info_handle,
        out_text: *mut duckdb_v2_str,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, out_text)
}

static __DUCKDB_V2_ERROR_INFO_SET_CODE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_error_info_set_code(
    info: duckdb_v2_error_info_handle,
    code: DUCKDB_V2_ERROR,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ERROR_INFO_SET_CODE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_error_info_handle,
        code: DUCKDB_V2_ERROR,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, code)
}

static __DUCKDB_V2_ERROR_INFO_SET_TEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_error_info_set_text(
    info: duckdb_v2_error_info_handle,
    text: *const duckdb_v2_str,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ERROR_INFO_SET_TEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_error_info_handle,
        text: *const duckdb_v2_str,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, text)
}

static __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_ID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_factory_create_type_from_id(
    factory: duckdb_v2_factory_handle,
    type_id: DUCKDB_V2_LOGICAL_TYPE_ID,
    param_names: *const duckdb_v2_identifier_t,
    param_values: *const duckdb_v2_value_handle,
    param_count: idx_t,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_ID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        type_id: DUCKDB_V2_LOGICAL_TYPE_ID,
        param_names: *const duckdb_v2_identifier_t,
        param_values: *const duckdb_v2_value_handle,
        param_count: idx_t,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, type_id, param_names, param_values, param_count, out_type, err)
}

static __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_factory_create_type_from_name(
    factory: duckdb_v2_factory_handle,
    name: duckdb_v2_qname_handle,
    param_names: *const duckdb_v2_identifier_t,
    param_values: *const duckdb_v2_value_handle,
    param_count: idx_t,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        name: duckdb_v2_qname_handle,
        param_names: *const duckdb_v2_identifier_t,
        param_values: *const duckdb_v2_value_handle,
        param_count: idx_t,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, name, param_names, param_values, param_count, out_type, err)
}

static __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_TEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_factory_create_type_from_text(
    factory: duckdb_v2_factory_handle,
    text: *const duckdb_v2_str,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_TEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        text: *const duckdb_v2_str,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, text, out_type, err)
}

static __DUCKDB_V2_FACTORY_CREATE_TYPE_WITH_ALIAS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_factory_create_type_with_alias(
    factory: duckdb_v2_factory_handle,
    base_type: duckdb_v2_logical_type_handle,
    alias_name: *const duckdb_v2_identifier_t,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FACTORY_CREATE_TYPE_WITH_ALIAS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        base_type: duckdb_v2_logical_type_handle,
        alias_name: *const duckdb_v2_identifier_t,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, base_type, alias_name, out_type, err)
}

static __DUCKDB_V2_INSTANCE_ATTACH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_attach(
    instance: duckdb_v2_instance_handle,
    name: *const duckdb_v2_identifier_t,
    path: *const duckdb_v2_str,
    options: duckdb_v2_attach_options_handle,
    make_default: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_ATTACH
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        name: *const duckdb_v2_identifier_t,
        path: *const duckdb_v2_str,
        options: duckdb_v2_attach_options_handle,
        make_default: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, name, path, options, make_default, err)
}

static __DUCKDB_V2_INSTANCE_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_create(
    env: duckdb_v2_environment_handle,
    out_instance: *mut duckdb_v2_instance_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        env: duckdb_v2_environment_handle,
        out_instance: *mut duckdb_v2_instance_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(env, out_instance, err)
}

static __DUCKDB_V2_INSTANCE_CREATE_WITH_OPTIONS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_create_with_options(
    env: duckdb_v2_environment_handle,
    option_names: *const duckdb_v2_str,
    option_values: *const duckdb_v2_str,
    option_count: idx_t,
    out_instance: *mut duckdb_v2_instance_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_CREATE_WITH_OPTIONS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        env: duckdb_v2_environment_handle,
        option_names: *const duckdb_v2_str,
        option_values: *const duckdb_v2_str,
        option_count: idx_t,
        out_instance: *mut duckdb_v2_instance_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(env, option_names, option_values, option_count, out_instance, err)
}

static __DUCKDB_V2_INSTANCE_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_destroy(
    instance: *mut duckdb_v2_instance_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: *mut duckdb_v2_instance_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance)
}

static __DUCKDB_V2_INSTANCE_DETACH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_detach(
    instance: duckdb_v2_instance_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_DETACH
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, name, err)
}

static __DUCKDB_V2_LIBRARY_VERSION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_library_version(
    out_version: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LIBRARY_VERSION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        out_version: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(out_version, err)
}

static __DUCKDB_V2_LOGICAL_TYPE_COPY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_logical_type_copy(
    type_: duckdb_v2_logical_type_handle,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOGICAL_TYPE_COPY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: duckdb_v2_logical_type_handle,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_, out_type, err)
}

static __DUCKDB_V2_LOGICAL_TYPE_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_logical_type_destroy(
    type_: *mut duckdb_v2_logical_type_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOGICAL_TYPE_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: *mut duckdb_v2_logical_type_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_)
}

static __DUCKDB_V2_LOGICAL_TYPE_GET_ID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_logical_type_get_id(
    type_: duckdb_v2_logical_type_handle,
    out_id: *mut DUCKDB_V2_LOGICAL_TYPE_ID,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOGICAL_TYPE_GET_ID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: duckdb_v2_logical_type_handle,
        out_id: *mut DUCKDB_V2_LOGICAL_TYPE_ID,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_, out_id, err)
}

static __DUCKDB_V2_LOGICAL_TYPE_GET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_logical_type_get_name(
    type_: duckdb_v2_logical_type_handle,
    out_name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOGICAL_TYPE_GET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: duckdb_v2_logical_type_handle,
        out_name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_, out_name, err)
}

static __DUCKDB_V2_LOGICAL_TYPE_GET_PARAM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_logical_type_get_param(
    type_: duckdb_v2_logical_type_handle,
    index: idx_t,
    out_name: *mut duckdb_v2_identifier_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOGICAL_TYPE_GET_PARAM
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: duckdb_v2_logical_type_handle,
        index: idx_t,
        out_name: *mut duckdb_v2_identifier_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_, index, out_name, out_value, err)
}

static __DUCKDB_V2_LOGICAL_TYPE_GET_PARAM_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_logical_type_get_param_count(
    type_: duckdb_v2_logical_type_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOGICAL_TYPE_GET_PARAM_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: duckdb_v2_logical_type_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_, out_count, err)
}

static __DUCKDB_V2_LOGICAL_TYPE_IS_EQUAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_logical_type_is_equal(
    left: duckdb_v2_logical_type_handle,
    right: duckdb_v2_logical_type_handle,
    result: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOGICAL_TYPE_IS_EQUAL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        left: duckdb_v2_logical_type_handle,
        right: duckdb_v2_logical_type_handle,
        result: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(left, right, result, err)
}

static __DUCKDB_V2_LOGICAL_TYPE_TO_TEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_logical_type_to_text(
    type_: duckdb_v2_logical_type_handle,
    out_text: *mut ::std::os::raw::c_char,
    out_capacity: idx_t,
    out_length: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOGICAL_TYPE_TO_TEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: duckdb_v2_logical_type_handle,
        out_text: *mut ::std::os::raw::c_char,
        out_capacity: idx_t,
        out_length: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_, out_text, out_capacity, out_length, err)
}

static __DUCKDB_V2_OPTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_option_destroy(
    option: *mut duckdb_v2_option_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_OPTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: *mut duckdb_v2_option_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option)
}

static __DUCKDB_V2_OPTION_GET_ALIAS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_option_get_alias(
    option: duckdb_v2_option_handle,
    index: idx_t,
    out_alias: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_OPTION_GET_ALIAS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_option_handle,
        index: idx_t,
        out_alias: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, index, out_alias, err)
}

static __DUCKDB_V2_OPTION_GET_ALIAS_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_option_get_alias_count(
    option: duckdb_v2_option_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_OPTION_GET_ALIAS_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_option_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, out_count, err)
}

static __DUCKDB_V2_OPTION_GET_DEFAULT_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_option_get_default_value(
    option: duckdb_v2_option_handle,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_OPTION_GET_DEFAULT_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_option_handle,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, out_value, err)
}

static __DUCKDB_V2_OPTION_GET_DESCRIPTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_option_get_description(
    option: duckdb_v2_option_handle,
    out_description: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_OPTION_GET_DESCRIPTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_option_handle,
        out_description: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, out_description, err)
}

static __DUCKDB_V2_OPTION_GET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_option_get_name(
    option: duckdb_v2_option_handle,
    out_name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_OPTION_GET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_option_handle,
        out_name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, out_name, err)
}

static __DUCKDB_V2_PARSE_SQL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_parse_sql(
    conn: duckdb_v2_connection_handle,
    sql: *const ::std::os::raw::c_char,
    out_iterator: *mut duckdb_v2_statement_iterator_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PARSE_SQL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        sql: *const ::std::os::raw::c_char,
        out_iterator: *mut duckdb_v2_statement_iterator_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, sql, out_iterator, err)
}

static __DUCKDB_V2_RESULT_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_destroy(
    result: *mut duckdb_v2_result_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: *mut duckdb_v2_result_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result)
}

static __DUCKDB_V2_RESULT_DRAIN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_drain(
    result: duckdb_v2_result_handle,
    out_rows_changed: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_DRAIN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_result_handle,
        out_rows_changed: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_rows_changed, err)
}

static __DUCKDB_V2_RESULT_FETCH_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_fetch_chunk(
    result: duckdb_v2_result_handle,
    out_chunk: *mut duckdb_v2_data_chunk_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_FETCH_CHUNK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_result_handle,
        out_chunk: *mut duckdb_v2_data_chunk_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_chunk, err)
}

static __DUCKDB_V2_RESULT_GET_RESULT_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_get_result_type(
    result: duckdb_v2_result_handle,
    out_type: *mut DUCKDB_V2_RESULT_TYPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_GET_RESULT_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_result_handle,
        out_type: *mut DUCKDB_V2_RESULT_TYPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_type, err)
}

static __DUCKDB_V2_RESULT_GET_SCHEMA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_get_schema(
    result: duckdb_v2_result_handle,
    out_schema: *mut duckdb_v2_schema_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_GET_SCHEMA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_result_handle,
        out_schema: *mut duckdb_v2_schema_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_schema, err)
}

static __DUCKDB_V2_RESULT_GET_STATEMENT_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_get_statement_type(
    result: duckdb_v2_result_handle,
    out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_GET_STATEMENT_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_result_handle,
        out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_type, err)
}

static __DUCKDB_V2_RESULT_RENDER_BOX: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_render_box(
    result: *mut duckdb_v2_result_handle,
    max_rows: idx_t,
    max_width: idx_t,
    max_col_width: idx_t,
    null_value: *const duckdb_v2_str,
    render_mode: idx_t,
    limit: idx_t,
    sink: duckdb_v2_text_sink_fn,
    user_data: *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_RENDER_BOX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: *mut duckdb_v2_result_handle,
        max_rows: idx_t,
        max_width: idx_t,
        max_col_width: idx_t,
        null_value: *const duckdb_v2_str,
        render_mode: idx_t,
        limit: idx_t,
        sink: duckdb_v2_text_sink_fn,
        user_data: *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(
        result,
        max_rows,
        max_width,
        max_col_width,
        null_value,
        render_mode,
        limit,
        sink,
        user_data,
        err,
    )
}

static __DUCKDB_V2_RESULT_STEP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_step(
    result: duckdb_v2_result_handle,
    out_chunk: *mut duckdb_v2_data_chunk_handle,
    out_status: *mut DUCKDB_V2_RESULT_STEP_STATUS,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_STEP
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_result_handle,
        out_chunk: *mut duckdb_v2_data_chunk_handle,
        out_status: *mut DUCKDB_V2_RESULT_STEP_STATUS,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_chunk, out_status, err)
}

static __DUCKDB_V2_RESULT_WAIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_result_wait(
    result: duckdb_v2_result_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_RESULT_WAIT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_result_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, err)
}

static __DUCKDB_V2_SCHEMA_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_schema_destroy(
    schema: *mut duckdb_v2_schema_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCHEMA_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        schema: *mut duckdb_v2_schema_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(schema)
}

static __DUCKDB_V2_SCHEMA_GET_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_schema_get_count(
    schema: duckdb_v2_schema_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCHEMA_GET_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        schema: duckdb_v2_schema_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(schema, out_count, err)
}

static __DUCKDB_V2_SCHEMA_GET_FIELD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_schema_get_field(
    schema: duckdb_v2_schema_handle,
    index: idx_t,
    out_name: *mut duckdb_v2_identifier_t,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCHEMA_GET_FIELD
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        schema: duckdb_v2_schema_handle,
        index: idx_t,
        out_name: *mut duckdb_v2_identifier_t,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(schema, index, out_name, out_type, err)
}

static __DUCKDB_V2_SQL_STATEMENT_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_sql_statement_destroy(
    statement: *mut duckdb_v2_sql_statement_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SQL_STATEMENT_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        statement: *mut duckdb_v2_sql_statement_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(statement)
}

static __DUCKDB_V2_STATEMENT_BIND: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_statement_bind(
    conn: duckdb_v2_connection_handle,
    statement: duckdb_v2_sql_statement_handle,
    out_schema: *mut duckdb_v2_schema_handle,
    out_parameters: *mut duckdb_v2_schema_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_STATEMENT_BIND
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        statement: duckdb_v2_sql_statement_handle,
        out_schema: *mut duckdb_v2_schema_handle,
        out_parameters: *mut duckdb_v2_schema_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, statement, out_schema, out_parameters, err)
}

static __DUCKDB_V2_STATEMENT_EXECUTE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_statement_execute(
    conn: duckdb_v2_connection_handle,
    statement: duckdb_v2_sql_statement_handle,
    parameter_names: *const duckdb_v2_identifier_t,
    parameter_values: *const duckdb_v2_value_handle,
    parameter_count: idx_t,
    out_result: *mut duckdb_v2_result_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_STATEMENT_EXECUTE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        statement: duckdb_v2_sql_statement_handle,
        parameter_names: *const duckdb_v2_identifier_t,
        parameter_values: *const duckdb_v2_value_handle,
        parameter_count: idx_t,
        out_result: *mut duckdb_v2_result_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(
        conn,
        statement,
        parameter_names,
        parameter_values,
        parameter_count,
        out_result,
        err,
    )
}

static __DUCKDB_V2_STATEMENT_ITERATOR_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_statement_iterator_destroy(
    iterator: *mut duckdb_v2_statement_iterator_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_STATEMENT_ITERATOR_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        iterator: *mut duckdb_v2_statement_iterator_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(iterator)
}

static __DUCKDB_V2_STATEMENT_ITERATOR_NEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_statement_iterator_next(
    iterator: duckdb_v2_statement_iterator_handle,
    out_statement: *mut duckdb_v2_sql_statement_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_STATEMENT_ITERATOR_NEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        iterator: duckdb_v2_statement_iterator_handle,
        out_statement: *mut duckdb_v2_sql_statement_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(iterator, out_statement, err)
}

static __DUCKDB_V2_VALUE_CAST: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_cast(
    factory: duckdb_v2_factory_handle,
    value: duckdb_v2_value_handle,
    target_type: duckdb_v2_logical_type_handle,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CAST
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        value: duckdb_v2_value_handle,
        target_type: duckdb_v2_logical_type_handle,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, value, target_type, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_ARRAY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_array(
    factory: duckdb_v2_factory_handle,
    child_type: duckdb_v2_logical_type_handle,
    children: *const duckdb_v2_value_handle,
    child_count: idx_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_ARRAY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        child_type: duckdb_v2_logical_type_handle,
        children: *const duckdb_v2_value_handle,
        child_count: idx_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, child_type, children, child_count, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_BIGINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_bigint(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_BIGINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_BIGNUM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_bignum(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_str,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_BIGNUM
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_str,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_BIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_bit(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_str,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_BIT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_str,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_BLOB: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_blob(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_str,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_BLOB
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_str,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_BOOL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_bool(
    factory: duckdb_v2_factory_handle,
    in_value: bool,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_BOOL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: bool,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_date(
    factory: duckdb_v2_factory_handle,
    in_value: i32,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_DATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i32,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_DECIMAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_decimal(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_hugeint_t,
    width: u8,
    scale: u8,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_DECIMAL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_hugeint_t,
        width: u8,
        scale: u8,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, width, scale, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_double(
    factory: duckdb_v2_factory_handle,
    in_value: f64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_DOUBLE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: f64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_FLOAT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_float(
    factory: duckdb_v2_factory_handle,
    in_value: f32,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_FLOAT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: f32,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_HUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_hugeint(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_hugeint_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_HUGEINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_hugeint_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_INT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_int(
    factory: duckdb_v2_factory_handle,
    in_value: i32,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_INT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i32,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_INTERVAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_interval(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_interval_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_INTERVAL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_interval_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_LIST: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_list(
    factory: duckdb_v2_factory_handle,
    child_type: duckdb_v2_logical_type_handle,
    children: *const duckdb_v2_value_handle,
    child_count: idx_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_LIST
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        child_type: duckdb_v2_logical_type_handle,
        children: *const duckdb_v2_value_handle,
        child_count: idx_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, child_type, children, child_count, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_MAP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_map(
    factory: duckdb_v2_factory_handle,
    key_type: duckdb_v2_logical_type_handle,
    value_type: duckdb_v2_logical_type_handle,
    keys: *const duckdb_v2_value_handle,
    values: *const duckdb_v2_value_handle,
    entry_count: idx_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_MAP
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        key_type: duckdb_v2_logical_type_handle,
        value_type: duckdb_v2_logical_type_handle,
        keys: *const duckdb_v2_value_handle,
        values: *const duckdb_v2_value_handle,
        entry_count: idx_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, key_type, value_type, keys, values, entry_count, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_NULL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_null(
    factory: duckdb_v2_factory_handle,
    type_: duckdb_v2_logical_type_handle,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_NULL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        type_: duckdb_v2_logical_type_handle,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, type_, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_SMALLINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_smallint(
    factory: duckdb_v2_factory_handle,
    in_value: i16,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_SMALLINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i16,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_STRUCT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_struct(
    factory: duckdb_v2_factory_handle,
    names: *const duckdb_v2_identifier_t,
    children: *const duckdb_v2_value_handle,
    field_count: idx_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_STRUCT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        names: *const duckdb_v2_identifier_t,
        children: *const duckdb_v2_value_handle,
        field_count: idx_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, names, children, field_count, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_time(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIME_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_time_ns(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIME_NS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIME_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_time_tz(
    factory: duckdb_v2_factory_handle,
    in_value: u64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIME_TZ
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: u64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_timestamp(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIMESTAMP
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_MS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_timestamp_ms(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_MS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_timestamp_ns(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_NS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_SEC: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_timestamp_sec(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_SEC
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_timestamp_tz(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_TZ
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_TZ_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_timestamp_tz_ns(
    factory: duckdb_v2_factory_handle,
    in_value: i64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_TZ_NS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TINYINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_tinyint(
    factory: duckdb_v2_factory_handle,
    in_value: i8,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TINYINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: i8,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TUPLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_tuple(
    factory: duckdb_v2_factory_handle,
    children: *const duckdb_v2_value_handle,
    field_count: idx_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TUPLE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        children: *const duckdb_v2_value_handle,
        field_count: idx_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, children, field_count, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_type(
    factory: duckdb_v2_factory_handle,
    in_type: duckdb_v2_logical_type_handle,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_type: duckdb_v2_logical_type_handle,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_type, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_UBIGINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_ubigint(
    factory: duckdb_v2_factory_handle,
    in_value: u64,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_UBIGINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: u64,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_UHUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_uhugeint(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_uhugeint_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_UHUGEINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_uhugeint_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_UINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_uint(
    factory: duckdb_v2_factory_handle,
    in_value: u32,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_UINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: u32,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_USMALLINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_usmallint(
    factory: duckdb_v2_factory_handle,
    in_value: u16,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_USMALLINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: u16,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_UTINYINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_utinyint(
    factory: duckdb_v2_factory_handle,
    in_value: u8,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_UTINYINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: u8,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_UUID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_uuid(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_hugeint_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_UUID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_hugeint_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_CREATE_VARCHAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_create_varchar(
    factory: duckdb_v2_factory_handle,
    in_value: *const duckdb_v2_str,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_CREATE_VARCHAR
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        in_value: *const duckdb_v2_str,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, in_value, out_value, err)
}

static __DUCKDB_V2_VALUE_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_destroy(
    value: *mut duckdb_v2_value_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: *mut duckdb_v2_value_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value)
}

static __DUCKDB_V2_VALUE_GET_BIGINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_bigint(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_BIGINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_BLOB: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_blob(
    value: duckdb_v2_value_handle,
    out: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_BLOB
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_BOOL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_bool(
    value: duckdb_v2_value_handle,
    out: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_BOOL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_child(
    value: duckdb_v2_value_handle,
    index: idx_t,
    out_child: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_CHILD
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        index: idx_t,
        out_child: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, index, out_child, err)
}

static __DUCKDB_V2_VALUE_GET_CHILD_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_child_count(
    value: duckdb_v2_value_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_CHILD_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out_count, err)
}

static __DUCKDB_V2_VALUE_GET_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_date(
    value: duckdb_v2_value_handle,
    out: *mut i32,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_DATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i32,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_DECIMAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_decimal(
    value: duckdb_v2_value_handle,
    out: *mut duckdb_v2_hugeint_t,
    out_width: *mut u8,
    out_scale: *mut u8,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_DECIMAL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut duckdb_v2_hugeint_t,
        out_width: *mut u8,
        out_scale: *mut u8,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, out_width, out_scale, err)
}

static __DUCKDB_V2_VALUE_GET_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_double(
    value: duckdb_v2_value_handle,
    out: *mut f64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_DOUBLE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut f64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_FLOAT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_float(
    value: duckdb_v2_value_handle,
    out: *mut f32,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_FLOAT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut f32,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_HUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_hugeint(
    value: duckdb_v2_value_handle,
    out: *mut duckdb_v2_hugeint_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_HUGEINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut duckdb_v2_hugeint_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_INT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_int(
    value: duckdb_v2_value_handle,
    out: *mut i32,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_INT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i32,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_INTERVAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_interval(
    value: duckdb_v2_value_handle,
    out: *mut duckdb_v2_interval_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_INTERVAL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut duckdb_v2_interval_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_LOGICAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_logical_type(
    value: duckdb_v2_value_handle,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_LOGICAL_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out_type, err)
}

static __DUCKDB_V2_VALUE_GET_SMALLINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_smallint(
    value: duckdb_v2_value_handle,
    out: *mut i16,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_SMALLINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i16,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_time(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIME_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_time_ns(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIME_NS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIME_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_time_tz(
    value: duckdb_v2_value_handle,
    out: *mut u64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIME_TZ
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut u64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_timestamp(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIMESTAMP
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIMESTAMP_MS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_timestamp_ms(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIMESTAMP_MS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIMESTAMP_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_timestamp_ns(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIMESTAMP_NS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIMESTAMP_SEC: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_timestamp_sec(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIMESTAMP_SEC
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIMESTAMP_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_timestamp_tz(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIMESTAMP_TZ
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TIMESTAMP_TZ_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_timestamp_tz_ns(
    value: duckdb_v2_value_handle,
    out: *mut i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TIMESTAMP_TZ_NS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TINYINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_tinyint(
    value: duckdb_v2_value_handle,
    out: *mut i8,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TINYINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut i8,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_type(
    value: duckdb_v2_value_handle,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out_type, err)
}

static __DUCKDB_V2_VALUE_GET_UBIGINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_ubigint(
    value: duckdb_v2_value_handle,
    out: *mut u64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_UBIGINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut u64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_UHUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_uhugeint(
    value: duckdb_v2_value_handle,
    out: *mut duckdb_v2_uhugeint_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_UHUGEINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut duckdb_v2_uhugeint_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_UINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_uint(
    value: duckdb_v2_value_handle,
    out: *mut u32,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_UINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut u32,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_USMALLINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_usmallint(
    value: duckdb_v2_value_handle,
    out: *mut u16,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_USMALLINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut u16,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_UTINYINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_utinyint(
    value: duckdb_v2_value_handle,
    out: *mut u8,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_UTINYINT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut u8,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_UUID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_uuid(
    value: duckdb_v2_value_handle,
    out: *mut duckdb_v2_hugeint_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_UUID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut duckdb_v2_hugeint_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_GET_VARCHAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_get_varchar(
    value: duckdb_v2_value_handle,
    out: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_GET_VARCHAR
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out, err)
}

static __DUCKDB_V2_VALUE_IS_NULL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_is_null(
    value: duckdb_v2_value_handle,
    out_is_null: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_IS_NULL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out_is_null: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out_is_null, err)
}

static __DUCKDB_V2_VALUE_TO_STRING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_value_to_string(
    value: duckdb_v2_value_handle,
    out_string: *mut ::std::os::raw::c_char,
    out_capacity: idx_t,
    out_length: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALUE_TO_STRING
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        value: duckdb_v2_value_handle,
        out_string: *mut ::std::os::raw::c_char,
        out_capacity: idx_t,
        out_length: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(value, out_string, out_capacity, out_length, err)
}

static __DUCKDB_V2_VECTOR_CONSTANT_SET_VALID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_constant_set_valid(
    vector: duckdb_v2_vector_handle,
    validity: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_CONSTANT_SET_VALID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        validity: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, validity, err)
}

static __DUCKDB_V2_VECTOR_FLAT_GET_VALIDITY_MUTABLE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_vector_flat_get_validity_mutable(
    vector: duckdb_v2_vector_handle,
    out_validity: *mut *mut u64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_FLAT_GET_VALIDITY_MUTABLE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        out_validity: *mut *mut u64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, out_validity, err)
}

static __DUCKDB_V2_VECTOR_FLATTEN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_flatten(
    vector: duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_FLATTEN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, err)
}

static __DUCKDB_V2_VECTOR_GET_ARENA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_arena(
    vector: duckdb_v2_vector_handle,
    out_arena: *mut duckdb_v2_arena_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_ARENA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        out_arena: *mut duckdb_v2_arena_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, out_arena, err)
}

static __DUCKDB_V2_VECTOR_GET_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_child(
    vector: duckdb_v2_vector_handle,
    index: idx_t,
    out_child: *mut duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_CHILD
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        index: idx_t,
        out_child: *mut duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, index, out_child, err)
}

static __DUCKDB_V2_VECTOR_GET_CHILD_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_child_count(
    vector: duckdb_v2_vector_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_CHILD_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, out_count, err)
}

static __DUCKDB_V2_VECTOR_GET_DATA_MUTABLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_data_mutable(
    vector: duckdb_v2_vector_handle,
    out_data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_DATA_MUTABLE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        out_data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, out_data, err)
}

static __DUCKDB_V2_VECTOR_GET_LOGICAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_logical_type(
    vector: duckdb_v2_vector_handle,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_LOGICAL_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, out_type, err)
}

static __DUCKDB_V2_VECTOR_GET_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_size(
    vector: duckdb_v2_vector_handle,
    out_size: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_SIZE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        out_size: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, out_size, err)
}

static __DUCKDB_V2_VECTOR_GET_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_value(
    vector: duckdb_v2_vector_handle,
    row: idx_t,
    out_value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        row: idx_t,
        out_value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, row, out_value, err)
}

static __DUCKDB_V2_VECTOR_GET_VECTOR_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_vector_type(
    vector: duckdb_v2_vector_handle,
    out_type: *mut DUCKDB_V2_VECTOR_TYPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_VECTOR_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        out_type: *mut DUCKDB_V2_VECTOR_TYPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, out_type, err)
}

static __DUCKDB_V2_VECTOR_GET_VIEW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_get_view(
    vector: duckdb_v2_vector_handle,
    out_view: *mut duckdb_v2_vector_view,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_GET_VIEW
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        out_view: *mut duckdb_v2_vector_view,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, out_view, err)
}

static __DUCKDB_V2_VECTOR_MAKE_CONSTANT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_make_constant(
    vector: duckdb_v2_vector_handle,
    value: duckdb_v2_value_handle,
    count: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_MAKE_CONSTANT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        value: duckdb_v2_value_handle,
        count: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, value, count, err)
}

static __DUCKDB_V2_VECTOR_MAKE_SEQUENCE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_make_sequence(
    vector: duckdb_v2_vector_handle,
    start: i64,
    increment: i64,
    count: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_MAKE_SEQUENCE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        start: i64,
        increment: i64,
        count: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, start, increment, count, err)
}

static __DUCKDB_V2_VECTOR_REFERENCE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_reference(
    vector: duckdb_v2_vector_handle,
    source: duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_REFERENCE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        source: duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, source, err)
}

static __DUCKDB_V2_VECTOR_SET_NULL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_set_null(
    vector: duckdb_v2_vector_handle,
    row: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_SET_NULL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        row: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, row, err)
}

static __DUCKDB_V2_VECTOR_SET_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_set_size(
    vector: duckdb_v2_vector_handle,
    size: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_SET_SIZE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        size: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, size, err)
}

static __DUCKDB_V2_VECTOR_SET_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_set_value(
    vector: duckdb_v2_vector_handle,
    row: idx_t,
    value: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_SET_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        vector: duckdb_v2_vector_handle,
        row: idx_t,
        value: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(vector, row, value, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_SCALAR_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_scalar_function(
    conn: duckdb_v2_connection_handle,
    function: duckdb_v2_scalar_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_SCALAR_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        function: duckdb_v2_scalar_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, function, err)
}

static __DUCKDB_V2_CONTEXT_LOG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_context_log(
    ctx: duckdb_v2_context_handle,
    level: DUCKDB_V2_LOG_LEVEL,
    log_type: *const duckdb_v2_str,
    message: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONTEXT_LOG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        ctx: duckdb_v2_context_handle,
        level: DUCKDB_V2_LOG_LEVEL,
        log_type: *const duckdb_v2_str,
        message: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(ctx, level, log_type, message, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_SCALAR_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_scalar_function(
    extension: duckdb_v2_extension_handle,
    function: duckdb_v2_scalar_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_SCALAR_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        function: duckdb_v2_scalar_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, function, err)
}

static __DUCKDB_V2_FUNCTION_SIGNATURE_ADD_PARAMETER: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_function_signature_add_parameter(
    sig: duckdb_v2_function_signature_handle,
    name: *const duckdb_v2_identifier_t,
    type_: duckdb_v2_logical_type_handle,
    value: duckdb_v2_value_handle,
    kind: DUCKDB_V2_FUNCTION_PARAMETER_KIND,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_SIGNATURE_ADD_PARAMETER
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        sig: duckdb_v2_function_signature_handle,
        name: *const duckdb_v2_identifier_t,
        type_: duckdb_v2_logical_type_handle,
        value: duckdb_v2_value_handle,
        kind: DUCKDB_V2_FUNCTION_PARAMETER_KIND,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(sig, name, type_, value, kind, err)
}

static __DUCKDB_V2_FUNCTION_SIGNATURE_SET_RETURN_TYPE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_function_signature_set_return_type(
    sig: duckdb_v2_function_signature_handle,
    type_: duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_SIGNATURE_SET_RETURN_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        sig: duckdb_v2_function_signature_handle,
        type_: duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(sig, type_, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_create(
    factory: duckdb_v2_factory_handle,
    function: *mut duckdb_v2_scalar_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        function: *mut duckdb_v2_scalar_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, function, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_destroy(
    function: *mut duckdb_v2_scalar_function_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: *mut duckdb_v2_scalar_function_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function)
}

static __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ARG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_exec_get_arg(
    info: duckdb_v2_scalar_function_exec_info_handle,
    index: idx_t,
    vector: *mut duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ARG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_exec_info_handle,
        index: idx_t,
        vector: *mut duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, vector, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ARG_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_exec_get_arg_count(
    info: duckdb_v2_scalar_function_exec_info_handle,
    positional_fixed: *mut idx_t,
    positional_variadic: *mut idx_t,
    named_fixed: *mut idx_t,
    named_variadic: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ARG_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_exec_info_handle,
        positional_fixed: *mut idx_t,
        positional_variadic: *mut idx_t,
        named_fixed: *mut idx_t,
        named_variadic: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, positional_fixed, positional_variadic, named_fixed, named_variadic, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_exec_get_bind_data(
    info: duckdb_v2_scalar_function_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_INIT_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_exec_get_init_data(
    info: duckdb_v2_scalar_function_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_INIT_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_RESULT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_exec_get_result(
    info: duckdb_v2_scalar_function_exec_info_handle,
    vector: *mut duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_RESULT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_exec_info_handle,
        vector: *mut duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, vector, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ROW_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_exec_get_row_count(
    info: duckdb_v2_scalar_function_exec_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ROW_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_exec_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_exec_get_user_data(
    info: duckdb_v2_scalar_function_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_GET_SIGNATURE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_get_signature(
    function: duckdb_v2_scalar_function_handle,
    sig: *mut duckdb_v2_function_signature_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_GET_SIGNATURE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        sig: *mut duckdb_v2_function_signature_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, sig, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_INIT_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_init_get_bind_data(
    info: duckdb_v2_scalar_function_init_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_INIT_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_init_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_INIT_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_init_get_user_data(
    info: duckdb_v2_scalar_function_init_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_INIT_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_init_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_INIT_SET_INIT_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_init_set_init_data(
    info: duckdb_v2_scalar_function_init_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_INIT_SET_INIT_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_init_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_SET_BIND_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_set_bind_callback(
    function: duckdb_v2_scalar_function_handle,
    callback: duckdb_v2_scalar_function_bind_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_SET_BIND_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        callback: duckdb_v2_scalar_function_bind_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_SET_EXEC_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_set_exec_callback(
    function: duckdb_v2_scalar_function_handle,
    callback: duckdb_v2_scalar_function_exec_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_SET_EXEC_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        callback: duckdb_v2_scalar_function_exec_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_SET_INIT_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_set_init_callback(
    function: duckdb_v2_scalar_function_handle,
    callback: duckdb_v2_scalar_function_init_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_SET_INIT_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        callback: duckdb_v2_scalar_function_init_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_set_name(
    function: duckdb_v2_scalar_function_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, name, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_set_user_data(
    function: duckdb_v2_scalar_function_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_BIND_SET_RETURN_TYPE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_bind_set_return_type(
    info: duckdb_v2_aggregate_function_bind_info_handle,
    return_type: duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_BIND_SET_RETURN_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_bind_info_handle,
        return_type: duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, return_type, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_combine_get_bind_data(
    info: duckdb_v2_aggregate_function_combine_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_combine_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_SOURCES: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_combine_get_sources(
    info: duckdb_v2_aggregate_function_combine_info_handle,
    states: *mut *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_SOURCES
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_combine_info_handle,
        states: *mut *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, states, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_STATE_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_combine_get_state_count(
    info: duckdb_v2_aggregate_function_combine_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_STATE_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_combine_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_TARGETS: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_combine_get_targets(
    info: duckdb_v2_aggregate_function_combine_info_handle,
    states: *mut *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_TARGETS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_combine_info_handle,
        states: *mut *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, states, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_combine_get_user_data(
    info: duckdb_v2_aggregate_function_combine_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_combine_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_aggregate_function_create(
    factory: duckdb_v2_factory_handle,
    function: *mut duckdb_v2_aggregate_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        function: *mut duckdb_v2_aggregate_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, function, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_aggregate_function_destroy(
    function: *mut duckdb_v2_aggregate_function_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: *mut duckdb_v2_aggregate_function_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_destroy_get_bind_data(
    info: duckdb_v2_aggregate_function_destroy_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_destroy_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_STATE_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_destroy_get_state_count(
    info: duckdb_v2_aggregate_function_destroy_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_STATE_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_destroy_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_STATES: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_destroy_get_states(
    info: duckdb_v2_aggregate_function_destroy_info_handle,
    states: *mut *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_STATES
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_destroy_info_handle,
        states: *mut *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, states, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_destroy_get_user_data(
    info: duckdb_v2_aggregate_function_destroy_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_destroy_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_finalize_get_bind_data(
    info: duckdb_v2_aggregate_function_finalize_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_finalize_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_RESULT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_finalize_get_result(
    info: duckdb_v2_aggregate_function_finalize_info_handle,
    vector: *mut duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_RESULT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_finalize_info_handle,
        vector: *mut duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, vector, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_RESULT_OFFSET: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_finalize_get_result_offset(
    info: duckdb_v2_aggregate_function_finalize_info_handle,
    offset: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_RESULT_OFFSET
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_finalize_info_handle,
        offset: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, offset, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_STATE_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_finalize_get_state_count(
    info: duckdb_v2_aggregate_function_finalize_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_STATE_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_finalize_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_STATES: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_finalize_get_states(
    info: duckdb_v2_aggregate_function_finalize_info_handle,
    states: *mut *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_STATES
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_finalize_info_handle,
        states: *mut *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, states, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_finalize_get_user_data(
    info: duckdb_v2_aggregate_function_finalize_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_finalize_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_GET_SIGNATURE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_get_signature(
    function: duckdb_v2_aggregate_function_handle,
    sig: *mut duckdb_v2_function_signature_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_GET_SIGNATURE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        sig: *mut duckdb_v2_function_signature_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, sig, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_init_get_bind_data(
    info: duckdb_v2_aggregate_function_init_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_init_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_STATE_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_init_get_state_count(
    info: duckdb_v2_aggregate_function_init_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_STATE_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_init_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_STATES: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_init_get_states(
    info: duckdb_v2_aggregate_function_init_info_handle,
    states: *mut *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_STATES
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_init_info_handle,
        states: *mut *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, states, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_init_get_user_data(
    info: duckdb_v2_aggregate_function_init_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_init_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_BIND_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_bind_callback(
    function: duckdb_v2_aggregate_function_handle,
    callback: duckdb_v2_aggregate_function_bind_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_BIND_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        callback: duckdb_v2_aggregate_function_bind_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_COMBINE_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_combine_callback(
    function: duckdb_v2_aggregate_function_handle,
    callback: duckdb_v2_aggregate_function_combine_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_COMBINE_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        callback: duckdb_v2_aggregate_function_combine_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_DESTROY_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_destroy_callback(
    function: duckdb_v2_aggregate_function_handle,
    callback: duckdb_v2_aggregate_function_destroy_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_DESTROY_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        callback: duckdb_v2_aggregate_function_destroy_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_FINALIZE_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_finalize_callback(
    function: duckdb_v2_aggregate_function_handle,
    callback: duckdb_v2_aggregate_function_finalize_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_FINALIZE_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        callback: duckdb_v2_aggregate_function_finalize_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_INIT_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_init_callback(
    function: duckdb_v2_aggregate_function_handle,
    callback: duckdb_v2_aggregate_function_init_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_INIT_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        callback: duckdb_v2_aggregate_function_init_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_name(
    function: duckdb_v2_aggregate_function_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, name, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_SIZE_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_size_callback(
    function: duckdb_v2_aggregate_function_handle,
    callback: duckdb_v2_aggregate_function_size_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_SIZE_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        callback: duckdb_v2_aggregate_function_size_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_UPDATE_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_update_callback(
    function: duckdb_v2_aggregate_function_handle,
    callback: duckdb_v2_aggregate_function_update_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_UPDATE_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        callback: duckdb_v2_aggregate_function_update_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_user_data(
    function: duckdb_v2_aggregate_function_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_size_get_bind_data(
    info: duckdb_v2_aggregate_function_size_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_size_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_size_get_user_data(
    info: duckdb_v2_aggregate_function_size_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_size_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_SET_STATE_SIZE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_size_set_state_size(
    info: duckdb_v2_aggregate_function_size_info_handle,
    size: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_SET_STATE_SIZE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_size_info_handle,
        size: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, size, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ARG: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_update_get_arg(
    info: duckdb_v2_aggregate_function_update_info_handle,
    index: idx_t,
    vector: *mut duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ARG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_update_info_handle,
        index: idx_t,
        vector: *mut duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, vector, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ARG_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_update_get_arg_count(
    info: duckdb_v2_aggregate_function_update_info_handle,
    positional_fixed: *mut idx_t,
    positional_variadic: *mut idx_t,
    named_fixed: *mut idx_t,
    named_variadic: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ARG_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_update_info_handle,
        positional_fixed: *mut idx_t,
        positional_variadic: *mut idx_t,
        named_fixed: *mut idx_t,
        named_variadic: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, positional_fixed, positional_variadic, named_fixed, named_variadic, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_update_get_bind_data(
    info: duckdb_v2_aggregate_function_update_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_update_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ROW_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_update_get_row_count(
    info: duckdb_v2_aggregate_function_update_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ROW_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_update_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_STATES: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_update_get_states(
    info: duckdb_v2_aggregate_function_update_info_handle,
    states: *mut *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_STATES
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_update_info_handle,
        states: *mut *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, states, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_aggregate_function_update_get_user_data(
    info: duckdb_v2_aggregate_function_update_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_aggregate_function_update_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_AGGREGATE_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_aggregate_function(
    conn: duckdb_v2_connection_handle,
    function: duckdb_v2_aggregate_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_AGGREGATE_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        function: duckdb_v2_aggregate_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, function, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_AGGREGATE_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_aggregate_function(
    extension: duckdb_v2_extension_handle,
    function: duckdb_v2_aggregate_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_AGGREGATE_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        function: duckdb_v2_aggregate_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, function, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_SET_PROPERTY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_aggregate_function_set_property(
    function: duckdb_v2_aggregate_function_handle,
    key: DUCKDB_V2_FUNCTION_PROPERTY_KEY,
    value: DUCKDB_V2_FUNCTION_PROPERTY_VALUE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_SET_PROPERTY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        key: DUCKDB_V2_FUNCTION_PROPERTY_KEY,
        value: DUCKDB_V2_FUNCTION_PROPERTY_VALUE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, key, value, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_SET_PROPERTY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_set_property(
    function: duckdb_v2_scalar_function_handle,
    key: DUCKDB_V2_FUNCTION_PROPERTY_KEY,
    value: DUCKDB_V2_FUNCTION_PROPERTY_VALUE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_SET_PROPERTY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        key: DUCKDB_V2_FUNCTION_PROPERTY_KEY,
        value: DUCKDB_V2_FUNCTION_PROPERTY_VALUE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, key, value, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_TABLE_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_table_function(
    conn: duckdb_v2_connection_handle,
    function: duckdb_v2_table_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_TABLE_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        function: duckdb_v2_table_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, function, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_TABLE_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_table_function(
    extension: duckdb_v2_extension_handle,
    function: duckdb_v2_table_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_TABLE_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        function: duckdb_v2_table_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, function, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_BIND_ADD_RESULT_COLUMN: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_bind_add_result_column(
    info: duckdb_v2_table_function_bind_info_handle,
    name: *const duckdb_v2_identifier_t,
    type_: duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_BIND_ADD_RESULT_COLUMN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_bind_info_handle,
        name: *const duckdb_v2_identifier_t,
        type_: duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, name, type_, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_BIND_SET_CARDINALITY: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_bind_set_cardinality(
    info: duckdb_v2_table_function_bind_info_handle,
    cardinality: idx_t,
    is_exact: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_BIND_SET_CARDINALITY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_bind_info_handle,
        cardinality: idx_t,
        is_exact: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, cardinality, is_exact, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_function_create(
    factory: duckdb_v2_factory_handle,
    function: *mut duckdb_v2_table_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        function: *mut duckdb_v2_table_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, function, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_function_destroy(
    function: *mut duckdb_v2_table_function_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: *mut duckdb_v2_table_function_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function)
}

static __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_exec_get_bind_data(
    info: duckdb_v2_table_function_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_exec_get_global_state(
    info: duckdb_v2_table_function_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_LOCAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_exec_get_local_state(
    info: duckdb_v2_table_function_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_LOCAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_OUTPUT_CHUNK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_exec_get_output_chunk(
    info: duckdb_v2_table_function_exec_info_handle,
    chunk: *mut duckdb_v2_data_chunk_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_OUTPUT_CHUNK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_exec_info_handle,
        chunk: *mut duckdb_v2_data_chunk_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, chunk, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_exec_get_user_data(
    info: duckdb_v2_table_function_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_GET_SIGNATURE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_function_get_signature(
    function: duckdb_v2_table_function_handle,
    sig: *mut duckdb_v2_function_signature_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_GET_SIGNATURE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        sig: *mut duckdb_v2_function_signature_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, sig, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_global_get_bind_data(
    info: duckdb_v2_table_function_init_global_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_global_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_global_get_user_data(
    info: duckdb_v2_table_function_init_global_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_global_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_SET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_global_set_global_state(
    info: duckdb_v2_table_function_init_global_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_SET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_global_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_SET_MAX_THREADS: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_global_set_max_threads(
    info: duckdb_v2_table_function_init_global_info_handle,
    max_threads: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_SET_MAX_THREADS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_global_info_handle,
        max_threads: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, max_threads, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_local_get_bind_data(
    info: duckdb_v2_table_function_init_local_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_local_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_local_get_global_state(
    info: duckdb_v2_table_function_init_local_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_local_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_local_get_user_data(
    info: duckdb_v2_table_function_init_local_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_local_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_SET_LOCAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_local_set_local_state(
    info: duckdb_v2_table_function_init_local_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_SET_LOCAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_local_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_progress_get_bind_data(
    info: duckdb_v2_table_function_progress_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_progress_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_progress_get_global_state(
    info: duckdb_v2_table_function_progress_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_progress_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_progress_get_user_data(
    info: duckdb_v2_table_function_progress_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_progress_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_SET_PROGRESS: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_progress_set_progress(
    info: duckdb_v2_table_function_progress_info_handle,
    progress: f64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_SET_PROGRESS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_progress_info_handle,
        progress: f64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, progress, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_BIND_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_bind_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_bind_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_BIND_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_bind_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_EXEC_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_exec_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_exec_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_EXEC_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_exec_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_INIT_GLOBAL_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_init_global_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_init_global_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_INIT_GLOBAL_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_init_global_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_INIT_LOCAL_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_init_local_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_init_local_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_INIT_LOCAL_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_init_local_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_function_set_name(
    function: duckdb_v2_table_function_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, name, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_PROGRESS_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_progress_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_progress_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_PROGRESS_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_progress_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_function_set_user_data(
    function: duckdb_v2_table_function_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, data, err)
}

static __DUCKDB_V2_CAST_FUNCTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_create(
    factory: duckdb_v2_factory_handle,
    function: *mut duckdb_v2_cast_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        function: *mut duckdb_v2_cast_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, function, err)
}

static __DUCKDB_V2_CAST_FUNCTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_destroy(
    function: *mut duckdb_v2_cast_function_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: *mut duckdb_v2_cast_function_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function)
}

static __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_INPUT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_exec_get_input(
    info: duckdb_v2_cast_function_exec_info_handle,
    vector: *mut duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_INPUT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_cast_function_exec_info_handle,
        vector: *mut duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, vector, err)
}

static __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_MODE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_exec_get_mode(
    info: duckdb_v2_cast_function_exec_info_handle,
    mode: *mut DUCKDB_V2_CAST_MODE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_MODE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_cast_function_exec_info_handle,
        mode: *mut DUCKDB_V2_CAST_MODE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, mode, err)
}

static __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_OUTPUT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_exec_get_output(
    info: duckdb_v2_cast_function_exec_info_handle,
    vector: *mut duckdb_v2_vector_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_OUTPUT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_cast_function_exec_info_handle,
        vector: *mut duckdb_v2_vector_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, vector, err)
}

static __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_ROW_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_cast_function_exec_get_row_count(
    info: duckdb_v2_cast_function_exec_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_ROW_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_cast_function_exec_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_cast_function_exec_get_user_data(
    info: duckdb_v2_cast_function_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_cast_function_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_CAST_FUNCTION_SET_EXEC_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_set_exec_callback(
    function: duckdb_v2_cast_function_handle,
    callback: duckdb_v2_cast_function_exec_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_SET_EXEC_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_cast_function_handle,
        callback: duckdb_v2_cast_function_exec_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_CAST_FUNCTION_SET_IMPLICIT_CAST_COST: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_cast_function_set_implicit_cast_cost(
    function: duckdb_v2_cast_function_handle,
    cost: i64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_SET_IMPLICIT_CAST_COST
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_cast_function_handle,
        cost: i64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, cost, err)
}

static __DUCKDB_V2_CAST_FUNCTION_SET_SOURCE_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_set_source_type(
    function: duckdb_v2_cast_function_handle,
    source_type: duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_SET_SOURCE_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_cast_function_handle,
        source_type: duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, source_type, err)
}

static __DUCKDB_V2_CAST_FUNCTION_SET_TARGET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_set_target_type(
    function: duckdb_v2_cast_function_handle,
    target_type: duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_SET_TARGET_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_cast_function_handle,
        target_type: duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, target_type, err)
}

static __DUCKDB_V2_CAST_FUNCTION_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_cast_function_set_user_data(
    function: duckdb_v2_cast_function_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CAST_FUNCTION_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_cast_function_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, data, err)
}

static __DUCKDB_V2_COLUMN_DATA_COLLECTION_CLEAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_data_collection_clear(
    collection: duckdb_v2_column_data_collection_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DATA_COLLECTION_CLEAR
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        collection: duckdb_v2_column_data_collection_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(collection, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_CAST_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_cast_function(
    conn: duckdb_v2_connection_handle,
    function: duckdb_v2_cast_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_CAST_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        function: duckdb_v2_cast_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, function, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_CUSTOM_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_register_custom_type(
    conn: duckdb_v2_connection_handle,
    type_: duckdb_v2_custom_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_CUSTOM_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        type_: duckdb_v2_custom_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, type_, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_REPLACEMENT_SCAN: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_replacement_scan(
    conn: duckdb_v2_connection_handle,
    scan: duckdb_v2_replacement_scan_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_REPLACEMENT_SCAN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        scan: duckdb_v2_replacement_scan_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, scan, err)
}

static __DUCKDB_V2_CONTEXT_GET_FILE_SYSTEM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_context_get_file_system(
    context: duckdb_v2_context_handle,
    file_system: *mut duckdb_v2_file_system_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONTEXT_GET_FILE_SYSTEM
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        context: duckdb_v2_context_handle,
        file_system: *mut duckdb_v2_file_system_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(context, file_system, err)
}

static __DUCKDB_V2_CUSTOM_TYPE_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_type_create(
    factory: duckdb_v2_factory_handle,
    type_: *mut duckdb_v2_custom_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_TYPE_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        type_: *mut duckdb_v2_custom_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, type_, err)
}

static __DUCKDB_V2_CUSTOM_TYPE_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_type_destroy(
    type_: *mut duckdb_v2_custom_type_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_TYPE_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: *mut duckdb_v2_custom_type_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_)
}

static __DUCKDB_V2_CUSTOM_TYPE_SET_BASE_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_type_set_base_type(
    type_: duckdb_v2_custom_type_handle,
    base_type: duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_TYPE_SET_BASE_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: duckdb_v2_custom_type_handle,
        base_type: duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_, base_type, err)
}

static __DUCKDB_V2_CUSTOM_TYPE_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_type_set_name(
    type_: duckdb_v2_custom_type_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_TYPE_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        type_: duckdb_v2_custom_type_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(type_, name, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_CAST_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_cast_function(
    extension: duckdb_v2_extension_handle,
    function: duckdb_v2_cast_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_CAST_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        function: duckdb_v2_cast_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, function, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_CUSTOM_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_extension_register_custom_type(
    extension: duckdb_v2_extension_handle,
    type_: duckdb_v2_custom_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_CUSTOM_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        type_: duckdb_v2_custom_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, type_, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_REPLACEMENT_SCAN: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_replacement_scan(
    extension: duckdb_v2_extension_handle,
    scan: duckdb_v2_replacement_scan_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_REPLACEMENT_SCAN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        scan: duckdb_v2_replacement_scan_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, scan, err)
}

static __DUCKDB_V2_FILE_CLOSE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_close(
    file: duckdb_v2_file_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_CLOSE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, err)
}

static __DUCKDB_V2_FILE_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_destroy(
    file: *mut duckdb_v2_file_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(file: *mut duckdb_v2_file_handle) -> DUCKDB_V2_ERROR = ::std::mem::transmute(
        function_ptr,
    );
    (fun)(file)
}

static __DUCKDB_V2_FILE_OPEN_OPTIONS_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_open_options_create(
    file_system: duckdb_v2_file_system_handle,
    options: *mut duckdb_v2_file_open_options_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_OPEN_OPTIONS_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file_system: duckdb_v2_file_system_handle,
        options: *mut duckdb_v2_file_open_options_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file_system, options, err)
}

static __DUCKDB_V2_FILE_OPEN_OPTIONS_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_open_options_destroy(
    options: *mut duckdb_v2_file_open_options_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_OPEN_OPTIONS_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        options: *mut duckdb_v2_file_open_options_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(options)
}

static __DUCKDB_V2_FILE_OPEN_OPTIONS_SET_FLAG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_open_options_set_flag(
    options: duckdb_v2_file_open_options_handle,
    flag: DUCKDB_V2_FILE_FLAG,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_OPEN_OPTIONS_SET_FLAG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        options: duckdb_v2_file_open_options_handle,
        flag: DUCKDB_V2_FILE_FLAG,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(options, flag, err)
}

static __DUCKDB_V2_FILE_OPEN_OPTIONS_SET_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_open_options_set_value(
    options: duckdb_v2_file_open_options_handle,
    name: *const duckdb_v2_str,
    value: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_OPEN_OPTIONS_SET_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        options: duckdb_v2_file_open_options_handle,
        name: *const duckdb_v2_str,
        value: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(options, name, value, err)
}

static __DUCKDB_V2_FILE_READ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_read(
    file: duckdb_v2_file_handle,
    buffer: *mut ::std::os::raw::c_void,
    buffer_size: idx_t,
    bytes_read: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_READ
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        buffer: *mut ::std::os::raw::c_void,
        buffer_size: idx_t,
        bytes_read: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, buffer, buffer_size, bytes_read, err)
}

static __DUCKDB_V2_FILE_READ_AT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_read_at(
    file: duckdb_v2_file_handle,
    buffer: *mut ::std::os::raw::c_void,
    buffer_size: idx_t,
    location: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_READ_AT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        buffer: *mut ::std::os::raw::c_void,
        buffer_size: idx_t,
        location: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, buffer, buffer_size, location, err)
}

static __DUCKDB_V2_FILE_SEEK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_seek(
    file: duckdb_v2_file_handle,
    position: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SEEK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        position: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, position, err)
}

static __DUCKDB_V2_FILE_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_size(
    file: duckdb_v2_file_handle,
    size: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SIZE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        size: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, size, err)
}

static __DUCKDB_V2_FILE_SYNC: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_sync(
    file: duckdb_v2_file_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SYNC
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, err)
}

static __DUCKDB_V2_FILE_SYSTEM_OPEN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_system_open(
    file_system: duckdb_v2_file_system_handle,
    file_path: *const duckdb_v2_str,
    options: duckdb_v2_file_open_options_handle,
    file: *mut duckdb_v2_file_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SYSTEM_OPEN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file_system: duckdb_v2_file_system_handle,
        file_path: *const duckdb_v2_str,
        options: duckdb_v2_file_open_options_handle,
        file: *mut duckdb_v2_file_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file_system, file_path, options, file, err)
}

static __DUCKDB_V2_FILE_TELL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_tell(
    file: duckdb_v2_file_handle,
    position: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_TELL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        position: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, position, err)
}

static __DUCKDB_V2_FILE_WRITE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_write(
    file: duckdb_v2_file_handle,
    buffer: *const ::std::os::raw::c_void,
    buffer_size: idx_t,
    bytes_written: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_WRITE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        buffer: *const ::std::os::raw::c_void,
        buffer_size: idx_t,
        bytes_written: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, buffer, buffer_size, bytes_written, err)
}

static __DUCKDB_V2_FILE_WRITE_AT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_write_at(
    file: duckdb_v2_file_handle,
    buffer: *const ::std::os::raw::c_void,
    buffer_size: idx_t,
    location: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_WRITE_AT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file: duckdb_v2_file_handle,
        buffer: *const ::std::os::raw::c_void,
        buffer_size: idx_t,
        location: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file, buffer, buffer_size, location, err)
}

static __DUCKDB_V2_INSTANCE_REGISTER_REPLACEMENT_SCAN: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_instance_register_replacement_scan(
    instance: duckdb_v2_instance_handle,
    scan: duckdb_v2_replacement_scan_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_REGISTER_REPLACEMENT_SCAN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        scan: duckdb_v2_replacement_scan_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, scan, err)
}

static __DUCKDB_V2_QNAME_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_qname_create(
    parts: *const duckdb_v2_identifier_t,
    part_count: idx_t,
    name: *mut duckdb_v2_qname_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QNAME_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        parts: *const duckdb_v2_identifier_t,
        part_count: idx_t,
        name: *mut duckdb_v2_qname_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(parts, part_count, name, err)
}

static __DUCKDB_V2_QNAME_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_qname_destroy(
    name: *mut duckdb_v2_qname_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QNAME_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        name: *mut duckdb_v2_qname_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(name)
}

static __DUCKDB_V2_QNAME_EQUALS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_qname_equals(
    left: duckdb_v2_qname_handle,
    right: duckdb_v2_qname_handle,
    result: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QNAME_EQUALS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        left: duckdb_v2_qname_handle,
        right: duckdb_v2_qname_handle,
        result: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(left, right, result, err)
}

static __DUCKDB_V2_QNAME_GET_PART: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_qname_get_part(
    name: duckdb_v2_qname_handle,
    index: idx_t,
    part: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QNAME_GET_PART
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        name: duckdb_v2_qname_handle,
        index: idx_t,
        part: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(name, index, part, err)
}

static __DUCKDB_V2_QNAME_GET_PART_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_qname_get_part_count(
    name: duckdb_v2_qname_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QNAME_GET_PART_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        name: duckdb_v2_qname_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(name, count, err)
}

static __DUCKDB_V2_QNAME_HASH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_qname_hash(
    name: duckdb_v2_qname_handle,
    hash: *mut u64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QNAME_HASH
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        name: duckdb_v2_qname_handle,
        hash: *mut u64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(name, hash, err)
}

static __DUCKDB_V2_QNAME_PARSE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_qname_parse(
    text: *const duckdb_v2_str,
    name: *mut duckdb_v2_qname_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QNAME_PARSE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        text: *const duckdb_v2_str,
        name: *mut duckdb_v2_qname_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(text, name, err)
}

static __DUCKDB_V2_QNAME_RENDER: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_qname_render(
    name: duckdb_v2_qname_handle,
    out_text: *mut ::std::os::raw::c_char,
    out_capacity: idx_t,
    out_length: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QNAME_RENDER
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        name: duckdb_v2_qname_handle,
        out_text: *mut ::std::os::raw::c_char,
        out_capacity: idx_t,
        out_length: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(name, out_text, out_capacity, out_length, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_ADD_ARGUMENT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_add_argument(
    info: duckdb_v2_replacement_scan_info_handle,
    value: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_ADD_ARGUMENT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        value: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, value, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_ADD_NAMED_ARGUMENT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_replacement_scan_add_named_argument(
    info: duckdb_v2_replacement_scan_info_handle,
    name: *const duckdb_v2_identifier_t,
    value: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_ADD_NAMED_ARGUMENT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        name: *const duckdb_v2_identifier_t,
        value: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, name, value, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_create(
    factory: duckdb_v2_factory_handle,
    scan: *mut duckdb_v2_replacement_scan_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        scan: *mut duckdb_v2_replacement_scan_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, scan, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_destroy(
    scan: *mut duckdb_v2_replacement_scan_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        scan: *mut duckdb_v2_replacement_scan_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(scan)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_GET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_get_name(
    info: duckdb_v2_replacement_scan_info_handle,
    name: *mut duckdb_v2_qname_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_GET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        name: *mut duckdb_v2_qname_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, name, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_get_user_data(
    info: duckdb_v2_replacement_scan_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_SET_ALIAS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_set_alias(
    info: duckdb_v2_replacement_scan_info_handle,
    alias: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_SET_ALIAS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        alias: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, alias, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_SET_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_set_callback(
    scan: duckdb_v2_replacement_scan_handle,
    callback: duckdb_v2_replacement_scan_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_SET_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        scan: duckdb_v2_replacement_scan_handle,
        callback: duckdb_v2_replacement_scan_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(scan, callback, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_SET_COLLECTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_set_collection(
    info: duckdb_v2_replacement_scan_info_handle,
    collection: duckdb_v2_column_data_collection_handle,
    column_names: *const duckdb_v2_identifier_t,
    column_count: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_SET_COLLECTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        collection: duckdb_v2_column_data_collection_handle,
        column_names: *const duckdb_v2_identifier_t,
        column_count: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, collection, column_names, column_count, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_SET_FUNCTION_NAME: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_replacement_scan_set_function_name(
    info: duckdb_v2_replacement_scan_info_handle,
    name: duckdb_v2_qname_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_SET_FUNCTION_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        name: duckdb_v2_qname_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, name, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_SET_SUBQUERY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_set_subquery(
    info: duckdb_v2_replacement_scan_info_handle,
    sql: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_SET_SUBQUERY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_replacement_scan_info_handle,
        sql: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, sql, err)
}

static __DUCKDB_V2_REPLACEMENT_SCAN_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_replacement_scan_set_user_data(
    scan: duckdb_v2_replacement_scan_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_REPLACEMENT_SCAN_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        scan: duckdb_v2_replacement_scan_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(scan, data, err)
}

static __DUCKDB_V2_ARROW_EXPORTER_APPEND: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_exporter_append(
    exporter: duckdb_v2_arrow_exporter_handle,
    chunk: *mut duckdb_v2_data_chunk_handle,
    consume: bool,
    flush: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_EXPORTER_APPEND
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        exporter: duckdb_v2_arrow_exporter_handle,
        chunk: *mut duckdb_v2_data_chunk_handle,
        consume: bool,
        flush: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(exporter, chunk, consume, flush, err)
}

static __DUCKDB_V2_ARROW_EXPORTER_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_exporter_create(
    context: duckdb_v2_context_handle,
    types: *const duckdb_v2_logical_type_handle,
    names: *const duckdb_v2_str,
    count: idx_t,
    batch_size: idx_t,
    out_exporter: *mut duckdb_v2_arrow_exporter_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_EXPORTER_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        context: duckdb_v2_context_handle,
        types: *const duckdb_v2_logical_type_handle,
        names: *const duckdb_v2_str,
        count: idx_t,
        batch_size: idx_t,
        out_exporter: *mut duckdb_v2_arrow_exporter_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(context, types, names, count, batch_size, out_exporter, err)
}

static __DUCKDB_V2_ARROW_EXPORTER_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_exporter_destroy(
    exporter: *mut duckdb_v2_arrow_exporter_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_EXPORTER_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        exporter: *mut duckdb_v2_arrow_exporter_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(exporter)
}

static __DUCKDB_V2_ARROW_EXPORTER_GET_SCHEMA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_exporter_get_schema(
    exporter: duckdb_v2_arrow_exporter_handle,
    out_schema: *mut ArrowSchema,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_EXPORTER_GET_SCHEMA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        exporter: duckdb_v2_arrow_exporter_handle,
        out_schema: *mut ArrowSchema,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(exporter, out_schema, err)
}

static __DUCKDB_V2_ARROW_EXPORTER_NEXT_ARRAY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_exporter_next_array(
    exporter: duckdb_v2_arrow_exporter_handle,
    out_array: *mut ArrowArray,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_EXPORTER_NEXT_ARRAY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        exporter: duckdb_v2_arrow_exporter_handle,
        out_array: *mut ArrowArray,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(exporter, out_array, err)
}

static __DUCKDB_V2_ARROW_IMPORTER_APPEND: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_importer_append(
    importer: duckdb_v2_arrow_importer_handle,
    array: *mut ArrowArray,
    consume: bool,
    flush: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_IMPORTER_APPEND
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        importer: duckdb_v2_arrow_importer_handle,
        array: *mut ArrowArray,
        consume: bool,
        flush: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(importer, array, consume, flush, err)
}

static __DUCKDB_V2_ARROW_IMPORTER_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_importer_create(
    context: duckdb_v2_context_handle,
    schema: *mut ArrowSchema,
    batch_size: idx_t,
    out_importer: *mut duckdb_v2_arrow_importer_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_IMPORTER_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        context: duckdb_v2_context_handle,
        schema: *mut ArrowSchema,
        batch_size: idx_t,
        out_importer: *mut duckdb_v2_arrow_importer_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(context, schema, batch_size, out_importer, err)
}

static __DUCKDB_V2_ARROW_IMPORTER_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_importer_destroy(
    importer: *mut duckdb_v2_arrow_importer_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_IMPORTER_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        importer: *mut duckdb_v2_arrow_importer_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(importer)
}

static __DUCKDB_V2_ARROW_IMPORTER_GET_SCHEMA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_importer_get_schema(
    importer: duckdb_v2_arrow_importer_handle,
    out_schema: *mut duckdb_v2_schema_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_IMPORTER_GET_SCHEMA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        importer: duckdb_v2_arrow_importer_handle,
        out_schema: *mut duckdb_v2_schema_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(importer, out_schema, err)
}

static __DUCKDB_V2_ARROW_IMPORTER_NEXT_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_importer_next_chunk(
    importer: duckdb_v2_arrow_importer_handle,
    out_chunk: *mut duckdb_v2_data_chunk_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_IMPORTER_NEXT_CHUNK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        importer: duckdb_v2_arrow_importer_handle,
        out_chunk: *mut duckdb_v2_data_chunk_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(importer, out_chunk, err)
}

static __DUCKDB_V2_COLUMN_DESCRIPTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_description_destroy(
    column: *mut duckdb_v2_column_description_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DESCRIPTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        column: *mut duckdb_v2_column_description_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(column)
}

static __DUCKDB_V2_COLUMN_DESCRIPTION_GET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_description_get_name(
    column: duckdb_v2_column_description_handle,
    name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DESCRIPTION_GET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        column: duckdb_v2_column_description_handle,
        name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(column, name, err)
}

static __DUCKDB_V2_COLUMN_DESCRIPTION_GET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_description_get_type(
    column: duckdb_v2_column_description_handle,
    type_: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DESCRIPTION_GET_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        column: duckdb_v2_column_description_handle,
        type_: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(column, type_, err)
}

static __DUCKDB_V2_COLUMN_DESCRIPTION_HAS_DEFAULT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_column_description_has_default(
    column: duckdb_v2_column_description_handle,
    has_default: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DESCRIPTION_HAS_DEFAULT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        column: duckdb_v2_column_description_handle,
        has_default: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(column, has_default, err)
}

static __DUCKDB_V2_COLUMN_DESCRIPTION_HAS_GENERATED: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_column_description_has_generated(
    column: duckdb_v2_column_description_handle,
    has_generated: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COLUMN_DESCRIPTION_HAS_GENERATED
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        column: duckdb_v2_column_description_handle,
        has_generated: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(column, has_generated, err)
}

static __DUCKDB_V2_CONNECTION_DESCRIBE_TABLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_describe_table(
    conn: duckdb_v2_connection_handle,
    name: duckdb_v2_qname_handle,
    desc: *mut duckdb_v2_table_description_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_DESCRIBE_TABLE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        name: duckdb_v2_qname_handle,
        desc: *mut duckdb_v2_table_description_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, name, desc, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_COPY_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_copy_function(
    conn: duckdb_v2_connection_handle,
    function: duckdb_v2_copy_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_COPY_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        function: duckdb_v2_copy_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, function, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_get_column_count(
    info: duckdb_v2_copy_from_bind_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_get_column_name(
    info: duckdb_v2_copy_from_bind_info_handle,
    index: idx_t,
    name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        index: idx_t,
        name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, name, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_get_column_type(
    info: duckdb_v2_copy_from_bind_info_handle,
    index: idx_t,
    type_: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        index: idx_t,
        type_: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, type_, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_GET_FILE_PATH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_get_file_path(
    info: duckdb_v2_copy_from_bind_info_handle,
    path: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_GET_FILE_PATH
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        path: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, path, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_get_option_count(
    info: duckdb_v2_copy_from_bind_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_get_option_name(
    info: duckdb_v2_copy_from_bind_info_handle,
    index: idx_t,
    name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        index: idx_t,
        name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, name, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_get_option_value(
    info: duckdb_v2_copy_from_bind_info_handle,
    index: idx_t,
    value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        index: idx_t,
        value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, value, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_get_user_data(
    info: duckdb_v2_copy_from_bind_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_SET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_set_bind_data(
    info: duckdb_v2_copy_from_bind_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_SET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_BIND_SET_CARDINALITY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_bind_set_cardinality(
    info: duckdb_v2_copy_from_bind_info_handle,
    cardinality: idx_t,
    is_exact: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_BIND_SET_CARDINALITY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_bind_info_handle,
        cardinality: idx_t,
        is_exact: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, cardinality, is_exact, err)
}

static __DUCKDB_V2_COPY_FROM_EXEC_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_exec_get_bind_data(
    info: duckdb_v2_copy_from_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_EXEC_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_EXEC_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_exec_get_global_state(
    info: duckdb_v2_copy_from_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_EXEC_GET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_EXEC_GET_LOCAL_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_exec_get_local_state(
    info: duckdb_v2_copy_from_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_EXEC_GET_LOCAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_EXEC_GET_OUTPUT_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_exec_get_output_chunk(
    info: duckdb_v2_copy_from_exec_info_handle,
    chunk: *mut duckdb_v2_data_chunk_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_EXEC_GET_OUTPUT_CHUNK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_exec_info_handle,
        chunk: *mut duckdb_v2_data_chunk_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, chunk, err)
}

static __DUCKDB_V2_COPY_FROM_EXEC_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_exec_get_user_data(
    info: duckdb_v2_copy_from_exec_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_EXEC_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_exec_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_init_global_get_bind_data(
    info: duckdb_v2_copy_from_init_global_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_global_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_init_global_get_user_data(
    info: duckdb_v2_copy_from_init_global_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_global_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_SET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_init_global_set_global_state(
    info: duckdb_v2_copy_from_init_global_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_SET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_global_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_SET_MAX_THREADS: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_init_global_set_max_threads(
    info: duckdb_v2_copy_from_init_global_info_handle,
    max_threads: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_SET_MAX_THREADS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_global_info_handle,
        max_threads: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, max_threads, err)
}

static __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_init_local_get_bind_data(
    info: duckdb_v2_copy_from_init_local_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_local_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_init_local_get_global_state(
    info: duckdb_v2_copy_from_init_local_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_local_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_init_local_get_user_data(
    info: duckdb_v2_copy_from_init_local_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_local_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_INIT_LOCAL_SET_LOCAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_init_local_set_local_state(
    info: duckdb_v2_copy_from_init_local_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_INIT_LOCAL_SET_LOCAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_init_local_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_PROGRESS_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_progress_get_bind_data(
    info: duckdb_v2_copy_from_progress_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_PROGRESS_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_progress_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_PROGRESS_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_progress_get_global_state(
    info: duckdb_v2_copy_from_progress_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_PROGRESS_GET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_progress_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_PROGRESS_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_progress_get_user_data(
    info: duckdb_v2_copy_from_progress_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_PROGRESS_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_progress_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_FROM_PROGRESS_SET_PROGRESS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_progress_set_progress(
    info: duckdb_v2_copy_from_progress_info_handle,
    progress: f64,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_PROGRESS_SET_PROGRESS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_from_progress_info_handle,
        progress: f64,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, progress, err)
}

static __DUCKDB_V2_COPY_FROM_SET_BIND_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_set_bind_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_from_bind_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_SET_BIND_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_from_bind_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_FROM_SET_EXEC_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_set_exec_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_from_exec_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_SET_EXEC_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_from_exec_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_FROM_SET_INIT_GLOBAL_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_set_init_global_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_from_init_global_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_SET_INIT_GLOBAL_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_from_init_global_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_FROM_SET_INIT_LOCAL_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_from_set_init_local_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_from_init_local_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_SET_INIT_LOCAL_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_from_init_local_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_FROM_SET_PROGRESS_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_from_set_progress_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_from_progress_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FROM_SET_PROGRESS_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_from_progress_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_FUNCTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_function_create(
    factory: duckdb_v2_factory_handle,
    function: *mut duckdb_v2_copy_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FUNCTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        function: *mut duckdb_v2_copy_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, function, err)
}

static __DUCKDB_V2_COPY_FUNCTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_function_destroy(
    function: *mut duckdb_v2_copy_function_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FUNCTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: *mut duckdb_v2_copy_function_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function)
}

static __DUCKDB_V2_COPY_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_function_set_name(
    function: duckdb_v2_copy_function_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FUNCTION_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, name, err)
}

static __DUCKDB_V2_COPY_FUNCTION_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_function_set_user_data(
    function: duckdb_v2_copy_function_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FUNCTION_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, data, err)
}

static __DUCKDB_V2_COPY_TO_BATCH_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_batch_get_bind_data(
    info: duckdb_v2_copy_to_batch_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BATCH_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_BATCH_GET_INIT_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_batch_get_init_data(
    info: duckdb_v2_copy_to_batch_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BATCH_GET_INIT_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_BATCH_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_batch_get_user_data(
    info: duckdb_v2_copy_to_batch_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BATCH_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_BATCH_SET_BATCH_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_batch_set_batch_data(
    info: duckdb_v2_copy_to_batch_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BATCH_SET_BATCH_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_BATCH_SIZE_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_to_batch_size_get_bind_data(
    info: duckdb_v2_copy_to_batch_size_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BATCH_SIZE_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_size_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_BATCH_SIZE_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_to_batch_size_get_user_data(
    info: duckdb_v2_copy_to_batch_size_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BATCH_SIZE_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_size_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_BATCH_SIZE_SET_TARGET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_batch_size_set_target(
    info: duckdb_v2_copy_to_batch_size_info_handle,
    rows: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BATCH_SIZE_SET_TARGET
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_size_info_handle,
        rows: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, rows, err)
}

static __DUCKDB_V2_COPY_TO_BATCH_TAKE_INPUT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_batch_take_input(
    info: duckdb_v2_copy_to_batch_info_handle,
    collection: *mut duckdb_v2_column_data_collection_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BATCH_TAKE_INPUT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_batch_info_handle,
        collection: *mut duckdb_v2_column_data_collection_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, collection, err)
}

static __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_get_column_count(
    info: duckdb_v2_copy_to_bind_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_get_column_name(
    info: duckdb_v2_copy_to_bind_info_handle,
    index: idx_t,
    name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        index: idx_t,
        name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, name, err)
}

static __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_get_column_type(
    info: duckdb_v2_copy_to_bind_info_handle,
    index: idx_t,
    type_: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        index: idx_t,
        type_: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, type_, err)
}

static __DUCKDB_V2_COPY_TO_BIND_GET_FILE_PATH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_get_file_path(
    info: duckdb_v2_copy_to_bind_info_handle,
    path: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_GET_FILE_PATH
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        path: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, path, err)
}

static __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_get_option_count(
    info: duckdb_v2_copy_to_bind_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_get_option_name(
    info: duckdb_v2_copy_to_bind_info_handle,
    index: idx_t,
    name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        index: idx_t,
        name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, name, err)
}

static __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_get_option_value(
    info: duckdb_v2_copy_to_bind_info_handle,
    index: idx_t,
    value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        index: idx_t,
        value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, value, err)
}

static __DUCKDB_V2_COPY_TO_BIND_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_get_user_data(
    info: duckdb_v2_copy_to_bind_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_BIND_SET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_bind_set_bind_data(
    info: duckdb_v2_copy_to_bind_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_BIND_SET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_bind_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_FINALIZE_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_finalize_get_bind_data(
    info: duckdb_v2_copy_to_finalize_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_FINALIZE_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_finalize_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_FINALIZE_GET_INIT_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_finalize_get_init_data(
    info: duckdb_v2_copy_to_finalize_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_FINALIZE_GET_INIT_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_finalize_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_FINALIZE_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_finalize_get_user_data(
    info: duckdb_v2_copy_to_finalize_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_FINALIZE_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_finalize_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_FLUSH_GET_BATCH_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_flush_get_batch_data(
    info: duckdb_v2_copy_to_flush_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_FLUSH_GET_BATCH_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_flush_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_FLUSH_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_flush_get_bind_data(
    info: duckdb_v2_copy_to_flush_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_FLUSH_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_flush_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_FLUSH_GET_INIT_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_flush_get_init_data(
    info: duckdb_v2_copy_to_flush_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_FLUSH_GET_INIT_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_flush_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_FLUSH_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_flush_get_user_data(
    info: duckdb_v2_copy_to_flush_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_FLUSH_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_flush_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_INIT_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_init_get_bind_data(
    info: duckdb_v2_copy_to_init_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_INIT_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_init_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_INIT_GET_FILE_PATH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_init_get_file_path(
    info: duckdb_v2_copy_to_init_info_handle,
    path: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_INIT_GET_FILE_PATH
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_init_info_handle,
        path: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, path, err)
}

static __DUCKDB_V2_COPY_TO_INIT_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_init_get_user_data(
    info: duckdb_v2_copy_to_init_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_INIT_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_init_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_INIT_SET_INIT_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_init_set_init_data(
    info: duckdb_v2_copy_to_init_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_INIT_SET_INIT_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_init_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_SET_BATCH_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_set_batch_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_to_batch_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_SET_BATCH_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_to_batch_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_TO_SET_BATCH_SIZE_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_set_batch_size_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_to_batch_size_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_SET_BATCH_SIZE_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_to_batch_size_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_TO_SET_BIND_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_set_bind_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_to_bind_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_SET_BIND_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_to_bind_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_TO_SET_FINALIZE_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_set_finalize_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_to_finalize_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_SET_FINALIZE_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_to_finalize_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_TO_SET_FLUSH_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_set_flush_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_to_flush_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_SET_FLUSH_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_to_flush_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_TO_SET_INIT_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_set_init_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_to_init_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_SET_INIT_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_to_init_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_EXPRESSION_CAST_GET_MODE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_cast_get_mode(
    expression: duckdb_v2_expression_handle,
    mode: *mut DUCKDB_V2_CAST_MODE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_CAST_GET_MODE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        mode: *mut DUCKDB_V2_CAST_MODE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, mode, err)
}

static __DUCKDB_V2_EXPRESSION_COLUMN_REF_GET_INDEX: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_column_ref_get_index(
    expression: duckdb_v2_expression_handle,
    index: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_COLUMN_REF_GET_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        index: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, index, err)
}

static __DUCKDB_V2_EXPRESSION_CONSTANT_GET_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_constant_get_value(
    expression: duckdb_v2_expression_handle,
    value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_CONSTANT_GET_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, value, err)
}

static __DUCKDB_V2_EXPRESSION_FUNCTION_GET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_function_get_name(
    expression: duckdb_v2_expression_handle,
    name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_FUNCTION_GET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, name, err)
}

static __DUCKDB_V2_EXPRESSION_FUNCTION_GET_QNAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_function_get_qname(
    expression: duckdb_v2_expression_handle,
    name: *mut duckdb_v2_qname_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_FUNCTION_GET_QNAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        name: *mut duckdb_v2_qname_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, name, err)
}

static __DUCKDB_V2_EXPRESSION_GET_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_get_child(
    expression: duckdb_v2_expression_handle,
    index: idx_t,
    child: *mut duckdb_v2_expression_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_GET_CHILD
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        index: idx_t,
        child: *mut duckdb_v2_expression_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, index, child, err)
}

static __DUCKDB_V2_EXPRESSION_GET_CHILD_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_get_child_count(
    expression: duckdb_v2_expression_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_GET_CHILD_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, count, err)
}

static __DUCKDB_V2_EXPRESSION_GET_RETURN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_get_return_type(
    expression: duckdb_v2_expression_handle,
    type_: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_GET_RETURN_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        type_: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, type_, err)
}

static __DUCKDB_V2_EXPRESSION_GET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_expression_get_type(
    expression: duckdb_v2_expression_handle,
    type_: *mut DUCKDB_V2_EXPRESSION_TYPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXPRESSION_GET_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        expression: duckdb_v2_expression_handle,
        type_: *mut DUCKDB_V2_EXPRESSION_TYPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(expression, type_, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_COPY_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_copy_function(
    extension: duckdb_v2_extension_handle,
    function: duckdb_v2_copy_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_COPY_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        function: duckdb_v2_copy_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, function, err)
}

static __DUCKDB_V2_IDENTIFIER_RENDER_QUOTED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_identifier_render_quoted(
    name: *const duckdb_v2_identifier_t,
    out_text: *mut ::std::os::raw::c_char,
    out_capacity: idx_t,
    out_length: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_IDENTIFIER_RENDER_QUOTED
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        name: *const duckdb_v2_identifier_t,
        out_text: *mut ::std::os::raw::c_char,
        out_capacity: idx_t,
        out_length: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(name, out_text, out_capacity, out_length, err)
}

static __DUCKDB_V2_PREPARED_STATEMENT_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_prepared_statement_create(
    conn: duckdb_v2_connection_handle,
    statement: duckdb_v2_sql_statement_handle,
    require_cacheable: bool,
    out_prepared: *mut duckdb_v2_prepared_statement_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PREPARED_STATEMENT_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        statement: duckdb_v2_sql_statement_handle,
        require_cacheable: bool,
        out_prepared: *mut duckdb_v2_prepared_statement_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, statement, require_cacheable, out_prepared, err)
}

static __DUCKDB_V2_PREPARED_STATEMENT_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_prepared_statement_destroy(
    prepared: *mut duckdb_v2_prepared_statement_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PREPARED_STATEMENT_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        prepared: *mut duckdb_v2_prepared_statement_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(prepared)
}

static __DUCKDB_V2_PREPARED_STATEMENT_EXECUTE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_prepared_statement_execute(
    prepared: duckdb_v2_prepared_statement_handle,
    parameter_names: *const duckdb_v2_identifier_t,
    parameter_values: *const duckdb_v2_value_handle,
    parameter_count: idx_t,
    out_result: *mut duckdb_v2_result_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PREPARED_STATEMENT_EXECUTE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        prepared: duckdb_v2_prepared_statement_handle,
        parameter_names: *const duckdb_v2_identifier_t,
        parameter_values: *const duckdb_v2_value_handle,
        parameter_count: idx_t,
        out_result: *mut duckdb_v2_result_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(prepared, parameter_names, parameter_values, parameter_count, out_result, err)
}

static __DUCKDB_V2_PREPARED_STATEMENT_REUSES_PLAN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_prepared_statement_reuses_plan(
    prepared: duckdb_v2_prepared_statement_handle,
    out_reuses: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PREPARED_STATEMENT_REUSES_PLAN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        prepared: duckdb_v2_prepared_statement_handle,
        out_reuses: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(prepared, out_reuses, err)
}

static __DUCKDB_V2_TABLE_DESCRIPTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_description_destroy(
    desc: *mut duckdb_v2_table_description_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_DESCRIPTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        desc: *mut duckdb_v2_table_description_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(desc)
}

static __DUCKDB_V2_TABLE_DESCRIPTION_GET_COLUMN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_description_get_column(
    desc: duckdb_v2_table_description_handle,
    index: idx_t,
    column: *mut duckdb_v2_column_description_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_DESCRIPTION_GET_COLUMN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        desc: duckdb_v2_table_description_handle,
        index: idx_t,
        column: *mut duckdb_v2_column_description_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(desc, index, column, err)
}

static __DUCKDB_V2_TABLE_DESCRIPTION_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_description_get_column_count(
    desc: duckdb_v2_table_description_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_DESCRIPTION_GET_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        desc: duckdb_v2_table_description_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(desc, count, err)
}

static __DUCKDB_V2_TABLE_DESCRIPTION_GET_QNAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_description_get_qname(
    desc: duckdb_v2_table_description_handle,
    name: *mut duckdb_v2_qname_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_DESCRIPTION_GET_QNAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        desc: duckdb_v2_table_description_handle,
        name: *mut duckdb_v2_qname_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(desc, name, err)
}

static __DUCKDB_V2_TABLE_DESCRIPTION_IS_READONLY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_description_is_readonly(
    desc: duckdb_v2_table_description_handle,
    readonly: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_DESCRIPTION_IS_READONLY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        desc: duckdb_v2_table_description_handle,
        readonly: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(desc, readonly, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_exec_get_column_count(
    info: duckdb_v2_table_function_exec_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_exec_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_COLUMN_INDEX: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_exec_get_column_index(
    info: duckdb_v2_table_function_exec_info_handle,
    index: idx_t,
    column_index: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_COLUMN_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_exec_info_handle,
        index: idx_t,
        column_index: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, column_index, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_ACCEPT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_filter_pushdown_accept(
    info: duckdb_v2_table_function_filter_pushdown_info_handle,
    index: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_ACCEPT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_filter_pushdown_info_handle,
        index: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_filter_pushdown_get_bind_data(
    info: duckdb_v2_table_function_filter_pushdown_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_filter_pushdown_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_filter_pushdown_get_column_count(
    info: duckdb_v2_table_function_filter_pushdown_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_filter_pushdown_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_COLUMN_INDEX: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_filter_pushdown_get_column_index(
    info: duckdb_v2_table_function_filter_pushdown_info_handle,
    index: idx_t,
    column_index: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_COLUMN_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_filter_pushdown_info_handle,
        index: idx_t,
        column_index: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, column_index, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_FILTER: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_filter_pushdown_get_filter(
    info: duckdb_v2_table_function_filter_pushdown_info_handle,
    index: idx_t,
    filter: *mut duckdb_v2_expression_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_FILTER
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_filter_pushdown_info_handle,
        index: idx_t,
        filter: *mut duckdb_v2_expression_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, filter, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_FILTER_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_filter_pushdown_get_filter_count(
    info: duckdb_v2_table_function_filter_pushdown_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_FILTER_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_filter_pushdown_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_filter_pushdown_get_user_data(
    info: duckdb_v2_table_function_filter_pushdown_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_filter_pushdown_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_global_get_column_count(
    info: duckdb_v2_table_function_init_global_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_global_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_COLUMN_INDEX: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_global_get_column_index(
    info: duckdb_v2_table_function_init_global_info_handle,
    index: idx_t,
    column_index: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_COLUMN_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_global_info_handle,
        index: idx_t,
        column_index: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, column_index, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_local_get_column_count(
    info: duckdb_v2_table_function_init_local_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_local_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_COLUMN_INDEX: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_init_local_get_column_index(
    info: duckdb_v2_table_function_init_local_info_handle,
    index: idx_t,
    column_index: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_COLUMN_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_init_local_info_handle,
        index: idx_t,
        column_index: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, column_index, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_FILTER_PUSHDOWN_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_filter_pushdown_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_filter_pushdown_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_FILTER_PUSHDOWN_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_filter_pushdown_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_PROJECTION_PUSHDOWN: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_projection_pushdown(
    function: duckdb_v2_table_function_handle,
    enable: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_PROJECTION_PUSHDOWN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        enable: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, enable, err)
}

static __DUCKDB_V2_SQL_STATEMENT_GET_PARAMETER_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_sql_statement_get_parameter_count(
    statement: duckdb_v2_sql_statement_handle,
    out_count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SQL_STATEMENT_GET_PARAMETER_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        statement: duckdb_v2_sql_statement_handle,
        out_count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(statement, out_count, err)
}

static __DUCKDB_V2_SQL_STATEMENT_GET_PARAMETER_NAME: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_sql_statement_get_parameter_name(
    statement: duckdb_v2_sql_statement_handle,
    index: idx_t,
    out_name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SQL_STATEMENT_GET_PARAMETER_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        statement: duckdb_v2_sql_statement_handle,
        index: idx_t,
        out_name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(statement, index, out_name, err)
}

static __DUCKDB_V2_SQL_STATEMENT_GET_TEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_sql_statement_get_text(
    statement: duckdb_v2_sql_statement_handle,
    out_text: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SQL_STATEMENT_GET_TEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        statement: duckdb_v2_sql_statement_handle,
        out_text: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(statement, out_text, err)
}

static __DUCKDB_V2_SQL_STATEMENT_GET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_sql_statement_get_type(
    statement: duckdb_v2_sql_statement_handle,
    out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SQL_STATEMENT_GET_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        statement: duckdb_v2_sql_statement_handle,
        out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(statement, out_type, err)
}

static __DUCKDB_V2_TOKEN_ITERATOR_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_token_iterator_destroy(
    iterator: *mut duckdb_v2_token_iterator_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TOKEN_ITERATOR_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        iterator: *mut duckdb_v2_token_iterator_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(iterator)
}

static __DUCKDB_V2_TOKEN_ITERATOR_ENDS_UNTERMINATED: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_token_iterator_ends_unterminated(
    iterator: duckdb_v2_token_iterator_handle,
    out_ends_unterminated: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TOKEN_ITERATOR_ENDS_UNTERMINATED
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        iterator: duckdb_v2_token_iterator_handle,
        out_ends_unterminated: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(iterator, out_ends_unterminated, err)
}

static __DUCKDB_V2_TOKEN_ITERATOR_NEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_token_iterator_next(
    iterator: duckdb_v2_token_iterator_handle,
    out_type: *mut DUCKDB_V2_TOKEN_TYPE,
    out_start: *mut idx_t,
    out_length: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TOKEN_ITERATOR_NEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        iterator: duckdb_v2_token_iterator_handle,
        out_type: *mut DUCKDB_V2_TOKEN_TYPE,
        out_start: *mut idx_t,
        out_length: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(iterator, out_type, out_start, out_length, err)
}

static __DUCKDB_V2_TOKENIZE_SQL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_tokenize_sql(
    conn: duckdb_v2_connection_handle,
    sql: *const duckdb_v2_str,
    out_iterator: *mut duckdb_v2_token_iterator_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TOKENIZE_SQL
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        sql: *const duckdb_v2_str,
        out_iterator: *mut duckdb_v2_token_iterator_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, sql, out_iterator, err)
}

static __DUCKDB_V2_ATTACH_OPTIONS_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_attach_options_create(
    instance: duckdb_v2_instance_handle,
    out_options: *mut duckdb_v2_attach_options_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ATTACH_OPTIONS_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        out_options: *mut duckdb_v2_attach_options_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, out_options, err)
}

static __DUCKDB_V2_ATTACH_OPTIONS_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_attach_options_destroy(
    options: *mut duckdb_v2_attach_options_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ATTACH_OPTIONS_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        options: *mut duckdb_v2_attach_options_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(options)
}

static __DUCKDB_V2_ATTACH_OPTIONS_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_attach_options_set(
    options: duckdb_v2_attach_options_handle,
    key: *const duckdb_v2_identifier_t,
    setting: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ATTACH_OPTIONS_SET
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        options: duckdb_v2_attach_options_handle,
        key: *const duckdb_v2_identifier_t,
        setting: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(options, key, setting, err)
}

static __DUCKDB_V2_INSTANCE_SET_DEFAULT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_set_default(
    instance: duckdb_v2_instance_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_SET_DEFAULT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, name, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_get_bind_data(
    info: duckdb_v2_table_function_partition_data_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_get_global_state(
    info: duckdb_v2_table_function_partition_data_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_LOCAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_get_local_state(
    info: duckdb_v2_table_function_partition_data_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_LOCAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_PARTITION_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_get_partition_column_count(
    info: duckdb_v2_table_function_partition_data_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_PARTITION_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_PARTITION_COLUMN_INDEX: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_get_partition_column_index(
    info: duckdb_v2_table_function_partition_data_info_handle,
    index: idx_t,
    column_index: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_PARTITION_COLUMN_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        index: idx_t,
        column_index: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, column_index, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_get_user_data(
    info: duckdb_v2_table_function_partition_data_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_REQUIRES_BATCH_INDEX: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_requires_batch_index(
    info: duckdb_v2_table_function_partition_data_info_handle,
    required: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_REQUIRES_BATCH_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        required: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, required, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_REQUIRES_PARTITION_COLUMNS: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_requires_partition_columns(
    info: duckdb_v2_table_function_partition_data_info_handle,
    required: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_REQUIRES_PARTITION_COLUMNS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        required: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, required, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_SET_BATCH_INDEX: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_set_batch_index(
    info: duckdb_v2_table_function_partition_data_info_handle,
    batch_index: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_SET_BATCH_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        batch_index: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, batch_index, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_SET_PARTITION_VALUE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partition_data_set_partition_value(
    info: duckdb_v2_table_function_partition_data_info_handle,
    index: idx_t,
    value: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_SET_PARTITION_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partition_data_info_handle,
        index: idx_t,
        value: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, value, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partitioning_get_bind_data(
    info: duckdb_v2_table_function_partitioning_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partitioning_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_PARTITION_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partitioning_get_partition_column_count(
    info: duckdb_v2_table_function_partitioning_info_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_PARTITION_COLUMN_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partitioning_info_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, count, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_PARTITION_COLUMN_INDEX: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partitioning_get_partition_column_index(
    info: duckdb_v2_table_function_partitioning_info_handle,
    index: idx_t,
    column_index: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_PARTITION_COLUMN_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partitioning_info_handle,
        index: idx_t,
        column_index: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, column_index, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partitioning_get_user_data(
    info: duckdb_v2_table_function_partitioning_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partitioning_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_SET_PARTITION_INFO: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_partitioning_set_partition_info(
    info: duckdb_v2_table_function_partitioning_info_handle,
    partition_info: DUCKDB_V2_TABLE_PARTITION_INFO,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_SET_PARTITION_INFO
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_partitioning_info_handle,
        partition_info: DUCKDB_V2_TABLE_PARTITION_INFO,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, partition_info, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_PARTITION_DATA_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_partition_data_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_partition_data_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_PARTITION_DATA_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_partition_data_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_PARTITIONING_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_partitioning_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_partitioning_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_PARTITIONING_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_partitioning_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_VALIDATE_UTF8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_validate_utf8(
    text: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VALIDATE_UTF8
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        text: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(text, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_MULTI_FILE_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_multi_file_function(
    conn: duckdb_v2_connection_handle,
    function: duckdb_v2_multi_file_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_MULTI_FILE_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        function: duckdb_v2_multi_file_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, function, err)
}

static __DUCKDB_V2_COPY_TO_SET_STATISTICS_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_copy_to_set_statistics_callback(
    function: duckdb_v2_copy_function_handle,
    callback: duckdb_v2_copy_to_statistics_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_SET_STATISTICS_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        callback: duckdb_v2_copy_to_statistics_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_COPY_TO_STATISTICS_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_to_statistics_get_bind_data(
    info: duckdb_v2_copy_to_statistics_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_STATISTICS_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_statistics_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_STATISTICS_GET_INIT_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_to_statistics_get_init_data(
    info: duckdb_v2_copy_to_statistics_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_STATISTICS_GET_INIT_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_statistics_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_STATISTICS_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_to_statistics_get_user_data(
    info: duckdb_v2_copy_to_statistics_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_STATISTICS_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_statistics_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_COPY_TO_STATISTICS_SET_FILE_SIZE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_to_statistics_set_file_size(
    info: duckdb_v2_copy_to_statistics_info_handle,
    file_size_bytes: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_STATISTICS_SET_FILE_SIZE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_statistics_info_handle,
        file_size_bytes: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, file_size_bytes, err)
}

static __DUCKDB_V2_COPY_TO_STATISTICS_SET_ROW_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_to_statistics_set_row_count(
    info: duckdb_v2_copy_to_statistics_info_handle,
    row_count: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_TO_STATISTICS_SET_ROW_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_copy_to_statistics_info_handle,
        row_count: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, row_count, err)
}

static __DUCKDB_V2_DATA_CHUNK_GET_CAPACITY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_data_chunk_get_capacity(
    chunk: duckdb_v2_data_chunk_handle,
    out_capacity: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_DATA_CHUNK_GET_CAPACITY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        chunk: duckdb_v2_data_chunk_handle,
        out_capacity: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(chunk, out_capacity, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_MULTI_FILE_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_multi_file_function(
    extension: duckdb_v2_extension_handle,
    function: duckdb_v2_multi_file_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_MULTI_FILE_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        function: duckdb_v2_multi_file_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, function, err)
}

static __DUCKDB_V2_MULTI_FILE_FUNCTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_multi_file_function_create(
    factory: duckdb_v2_factory_handle,
    function: *mut duckdb_v2_multi_file_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MULTI_FILE_FUNCTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        function: *mut duckdb_v2_multi_file_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, function, err)
}

static __DUCKDB_V2_MULTI_FILE_FUNCTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_multi_file_function_destroy(
    function: *mut duckdb_v2_multi_file_function_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MULTI_FILE_FUNCTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: *mut duckdb_v2_multi_file_function_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function)
}

static __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_FILE_EXTENSION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_multi_file_function_set_file_extension(
    function: duckdb_v2_multi_file_function_handle,
    extension: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_FILE_EXTENSION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_multi_file_function_handle,
        extension: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, extension, err)
}

static __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_multi_file_function_set_name(
    function: duckdb_v2_multi_file_function_handle,
    name: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_multi_file_function_handle,
        name: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, name, err)
}

static __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_READER_TYPE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_multi_file_function_set_reader_type(
    function: duckdb_v2_multi_file_function_handle,
    reader_type: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_READER_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_multi_file_function_handle,
        reader_type: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, reader_type, err)
}

static __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_SINGLE_FILE_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_multi_file_function_set_single_file_function(
    function: duckdb_v2_multi_file_function_handle,
    name: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_SINGLE_FILE_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_multi_file_function_handle,
        name: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, name, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_claim_batch_get_bind_data(
    info: duckdb_v2_table_function_claim_batch_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_claim_batch_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_claim_batch_get_global_state(
    info: duckdb_v2_table_function_claim_batch_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_GLOBAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_claim_batch_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_LOCAL_STATE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_claim_batch_get_local_state(
    info: duckdb_v2_table_function_claim_batch_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_LOCAL_STATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_claim_batch_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_claim_batch_get_user_data(
    info: duckdb_v2_table_function_claim_batch_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_claim_batch_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_SET_CLAIMED: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_claim_batch_set_claimed(
    info: duckdb_v2_table_function_claim_batch_info_handle,
    claimed: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_SET_CLAIMED
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_claim_batch_info_handle,
        claimed: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, claimed, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_CLAIM_BATCH_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_claim_batch_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_claim_batch_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_CLAIM_BATCH_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_claim_batch_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_FUNCTION_BIND_GET_ARG_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_bind_get_arg_count(
    info: duckdb_v2_function_bind_info_handle,
    positional_fixed: *mut idx_t,
    positional_variadic: *mut idx_t,
    named_fixed: *mut idx_t,
    named_variadic: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_BIND_GET_ARG_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        positional_fixed: *mut idx_t,
        positional_variadic: *mut idx_t,
        named_fixed: *mut idx_t,
        named_variadic: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, positional_fixed, positional_variadic, named_fixed, named_variadic, err)
}

static __DUCKDB_V2_FUNCTION_BIND_GET_ARG_INDEX: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_bind_get_arg_index(
    info: duckdb_v2_function_bind_info_handle,
    name: *const duckdb_v2_identifier_t,
    index: *mut idx_t,
    found: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_BIND_GET_ARG_INDEX
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        name: *const duckdb_v2_identifier_t,
        index: *mut idx_t,
        found: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, name, index, found, err)
}

static __DUCKDB_V2_FUNCTION_BIND_GET_ARG_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_bind_get_arg_name(
    info: duckdb_v2_function_bind_info_handle,
    index: idx_t,
    name: *mut duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_BIND_GET_ARG_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        index: idx_t,
        name: *mut duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, name, err)
}

static __DUCKDB_V2_FUNCTION_BIND_GET_ARG_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_bind_get_arg_type(
    info: duckdb_v2_function_bind_info_handle,
    index: idx_t,
    type_: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_BIND_GET_ARG_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        index: idx_t,
        type_: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, type_, err)
}

static __DUCKDB_V2_FUNCTION_BIND_GET_ARG_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_bind_get_arg_value(
    info: duckdb_v2_function_bind_info_handle,
    index: idx_t,
    value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_BIND_GET_ARG_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        index: idx_t,
        value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, index, value, err)
}

static __DUCKDB_V2_FUNCTION_BIND_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_bind_get_user_data(
    info: duckdb_v2_function_bind_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_BIND_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_FUNCTION_BIND_SET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_bind_set_bind_data(
    info: duckdb_v2_function_bind_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_BIND_SET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_function_bind_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_BIND_SET_ORDER_PRESERVATION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_bind_set_order_preservation(
    info: duckdb_v2_table_function_bind_info_handle,
    order: DUCKDB_V2_ORDER_PRESERVATION,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_BIND_SET_ORDER_PRESERVATION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_bind_info_handle,
        order: DUCKDB_V2_ORDER_PRESERVATION,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, order, err)
}

static __DUCKDB_V2_ARROW_RESULT_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_destroy(
    result: *mut duckdb_v2_arrow_result_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: *mut duckdb_v2_arrow_result_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result)
}

static __DUCKDB_V2_ARROW_RESULT_DRAIN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_drain(
    result: duckdb_v2_arrow_result_handle,
    out_rows_changed: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_DRAIN
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_arrow_result_handle,
        out_rows_changed: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_rows_changed, err)
}

static __DUCKDB_V2_ARROW_RESULT_FETCH_ARRAY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_fetch_array(
    result: duckdb_v2_arrow_result_handle,
    out_array: *mut ArrowArray,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_FETCH_ARRAY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_arrow_result_handle,
        out_array: *mut ArrowArray,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_array, err)
}

static __DUCKDB_V2_ARROW_RESULT_GET_RESULT_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_get_result_type(
    result: duckdb_v2_arrow_result_handle,
    out_type: *mut DUCKDB_V2_RESULT_TYPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_GET_RESULT_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_arrow_result_handle,
        out_type: *mut DUCKDB_V2_RESULT_TYPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_type, err)
}

static __DUCKDB_V2_ARROW_RESULT_GET_SCHEMA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_get_schema(
    result: duckdb_v2_arrow_result_handle,
    out_schema: *mut ArrowSchema,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_GET_SCHEMA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_arrow_result_handle,
        out_schema: *mut ArrowSchema,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_schema, err)
}

static __DUCKDB_V2_ARROW_RESULT_GET_STATEMENT_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_get_statement_type(
    result: duckdb_v2_arrow_result_handle,
    out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_GET_STATEMENT_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_arrow_result_handle,
        out_type: *mut DUCKDB_V2_STATEMENT_TYPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_type, err)
}

static __DUCKDB_V2_ARROW_RESULT_STEP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_step(
    result: duckdb_v2_arrow_result_handle,
    out_array: *mut ArrowArray,
    out_status: *mut DUCKDB_V2_RESULT_STEP_STATUS,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_STEP
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_arrow_result_handle,
        out_array: *mut ArrowArray,
        out_status: *mut DUCKDB_V2_RESULT_STEP_STATUS,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_array, out_status, err)
}

static __DUCKDB_V2_ARROW_RESULT_TO_ARROW_C_STREAM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_to_arrow_c_stream(
    result: *mut duckdb_v2_arrow_result_handle,
    out_stream: *mut ArrowArrayStream,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_TO_ARROW_C_STREAM
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: *mut duckdb_v2_arrow_result_handle,
        out_stream: *mut ArrowArrayStream,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, out_stream, err)
}

static __DUCKDB_V2_ARROW_RESULT_WAIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_arrow_result_wait(
    result: duckdb_v2_arrow_result_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_ARROW_RESULT_WAIT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        result: duckdb_v2_arrow_result_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(result, err)
}

static __DUCKDB_V2_PREPARED_STATEMENT_EXECUTE_ARROW: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_prepared_statement_execute_arrow(
    prepared: duckdb_v2_prepared_statement_handle,
    parameter_names: *const duckdb_v2_identifier_t,
    parameter_values: *const duckdb_v2_value_handle,
    parameter_count: idx_t,
    batch_size: idx_t,
    out_result: *mut duckdb_v2_arrow_result_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PREPARED_STATEMENT_EXECUTE_ARROW
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        prepared: duckdb_v2_prepared_statement_handle,
        parameter_names: *const duckdb_v2_identifier_t,
        parameter_values: *const duckdb_v2_value_handle,
        parameter_count: idx_t,
        batch_size: idx_t,
        out_result: *mut duckdb_v2_arrow_result_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(
        prepared,
        parameter_names,
        parameter_values,
        parameter_count,
        batch_size,
        out_result,
        err,
    )
}

static __DUCKDB_V2_STATEMENT_EXECUTE_ARROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_statement_execute_arrow(
    conn: duckdb_v2_connection_handle,
    statement: duckdb_v2_sql_statement_handle,
    parameter_names: *const duckdb_v2_identifier_t,
    parameter_values: *const duckdb_v2_value_handle,
    parameter_count: idx_t,
    batch_size: idx_t,
    out_result: *mut duckdb_v2_arrow_result_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_STATEMENT_EXECUTE_ARROW
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        statement: duckdb_v2_sql_statement_handle,
        parameter_names: *const duckdb_v2_identifier_t,
        parameter_values: *const duckdb_v2_value_handle,
        parameter_count: idx_t,
        batch_size: idx_t,
        out_result: *mut duckdb_v2_arrow_result_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(
        conn,
        statement,
        parameter_names,
        parameter_values,
        parameter_count,
        batch_size,
        out_result,
        err,
    )
}

static __DUCKDB_V2_SCALAR_FUNCTION_RESOLVE_TYPES_SET_RETURN_TYPE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_resolve_types_set_return_type(
    info: duckdb_v2_scalar_function_resolve_types_info_handle,
    return_type: duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_RESOLVE_TYPES_SET_RETURN_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_resolve_types_info_handle,
        return_type: duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, return_type, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_SET_RESOLVE_TYPES_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_set_resolve_types_callback(
    function: duckdb_v2_scalar_function_handle,
    callback: duckdb_v2_scalar_function_resolve_types_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_SET_RESOLVE_TYPES_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        callback: duckdb_v2_scalar_function_resolve_types_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_get_bind_info_get_bind_data(
    info: duckdb_v2_table_function_get_bind_info_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_GET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_get_bind_info_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_get_bind_info_get_user_data(
    info: duckdb_v2_table_function_get_bind_info_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_get_bind_info_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_SET_COLUMN_IDENTIFIER: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_get_bind_info_set_column_identifier(
    info: duckdb_v2_table_function_get_bind_info_info_handle,
    column_index: idx_t,
    child_path: *const idx_t,
    child_path_length: idx_t,
    identifier: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_SET_COLUMN_IDENTIFIER
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_get_bind_info_info_handle,
        column_index: idx_t,
        child_path: *const idx_t,
        child_path_length: idx_t,
        identifier: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, column_index, child_path, child_path_length, identifier, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_SET_OPTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_get_bind_info_set_option(
    info: duckdb_v2_table_function_get_bind_info_info_handle,
    key: *mut duckdb_v2_str,
    value: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_SET_OPTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_table_function_get_bind_info_info_handle,
        key: *mut duckdb_v2_str,
        value: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, key, value, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_SET_GET_BIND_INFO_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_table_function_set_get_bind_info_callback(
    function: duckdb_v2_table_function_handle,
    callback: duckdb_v2_table_function_get_bind_info_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_SET_GET_BIND_INFO_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        callback: duckdb_v2_table_function_get_bind_info_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_CONNECTION_GET_FACTORY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_get_factory(
    conn: duckdb_v2_connection_handle,
    out_factory: *mut duckdb_v2_factory_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_GET_FACTORY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        out_factory: *mut duckdb_v2_factory_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, out_factory, err)
}

static __DUCKDB_V2_CONTEXT_GET_FACTORY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_context_get_factory(
    ctx: duckdb_v2_context_handle,
    out_factory: *mut duckdb_v2_factory_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONTEXT_GET_FACTORY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        ctx: duckdb_v2_context_handle,
        out_factory: *mut duckdb_v2_factory_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(ctx, out_factory, err)
}

static __DUCKDB_V2_INSTANCE_GET_FACTORY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_get_factory(
    instance: duckdb_v2_instance_handle,
    out_factory: *mut duckdb_v2_factory_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_GET_FACTORY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        out_factory: *mut duckdb_v2_factory_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, out_factory, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_BIND_SET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_scalar_function_bind_set_bind_data(
    info: duckdb_v2_scalar_function_bind_info_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_BIND_SET_BIND_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_scalar_function_bind_info_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_CONFIG_GET_OPTION_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_config_get_option_value(
    config: duckdb_v2_config_handle,
    name: *const duckdb_v2_identifier_t,
    out_value: *mut duckdb_v2_value_handle,
    out_scope: *mut DUCKDB_V2_SETTING_SCOPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONFIG_GET_OPTION_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        config: duckdb_v2_config_handle,
        name: *const duckdb_v2_identifier_t,
        out_value: *mut duckdb_v2_value_handle,
        out_scope: *mut DUCKDB_V2_SETTING_SCOPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(config, name, out_value, out_scope, err)
}

static __DUCKDB_V2_CONFIG_SET_OPTION_TEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_config_set_option_text(
    config: duckdb_v2_config_handle,
    name: *const duckdb_v2_identifier_t,
    setting: *const duckdb_v2_str,
    scope: DUCKDB_V2_SETTING_SCOPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONFIG_SET_OPTION_TEXT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        config: duckdb_v2_config_handle,
        name: *const duckdb_v2_identifier_t,
        setting: *const duckdb_v2_str,
        scope: DUCKDB_V2_SETTING_SCOPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(config, name, setting, scope, err)
}

static __DUCKDB_V2_CONFIG_SET_OPTION_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_config_set_option_value(
    config: duckdb_v2_config_handle,
    name: *const duckdb_v2_identifier_t,
    value: duckdb_v2_value_handle,
    scope: DUCKDB_V2_SETTING_SCOPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONFIG_SET_OPTION_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        config: duckdb_v2_config_handle,
        name: *const duckdb_v2_identifier_t,
        value: duckdb_v2_value_handle,
        scope: DUCKDB_V2_SETTING_SCOPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(config, name, value, scope, err)
}

static __DUCKDB_V2_CONNECTION_GET_CONFIG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_get_config(
    conn: duckdb_v2_connection_handle,
    out_config: *mut duckdb_v2_config_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_GET_CONFIG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        out_config: *mut duckdb_v2_config_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, out_config, err)
}

static __DUCKDB_V2_CONNECTION_GET_FILE_SYSTEM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_get_file_system(
    conn: duckdb_v2_connection_handle,
    file_system: *mut duckdb_v2_file_system_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_GET_FILE_SYSTEM
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        file_system: *mut duckdb_v2_file_system_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, file_system, err)
}

static __DUCKDB_V2_CONNECTION_LOG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_log(
    conn: duckdb_v2_connection_handle,
    level: DUCKDB_V2_LOG_LEVEL,
    log_type: *const duckdb_v2_str,
    message: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_LOG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        level: DUCKDB_V2_LOG_LEVEL,
        log_type: *const duckdb_v2_str,
        message: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, level, log_type, message, err)
}

static __DUCKDB_V2_CONTEXT_GET_CONFIG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_context_get_config(
    ctx: duckdb_v2_context_handle,
    out_config: *mut duckdb_v2_config_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONTEXT_GET_CONFIG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        ctx: duckdb_v2_context_handle,
        out_config: *mut duckdb_v2_config_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(ctx, out_config, err)
}

static __DUCKDB_V2_INSTANCE_GET_CONFIG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_get_config(
    instance: duckdb_v2_instance_handle,
    out_config: *mut duckdb_v2_config_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_GET_CONFIG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        out_config: *mut duckdb_v2_config_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, out_config, err)
}

static __DUCKDB_V2_INSTANCE_GET_FILE_SYSTEM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_get_file_system(
    instance: duckdb_v2_instance_handle,
    file_system: *mut duckdb_v2_file_system_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_GET_FILE_SYSTEM
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        file_system: *mut duckdb_v2_file_system_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, file_system, err)
}

static __DUCKDB_V2_INSTANCE_LOG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_log(
    instance: duckdb_v2_instance_handle,
    level: DUCKDB_V2_LOG_LEVEL,
    log_type: *const duckdb_v2_str,
    message: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_LOG
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        level: DUCKDB_V2_LOG_LEVEL,
        log_type: *const duckdb_v2_str,
        message: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, level, log_type, message, err)
}

static __DUCKDB_V2_OPTION_GET_DEFAULT_SCOPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_option_get_default_scope(
    option: duckdb_v2_option_handle,
    out_scope: *mut DUCKDB_V2_SETTING_SCOPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_OPTION_GET_DEFAULT_SCOPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_option_handle,
        out_scope: *mut DUCKDB_V2_SETTING_SCOPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, out_scope, err)
}

static __DUCKDB_V2_OPTION_SUPPORTS_SCOPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_option_supports_scope(
    option: duckdb_v2_option_handle,
    scope: DUCKDB_V2_SETTING_SCOPE,
    out_supported: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_OPTION_SUPPORTS_SCOPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_option_handle,
        scope: DUCKDB_V2_SETTING_SCOPE,
        out_supported: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, scope, out_supported, err)
}

static __DUCKDB_V2_AGGREGATE_FUNCTION_GET_DOCS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_aggregate_function_get_docs(
    function: duckdb_v2_aggregate_function_handle,
    docs: *mut duckdb_v2_function_docs_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_AGGREGATE_FUNCTION_GET_DOCS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_aggregate_function_handle,
        docs: *mut duckdb_v2_function_docs_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, docs, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_PRAGMA_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_pragma_function(
    conn: duckdb_v2_connection_handle,
    function: duckdb_v2_pragma_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_PRAGMA_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        function: duckdb_v2_pragma_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, function, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_PRAGMA_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_pragma_function(
    extension: duckdb_v2_extension_handle,
    function: duckdb_v2_pragma_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_PRAGMA_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        function: duckdb_v2_pragma_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, function, err)
}

static __DUCKDB_V2_FACTORY_CREATE_COMMON_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_factory_create_common_type(
    factory: duckdb_v2_factory_handle,
    types: *const duckdb_v2_logical_type_handle,
    type_count: idx_t,
    out_type: *mut duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FACTORY_CREATE_COMMON_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        types: *const duckdb_v2_logical_type_handle,
        type_count: idx_t,
        out_type: *mut duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, types, type_count, out_type, err)
}

static __DUCKDB_V2_FUNCTION_DOCS_ADD_CATEGORY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_docs_add_category(
    docs: duckdb_v2_function_docs_handle,
    category: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_DOCS_ADD_CATEGORY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        docs: duckdb_v2_function_docs_handle,
        category: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(docs, category, err)
}

static __DUCKDB_V2_FUNCTION_DOCS_ADD_EXAMPLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_docs_add_example(
    docs: duckdb_v2_function_docs_handle,
    title: *const duckdb_v2_str,
    example: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_DOCS_ADD_EXAMPLE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        docs: duckdb_v2_function_docs_handle,
        title: *const duckdb_v2_str,
        example: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(docs, title, example, err)
}

static __DUCKDB_V2_FUNCTION_DOCS_SET_DESCRIPTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_function_docs_set_description(
    docs: duckdb_v2_function_docs_handle,
    description: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FUNCTION_DOCS_SET_DESCRIPTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        docs: duckdb_v2_function_docs_handle,
        description: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(docs, description, err)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_pragma_function_create(
    factory: duckdb_v2_factory_handle,
    function: *mut duckdb_v2_pragma_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        function: *mut duckdb_v2_pragma_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, function, err)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_pragma_function_destroy(
    function: *mut duckdb_v2_pragma_function_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: *mut duckdb_v2_pragma_function_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_GET_DOCS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_pragma_function_get_docs(
    function: duckdb_v2_pragma_function_handle,
    docs: *mut duckdb_v2_function_docs_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_GET_DOCS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_pragma_function_handle,
        docs: *mut duckdb_v2_function_docs_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, docs, err)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_GET_SIGNATURE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_pragma_function_get_signature(
    function: duckdb_v2_pragma_function_handle,
    sig: *mut duckdb_v2_function_signature_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_GET_SIGNATURE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_pragma_function_handle,
        sig: *mut duckdb_v2_function_signature_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, sig, err)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_QUERY_SET_QUERY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_pragma_function_query_set_query(
    info: duckdb_v2_pragma_function_query_info_handle,
    query: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_QUERY_SET_QUERY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_pragma_function_query_info_handle,
        query: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, query, err)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_SET_EXEC_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_pragma_function_set_exec_callback(
    function: duckdb_v2_pragma_function_handle,
    callback: duckdb_v2_pragma_function_exec_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_SET_EXEC_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_pragma_function_handle,
        callback: duckdb_v2_pragma_function_exec_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_pragma_function_set_name(
    function: duckdb_v2_pragma_function_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_pragma_function_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, name, err)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_SET_QUERY_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_pragma_function_set_query_callback(
    function: duckdb_v2_pragma_function_handle,
    callback: duckdb_v2_pragma_function_query_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_SET_QUERY_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_pragma_function_handle,
        callback: duckdb_v2_pragma_function_query_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, callback, err)
}

static __DUCKDB_V2_PRAGMA_FUNCTION_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_pragma_function_set_user_data(
    function: duckdb_v2_pragma_function_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_PRAGMA_FUNCTION_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_pragma_function_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, data, err)
}

static __DUCKDB_V2_SCALAR_FUNCTION_GET_DOCS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_scalar_function_get_docs(
    function: duckdb_v2_scalar_function_handle,
    docs: *mut duckdb_v2_function_docs_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_SCALAR_FUNCTION_GET_DOCS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_scalar_function_handle,
        docs: *mut duckdb_v2_function_docs_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, docs, err)
}

static __DUCKDB_V2_TABLE_FUNCTION_GET_DOCS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_table_function_get_docs(
    function: duckdb_v2_table_function_handle,
    docs: *mut duckdb_v2_function_docs_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_TABLE_FUNCTION_GET_DOCS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_table_function_handle,
        docs: *mut duckdb_v2_function_docs_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, docs, err)
}

static __DUCKDB_V2_CONNECTION_REGISTER_CUSTOM_OPTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_connection_register_custom_option(
    conn: duckdb_v2_connection_handle,
    option: duckdb_v2_custom_option_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_REGISTER_CUSTOM_OPTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        option: duckdb_v2_custom_option_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, option, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_create(
    factory: duckdb_v2_factory_handle,
    option: *mut duckdb_v2_custom_option_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        option: *mut duckdb_v2_custom_option_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, option, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_destroy(
    option: *mut duckdb_v2_custom_option_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: *mut duckdb_v2_custom_option_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option)
}

static __DUCKDB_V2_CUSTOM_OPTION_SET_DEFAULT_SCOPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_set_default_scope(
    option: duckdb_v2_custom_option_handle,
    scope: DUCKDB_V2_SETTING_SCOPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_SET_DEFAULT_SCOPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_custom_option_handle,
        scope: DUCKDB_V2_SETTING_SCOPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, scope, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_SET_DEFAULT_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_set_default_value(
    option: duckdb_v2_custom_option_handle,
    value: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_SET_DEFAULT_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_custom_option_handle,
        value: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, value, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_SET_DESCRIPTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_set_description(
    option: duckdb_v2_custom_option_handle,
    description: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_SET_DESCRIPTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_custom_option_handle,
        description: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, description, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_set_name(
    option: duckdb_v2_custom_option_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_custom_option_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, name, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_SET_SUPPORTS_SCOPE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_custom_option_set_supports_scope(
    option: duckdb_v2_custom_option_handle,
    scope: DUCKDB_V2_SETTING_SCOPE,
    supported: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_SET_SUPPORTS_SCOPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_custom_option_handle,
        scope: DUCKDB_V2_SETTING_SCOPE,
        supported: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, scope, supported, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_SET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_set_type(
    option: duckdb_v2_custom_option_handle,
    type_: duckdb_v2_logical_type_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_SET_TYPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_custom_option_handle,
        type_: duckdb_v2_logical_type_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, type_, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_SET_UPDATE_CALLBACK: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_custom_option_set_update_callback(
    option: duckdb_v2_custom_option_handle,
    callback: duckdb_v2_custom_option_update_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_SET_UPDATE_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_custom_option_handle,
        callback: duckdb_v2_custom_option_update_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, callback, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_set_user_data(
    option: duckdb_v2_custom_option_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        option: duckdb_v2_custom_option_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(option, data, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_SCOPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_update_get_scope(
    info: duckdb_v2_custom_option_update_info_handle,
    scope: *mut DUCKDB_V2_SETTING_SCOPE,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_SCOPE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_custom_option_update_info_handle,
        scope: *mut DUCKDB_V2_SETTING_SCOPE,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, scope, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_USER_DATA: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_custom_option_update_get_user_data(
    info: duckdb_v2_custom_option_update_info_handle,
    data: *mut *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_custom_option_update_info_handle,
        data: *mut *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, data, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_update_get_value(
    info: duckdb_v2_custom_option_update_info_handle,
    value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_custom_option_update_info_handle,
        value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, value, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_UPDATE_IS_RESET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_update_is_reset(
    info: duckdb_v2_custom_option_update_info_handle,
    is_reset: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_UPDATE_IS_RESET
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_custom_option_update_info_handle,
        is_reset: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, is_reset, err)
}

static __DUCKDB_V2_CUSTOM_OPTION_UPDATE_SET_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_custom_option_update_set_value(
    info: duckdb_v2_custom_option_update_info_handle,
    value: duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CUSTOM_OPTION_UPDATE_SET_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_custom_option_update_info_handle,
        value: duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, value, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_CUSTOM_OPTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_custom_option(
    extension: duckdb_v2_extension_handle,
    option: duckdb_v2_custom_option_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_CUSTOM_OPTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        option: duckdb_v2_custom_option_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, option, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_LOG_SINK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_extension_register_log_sink(
    extension: duckdb_v2_extension_handle,
    sink: duckdb_v2_log_sink_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_LOG_SINK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        sink: duckdb_v2_log_sink_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, sink, err)
}

static __DUCKDB_V2_EXTENSION_REGISTER_MACRO_FUNCTION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_extension_register_macro_function(
    extension: duckdb_v2_extension_handle,
    function: duckdb_v2_macro_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_EXTENSION_REGISTER_MACRO_FUNCTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        extension: duckdb_v2_extension_handle,
        function: duckdb_v2_macro_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(extension, function, err)
}

static __DUCKDB_V2_FILE_SYSTEM_PATH_EXISTS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_system_path_exists(
    file_system: duckdb_v2_file_system_handle,
    path: *const duckdb_v2_str,
    out_exists: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SYSTEM_PATH_EXISTS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file_system: duckdb_v2_file_system_handle,
        path: *const duckdb_v2_str,
        out_exists: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file_system, path, out_exists, err)
}

static __DUCKDB_V2_FILE_SYSTEM_PATH_EXPAND: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_system_path_expand(
    file_system: duckdb_v2_file_system_handle,
    path: *const duckdb_v2_str,
    sink: duckdb_v2_text_sink_fn,
    user_data: *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SYSTEM_PATH_EXPAND
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file_system: duckdb_v2_file_system_handle,
        path: *const duckdb_v2_str,
        sink: duckdb_v2_text_sink_fn,
        user_data: *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file_system, path, sink, user_data, err)
}

static __DUCKDB_V2_FILE_SYSTEM_PATH_IS_REMOTE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_system_path_is_remote(
    file_system: duckdb_v2_file_system_handle,
    path: *const duckdb_v2_str,
    out_is_remote: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SYSTEM_PATH_IS_REMOTE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file_system: duckdb_v2_file_system_handle,
        path: *const duckdb_v2_str,
        out_is_remote: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file_system, path, out_is_remote, err)
}

static __DUCKDB_V2_INSTANCE_REGISTER_LOG_SINK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_instance_register_log_sink(
    instance: duckdb_v2_instance_handle,
    sink: duckdb_v2_log_sink_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_INSTANCE_REGISTER_LOG_SINK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        instance: duckdb_v2_instance_handle,
        sink: duckdb_v2_log_sink_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(instance, sink, err)
}

static __DUCKDB_V2_LOG_SINK_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_log_sink_create(
    factory: duckdb_v2_factory_handle,
    sink: *mut duckdb_v2_log_sink_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        sink: *mut duckdb_v2_log_sink_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, sink, err)
}

static __DUCKDB_V2_LOG_SINK_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_log_sink_destroy(
    sink: *mut duckdb_v2_log_sink_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        sink: *mut duckdb_v2_log_sink_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(sink)
}

static __DUCKDB_V2_LOG_SINK_SET_FLUSH_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_log_sink_set_flush_callback(
    sink: duckdb_v2_log_sink_handle,
    callback: duckdb_v2_log_sink_flush_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_SET_FLUSH_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        sink: duckdb_v2_log_sink_handle,
        callback: duckdb_v2_log_sink_flush_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(sink, callback, err)
}

static __DUCKDB_V2_LOG_SINK_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_log_sink_set_name(
    sink: duckdb_v2_log_sink_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        sink: duckdb_v2_log_sink_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(sink, name, err)
}

static __DUCKDB_V2_LOG_SINK_SET_USER_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_log_sink_set_user_data(
    sink: duckdb_v2_log_sink_handle,
    data: *mut duckdb_v2_opaque,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_SET_USER_DATA
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        sink: duckdb_v2_log_sink_handle,
        data: *mut duckdb_v2_opaque,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(sink, data, err)
}

static __DUCKDB_V2_LOG_SINK_SET_WRITE_CALLBACK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_log_sink_set_write_callback(
    sink: duckdb_v2_log_sink_handle,
    callback: duckdb_v2_log_sink_write_callback_fn,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_SET_WRITE_CALLBACK
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        sink: duckdb_v2_log_sink_handle,
        callback: duckdb_v2_log_sink_write_callback_fn,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(sink, callback, err)
}

static __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_CONNECTION_ID: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_log_sink_write_info_get_connection_id(
    info: duckdb_v2_log_sink_write_info_handle,
    id: *mut idx_t,
    present: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_CONNECTION_ID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_log_sink_write_info_handle,
        id: *mut idx_t,
        present: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, id, present, err)
}

static __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_QUERY_ID: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_log_sink_write_info_get_query_id(
    info: duckdb_v2_log_sink_write_info_handle,
    id: *mut idx_t,
    present: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_QUERY_ID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_log_sink_write_info_handle,
        id: *mut idx_t,
        present: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, id, present, err)
}

static __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_THREAD_ID: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_log_sink_write_info_get_thread_id(
    info: duckdb_v2_log_sink_write_info_handle,
    id: *mut idx_t,
    present: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_THREAD_ID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_log_sink_write_info_handle,
        id: *mut idx_t,
        present: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, id, present, err)
}

static __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_TRANSACTION_ID: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_log_sink_write_info_get_transaction_id(
    info: duckdb_v2_log_sink_write_info_handle,
    id: *mut idx_t,
    present: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_TRANSACTION_ID
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        info: duckdb_v2_log_sink_write_info_handle,
        id: *mut idx_t,
        present: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(info, id, present, err)
}

static __DUCKDB_V2_MACRO_FUNCTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_macro_function_create(
    factory: duckdb_v2_factory_handle,
    type_: DUCKDB_V2_MACRO_FUNCTION_TYPE,
    function: *mut duckdb_v2_macro_function_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MACRO_FUNCTION_CREATE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        type_: DUCKDB_V2_MACRO_FUNCTION_TYPE,
        function: *mut duckdb_v2_macro_function_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, type_, function, err)
}

static __DUCKDB_V2_MACRO_FUNCTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_macro_function_destroy(
    function: *mut duckdb_v2_macro_function_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MACRO_FUNCTION_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: *mut duckdb_v2_macro_function_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function)
}

static __DUCKDB_V2_MACRO_FUNCTION_GET_DOCS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_macro_function_get_docs(
    function: duckdb_v2_macro_function_handle,
    docs: *mut duckdb_v2_function_docs_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MACRO_FUNCTION_GET_DOCS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_macro_function_handle,
        docs: *mut duckdb_v2_function_docs_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, docs, err)
}

static __DUCKDB_V2_MACRO_FUNCTION_GET_SIGNATURE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_macro_function_get_signature(
    function: duckdb_v2_macro_function_handle,
    sig: *mut duckdb_v2_function_signature_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MACRO_FUNCTION_GET_SIGNATURE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_macro_function_handle,
        sig: *mut duckdb_v2_function_signature_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, sig, err)
}

static __DUCKDB_V2_MACRO_FUNCTION_SET_BODY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_macro_function_set_body(
    function: duckdb_v2_macro_function_handle,
    body: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MACRO_FUNCTION_SET_BODY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_macro_function_handle,
        body: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, body, err)
}

static __DUCKDB_V2_MACRO_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_macro_function_set_name(
    function: duckdb_v2_macro_function_handle,
    name: *const duckdb_v2_identifier_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_MACRO_FUNCTION_SET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_macro_function_handle,
        name: *const duckdb_v2_identifier_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, name, err)
}

static __DUCKDB_V2_VECTOR_CAST: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_vector_cast(
    factory: duckdb_v2_factory_handle,
    source: duckdb_v2_vector_handle,
    target: duckdb_v2_vector_handle,
    mode: DUCKDB_V2_CAST_MODE,
    out_converted: *mut bool,
    cast_err: *mut duckdb_v2_error_info_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_VECTOR_CAST
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        factory: duckdb_v2_factory_handle,
        source: duckdb_v2_vector_handle,
        target: duckdb_v2_vector_handle,
        mode: DUCKDB_V2_CAST_MODE,
        out_converted: *mut bool,
        cast_err: *mut duckdb_v2_error_info_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(factory, source, target, mode, out_converted, cast_err, err)
}

static __DUCKDB_V2_CONNECTION_ENABLE_PROFILING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_enable_profiling(
    conn: duckdb_v2_connection_handle,
    enabled: bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_ENABLE_PROFILING
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        enabled: bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, enabled, err)
}

static __DUCKDB_V2_CONNECTION_GET_QUERY_METRICS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_connection_get_query_metrics(
    conn: duckdb_v2_connection_handle,
    metrics: *mut duckdb_v2_query_metrics_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_CONNECTION_GET_QUERY_METRICS
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        conn: duckdb_v2_connection_handle,
        metrics: *mut duckdb_v2_query_metrics_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(conn, metrics, err)
}

static __DUCKDB_V2_COPY_FUNCTION_SET_FILE_EXTENSION: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_copy_function_set_file_extension(
    function: duckdb_v2_copy_function_handle,
    extension: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_COPY_FUNCTION_SET_FILE_EXTENSION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        function: duckdb_v2_copy_function_handle,
        extension: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(function, extension, err)
}

static __DUCKDB_V2_DATA_CHUNK_CLEAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_data_chunk_clear(
    chunk: duckdb_v2_data_chunk_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_DATA_CHUNK_CLEAR
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        chunk: duckdb_v2_data_chunk_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(chunk, err)
}

static __DUCKDB_V2_FILE_SYSTEM_PATH_GLOB: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_system_path_glob(
    file_system: duckdb_v2_file_system_handle,
    pattern: *const duckdb_v2_str,
    callback: duckdb_v2_file_system_path_glob_callback_fn,
    user_data: *mut ::std::os::raw::c_void,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SYSTEM_PATH_GLOB
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file_system: duckdb_v2_file_system_handle,
        pattern: *const duckdb_v2_str,
        callback: duckdb_v2_file_system_path_glob_callback_fn,
        user_data: *mut ::std::os::raw::c_void,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file_system, pattern, callback, user_data, err)
}

static __DUCKDB_V2_FILE_SYSTEM_PATH_MOVE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_system_path_move(
    file_system: duckdb_v2_file_system_handle,
    source: *const duckdb_v2_str,
    target: *const duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SYSTEM_PATH_MOVE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file_system: duckdb_v2_file_system_handle,
        source: *const duckdb_v2_str,
        target: *const duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file_system, source, target, err)
}

static __DUCKDB_V2_FILE_SYSTEM_PATH_REMOVE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_file_system_path_remove(
    file_system: duckdb_v2_file_system_handle,
    path: *const duckdb_v2_str,
    out_removed: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_FILE_SYSTEM_PATH_REMOVE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        file_system: duckdb_v2_file_system_handle,
        path: *const duckdb_v2_str,
        out_removed: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(file_system, path, out_removed, err)
}

static __DUCKDB_V2_QUERY_METRICS_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_query_metrics_destroy(
    metrics: *mut duckdb_v2_query_metrics_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_DESTROY
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        metrics: *mut duckdb_v2_query_metrics_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(metrics)
}

static __DUCKDB_V2_QUERY_METRICS_GET_ROOT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_query_metrics_get_root(
    metrics: duckdb_v2_query_metrics_handle,
    node: *mut duckdb_v2_query_metrics_node_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_GET_ROOT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        metrics: duckdb_v2_query_metrics_handle,
        node: *mut duckdb_v2_query_metrics_node_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(metrics, node, err)
}

static __DUCKDB_V2_QUERY_METRICS_NODE_GET_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_query_metrics_node_get_child(
    node: duckdb_v2_query_metrics_node_handle,
    index: idx_t,
    child: *mut duckdb_v2_query_metrics_node_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_NODE_GET_CHILD
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        node: duckdb_v2_query_metrics_node_handle,
        index: idx_t,
        child: *mut duckdb_v2_query_metrics_node_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(node, index, child, err)
}

static __DUCKDB_V2_QUERY_METRICS_NODE_GET_CHILD_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_query_metrics_node_get_child_count(
    node: duckdb_v2_query_metrics_node_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_NODE_GET_CHILD_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        node: duckdb_v2_query_metrics_node_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(node, count, err)
}

static __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_query_metrics_node_get_metric(
    node: duckdb_v2_query_metrics_node_handle,
    name: *const duckdb_v2_str,
    value: *mut duckdb_v2_value_handle,
    present: *mut bool,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        node: duckdb_v2_query_metrics_node_handle,
        name: *const duckdb_v2_str,
        value: *mut duckdb_v2_value_handle,
        present: *mut bool,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(node, name, value, present, err)
}

static __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_COUNT: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_query_metrics_node_get_metric_count(
    node: duckdb_v2_query_metrics_node_handle,
    count: *mut idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_COUNT
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        node: duckdb_v2_query_metrics_node_handle,
        count: *mut idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(node, count, err)
}

static __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_NAME: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_query_metrics_node_get_metric_name(
    node: duckdb_v2_query_metrics_node_handle,
    index: idx_t,
    name: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        node: duckdb_v2_query_metrics_node_handle,
        index: idx_t,
        name: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(node, index, name, err)
}

static __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_VALUE: ::std::sync::atomic::AtomicPtr<
    (),
> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
pub unsafe extern "C" fn duckdb_v2_query_metrics_node_get_metric_value(
    node: duckdb_v2_query_metrics_node_handle,
    index: idx_t,
    value: *mut duckdb_v2_value_handle,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_VALUE
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        node: duckdb_v2_query_metrics_node_handle,
        index: idx_t,
        value: *mut duckdb_v2_value_handle,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(node, index, value, err)
}

static __DUCKDB_V2_QUERY_METRICS_NODE_GET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_query_metrics_node_get_name(
    node: duckdb_v2_query_metrics_node_handle,
    name: *mut duckdb_v2_str,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_QUERY_METRICS_NODE_GET_NAME
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        node: duckdb_v2_query_metrics_node_handle,
        name: *mut duckdb_v2_str,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(node, name, err)
}

static __DUCKDB_V2_STATEMENT_ADD_COLLECTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
    ::std::ptr::null_mut(),
);
pub unsafe extern "C" fn duckdb_v2_statement_add_collection(
    statement: duckdb_v2_sql_statement_handle,
    name: *const duckdb_v2_identifier_t,
    collection: duckdb_v2_column_data_collection_handle,
    column_names: *const duckdb_v2_identifier_t,
    column_count: idx_t,
    err: *mut duckdb_v2_error_info_handle,
) -> DUCKDB_V2_ERROR {
    let function_ptr = __DUCKDB_V2_STATEMENT_ADD_COLLECTION
        .load(::std::sync::atomic::Ordering::Acquire);
    assert!(
        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
    );
    let fun: unsafe extern "C" fn(
        statement: duckdb_v2_sql_statement_handle,
        name: *const duckdb_v2_identifier_t,
        collection: duckdb_v2_column_data_collection_handle,
        column_names: *const duckdb_v2_identifier_t,
        column_count: idx_t,
        err: *mut duckdb_v2_error_info_handle,
    ) -> DUCKDB_V2_ERROR = ::std::mem::transmute(function_ptr);
    (fun)(statement, name, collection, column_names, column_count, err)
}

/// Like DUCKDB_EXTENSION_API_INIT macro
pub unsafe fn duckdb_rs_extension_api_v2_init(
    input: &duckdb_v2_extension_input,
    version: &str,
) -> ::std::result::Result<bool, &'static str> {
    let version_c_string = std::ffi::CString::new(version).unwrap();
    let Some(get_api) = input.get_api else {
        return Err("get_api is NULL: loadable extensions cannot be statically linked");
    };
    let p_api = get_api(input.extension, version_c_string.as_ptr())
        as *const duckdb_ext_api_v2;
    if p_api.is_null() {
        return Ok(false);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arena_allocate {
        __DUCKDB_V2_ARENA_ALLOCATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_bignum_decode {
        __DUCKDB_V2_BIGNUM_DECODE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_bignum_encode {
        __DUCKDB_V2_BIGNUM_ENCODE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_append {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_append_state_create {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND_STATE_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_append_state_destroy {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_APPEND_STATE_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_combine {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_COMBINE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_create {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_destroy {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_reset {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_RESET
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_row_count {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_ROW_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_scan {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_SCAN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_shared_scan_state_create
    {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_SHARED_SCAN_STATE_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_column_data_collection_shared_scan_state_destroy
    {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_SHARED_SCAN_STATE_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_worker_scan_state_create
    {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_WORKER_SCAN_STATE_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_column_data_collection_worker_scan_state_destroy
    {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_WORKER_SCAN_STATE_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_config_get_option_by_index {
        __DUCKDB_V2_CONFIG_GET_OPTION_BY_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_config_get_option_by_name {
        __DUCKDB_V2_CONFIG_GET_OPTION_BY_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_config_get_option_count {
        __DUCKDB_V2_CONFIG_GET_OPTION_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_create {
        __DUCKDB_V2_CONNECTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_destroy {
        __DUCKDB_V2_CONNECTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_interrupt {
        __DUCKDB_V2_CONNECTION_INTERRUPT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_progress_get {
        __DUCKDB_V2_CONNECTION_PROGRESS_GET
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_data_chunk_copy {
        __DUCKDB_V2_DATA_CHUNK_COPY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_data_chunk_create {
        __DUCKDB_V2_DATA_CHUNK_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_data_chunk_destroy {
        __DUCKDB_V2_DATA_CHUNK_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_data_chunk_get_size {
        __DUCKDB_V2_DATA_CHUNK_GET_SIZE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_data_chunk_get_vector {
        __DUCKDB_V2_DATA_CHUNK_GET_VECTOR
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_data_chunk_get_vector_count {
        __DUCKDB_V2_DATA_CHUNK_GET_VECTOR_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_environment_create {
        __DUCKDB_V2_ENVIRONMENT_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_environment_destroy {
        __DUCKDB_V2_ENVIRONMENT_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_environment_get_instance_count {
        __DUCKDB_V2_ENVIRONMENT_GET_INSTANCE_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_error_info_destroy {
        __DUCKDB_V2_ERROR_INFO_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_error_info_get_code {
        __DUCKDB_V2_ERROR_INFO_GET_CODE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_error_info_get_raw_text {
        __DUCKDB_V2_ERROR_INFO_GET_RAW_TEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_error_info_get_text {
        __DUCKDB_V2_ERROR_INFO_GET_TEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_error_info_set_code {
        __DUCKDB_V2_ERROR_INFO_SET_CODE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_error_info_set_text {
        __DUCKDB_V2_ERROR_INFO_SET_TEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_factory_create_type_from_id {
        __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_ID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_factory_create_type_from_name {
        __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_factory_create_type_from_text {
        __DUCKDB_V2_FACTORY_CREATE_TYPE_FROM_TEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_factory_create_type_with_alias {
        __DUCKDB_V2_FACTORY_CREATE_TYPE_WITH_ALIAS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_attach {
        __DUCKDB_V2_INSTANCE_ATTACH
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_create {
        __DUCKDB_V2_INSTANCE_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_create_with_options {
        __DUCKDB_V2_INSTANCE_CREATE_WITH_OPTIONS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_destroy {
        __DUCKDB_V2_INSTANCE_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_detach {
        __DUCKDB_V2_INSTANCE_DETACH
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_library_version {
        __DUCKDB_V2_LIBRARY_VERSION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_logical_type_copy {
        __DUCKDB_V2_LOGICAL_TYPE_COPY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_logical_type_destroy {
        __DUCKDB_V2_LOGICAL_TYPE_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_logical_type_get_id {
        __DUCKDB_V2_LOGICAL_TYPE_GET_ID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_logical_type_get_name {
        __DUCKDB_V2_LOGICAL_TYPE_GET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_logical_type_get_param {
        __DUCKDB_V2_LOGICAL_TYPE_GET_PARAM
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_logical_type_get_param_count {
        __DUCKDB_V2_LOGICAL_TYPE_GET_PARAM_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_logical_type_is_equal {
        __DUCKDB_V2_LOGICAL_TYPE_IS_EQUAL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_logical_type_to_text {
        __DUCKDB_V2_LOGICAL_TYPE_TO_TEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_option_destroy {
        __DUCKDB_V2_OPTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_option_get_alias {
        __DUCKDB_V2_OPTION_GET_ALIAS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_option_get_alias_count {
        __DUCKDB_V2_OPTION_GET_ALIAS_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_option_get_default_value {
        __DUCKDB_V2_OPTION_GET_DEFAULT_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_option_get_description {
        __DUCKDB_V2_OPTION_GET_DESCRIPTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_option_get_name {
        __DUCKDB_V2_OPTION_GET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_parse_sql {
        __DUCKDB_V2_PARSE_SQL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_destroy {
        __DUCKDB_V2_RESULT_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_drain {
        __DUCKDB_V2_RESULT_DRAIN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_fetch_chunk {
        __DUCKDB_V2_RESULT_FETCH_CHUNK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_get_result_type {
        __DUCKDB_V2_RESULT_GET_RESULT_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_get_schema {
        __DUCKDB_V2_RESULT_GET_SCHEMA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_get_statement_type {
        __DUCKDB_V2_RESULT_GET_STATEMENT_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_render_box {
        __DUCKDB_V2_RESULT_RENDER_BOX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_step {
        __DUCKDB_V2_RESULT_STEP
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_result_wait {
        __DUCKDB_V2_RESULT_WAIT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_schema_destroy {
        __DUCKDB_V2_SCHEMA_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_schema_get_count {
        __DUCKDB_V2_SCHEMA_GET_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_schema_get_field {
        __DUCKDB_V2_SCHEMA_GET_FIELD
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_sql_statement_destroy {
        __DUCKDB_V2_SQL_STATEMENT_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_statement_bind {
        __DUCKDB_V2_STATEMENT_BIND
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_statement_execute {
        __DUCKDB_V2_STATEMENT_EXECUTE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_statement_iterator_destroy {
        __DUCKDB_V2_STATEMENT_ITERATOR_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_statement_iterator_next {
        __DUCKDB_V2_STATEMENT_ITERATOR_NEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_cast {
        __DUCKDB_V2_VALUE_CAST
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_array {
        __DUCKDB_V2_VALUE_CREATE_ARRAY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_bigint {
        __DUCKDB_V2_VALUE_CREATE_BIGINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_bignum {
        __DUCKDB_V2_VALUE_CREATE_BIGNUM
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_bit {
        __DUCKDB_V2_VALUE_CREATE_BIT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_blob {
        __DUCKDB_V2_VALUE_CREATE_BLOB
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_bool {
        __DUCKDB_V2_VALUE_CREATE_BOOL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_date {
        __DUCKDB_V2_VALUE_CREATE_DATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_decimal {
        __DUCKDB_V2_VALUE_CREATE_DECIMAL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_double {
        __DUCKDB_V2_VALUE_CREATE_DOUBLE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_float {
        __DUCKDB_V2_VALUE_CREATE_FLOAT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_hugeint {
        __DUCKDB_V2_VALUE_CREATE_HUGEINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_int {
        __DUCKDB_V2_VALUE_CREATE_INT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_interval {
        __DUCKDB_V2_VALUE_CREATE_INTERVAL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_list {
        __DUCKDB_V2_VALUE_CREATE_LIST
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_map {
        __DUCKDB_V2_VALUE_CREATE_MAP
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_null {
        __DUCKDB_V2_VALUE_CREATE_NULL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_smallint {
        __DUCKDB_V2_VALUE_CREATE_SMALLINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_struct {
        __DUCKDB_V2_VALUE_CREATE_STRUCT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_time {
        __DUCKDB_V2_VALUE_CREATE_TIME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_time_ns {
        __DUCKDB_V2_VALUE_CREATE_TIME_NS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_time_tz {
        __DUCKDB_V2_VALUE_CREATE_TIME_TZ
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_timestamp {
        __DUCKDB_V2_VALUE_CREATE_TIMESTAMP
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_timestamp_ms {
        __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_MS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_timestamp_ns {
        __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_NS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_timestamp_sec {
        __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_SEC
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_timestamp_tz {
        __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_TZ
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_timestamp_tz_ns {
        __DUCKDB_V2_VALUE_CREATE_TIMESTAMP_TZ_NS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_tinyint {
        __DUCKDB_V2_VALUE_CREATE_TINYINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_tuple {
        __DUCKDB_V2_VALUE_CREATE_TUPLE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_type {
        __DUCKDB_V2_VALUE_CREATE_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_ubigint {
        __DUCKDB_V2_VALUE_CREATE_UBIGINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_uhugeint {
        __DUCKDB_V2_VALUE_CREATE_UHUGEINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_uint {
        __DUCKDB_V2_VALUE_CREATE_UINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_usmallint {
        __DUCKDB_V2_VALUE_CREATE_USMALLINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_utinyint {
        __DUCKDB_V2_VALUE_CREATE_UTINYINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_uuid {
        __DUCKDB_V2_VALUE_CREATE_UUID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_create_varchar {
        __DUCKDB_V2_VALUE_CREATE_VARCHAR
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_destroy {
        __DUCKDB_V2_VALUE_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_bigint {
        __DUCKDB_V2_VALUE_GET_BIGINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_blob {
        __DUCKDB_V2_VALUE_GET_BLOB
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_bool {
        __DUCKDB_V2_VALUE_GET_BOOL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_child {
        __DUCKDB_V2_VALUE_GET_CHILD
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_child_count {
        __DUCKDB_V2_VALUE_GET_CHILD_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_date {
        __DUCKDB_V2_VALUE_GET_DATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_decimal {
        __DUCKDB_V2_VALUE_GET_DECIMAL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_double {
        __DUCKDB_V2_VALUE_GET_DOUBLE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_float {
        __DUCKDB_V2_VALUE_GET_FLOAT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_hugeint {
        __DUCKDB_V2_VALUE_GET_HUGEINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_int {
        __DUCKDB_V2_VALUE_GET_INT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_interval {
        __DUCKDB_V2_VALUE_GET_INTERVAL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_logical_type {
        __DUCKDB_V2_VALUE_GET_LOGICAL_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_smallint {
        __DUCKDB_V2_VALUE_GET_SMALLINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_time {
        __DUCKDB_V2_VALUE_GET_TIME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_time_ns {
        __DUCKDB_V2_VALUE_GET_TIME_NS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_time_tz {
        __DUCKDB_V2_VALUE_GET_TIME_TZ
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_timestamp {
        __DUCKDB_V2_VALUE_GET_TIMESTAMP
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_timestamp_ms {
        __DUCKDB_V2_VALUE_GET_TIMESTAMP_MS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_timestamp_ns {
        __DUCKDB_V2_VALUE_GET_TIMESTAMP_NS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_timestamp_sec {
        __DUCKDB_V2_VALUE_GET_TIMESTAMP_SEC
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_timestamp_tz {
        __DUCKDB_V2_VALUE_GET_TIMESTAMP_TZ
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_timestamp_tz_ns {
        __DUCKDB_V2_VALUE_GET_TIMESTAMP_TZ_NS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_tinyint {
        __DUCKDB_V2_VALUE_GET_TINYINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_type {
        __DUCKDB_V2_VALUE_GET_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_ubigint {
        __DUCKDB_V2_VALUE_GET_UBIGINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_uhugeint {
        __DUCKDB_V2_VALUE_GET_UHUGEINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_uint {
        __DUCKDB_V2_VALUE_GET_UINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_usmallint {
        __DUCKDB_V2_VALUE_GET_USMALLINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_utinyint {
        __DUCKDB_V2_VALUE_GET_UTINYINT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_uuid {
        __DUCKDB_V2_VALUE_GET_UUID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_get_varchar {
        __DUCKDB_V2_VALUE_GET_VARCHAR
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_is_null {
        __DUCKDB_V2_VALUE_IS_NULL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_value_to_string {
        __DUCKDB_V2_VALUE_TO_STRING
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_constant_set_valid {
        __DUCKDB_V2_VECTOR_CONSTANT_SET_VALID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_flat_get_validity_mutable {
        __DUCKDB_V2_VECTOR_FLAT_GET_VALIDITY_MUTABLE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_flatten {
        __DUCKDB_V2_VECTOR_FLATTEN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_arena {
        __DUCKDB_V2_VECTOR_GET_ARENA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_child {
        __DUCKDB_V2_VECTOR_GET_CHILD
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_child_count {
        __DUCKDB_V2_VECTOR_GET_CHILD_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_data_mutable {
        __DUCKDB_V2_VECTOR_GET_DATA_MUTABLE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_logical_type {
        __DUCKDB_V2_VECTOR_GET_LOGICAL_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_size {
        __DUCKDB_V2_VECTOR_GET_SIZE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_value {
        __DUCKDB_V2_VECTOR_GET_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_vector_type {
        __DUCKDB_V2_VECTOR_GET_VECTOR_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_get_view {
        __DUCKDB_V2_VECTOR_GET_VIEW
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_make_constant {
        __DUCKDB_V2_VECTOR_MAKE_CONSTANT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_make_sequence {
        __DUCKDB_V2_VECTOR_MAKE_SEQUENCE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_reference {
        __DUCKDB_V2_VECTOR_REFERENCE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_set_null {
        __DUCKDB_V2_VECTOR_SET_NULL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_set_size {
        __DUCKDB_V2_VECTOR_SET_SIZE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_set_value {
        __DUCKDB_V2_VECTOR_SET_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_scalar_function {
        __DUCKDB_V2_CONNECTION_REGISTER_SCALAR_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_context_log {
        __DUCKDB_V2_CONTEXT_LOG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_scalar_function {
        __DUCKDB_V2_EXTENSION_REGISTER_SCALAR_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_signature_add_parameter {
        __DUCKDB_V2_FUNCTION_SIGNATURE_ADD_PARAMETER
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_signature_set_return_type {
        __DUCKDB_V2_FUNCTION_SIGNATURE_SET_RETURN_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_create {
        __DUCKDB_V2_SCALAR_FUNCTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_destroy {
        __DUCKDB_V2_SCALAR_FUNCTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_exec_get_arg {
        __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ARG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_exec_get_arg_count {
        __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ARG_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_exec_get_bind_data {
        __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_exec_get_init_data {
        __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_INIT_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_exec_get_result {
        __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_RESULT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_exec_get_row_count {
        __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_ROW_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_exec_get_user_data {
        __DUCKDB_V2_SCALAR_FUNCTION_EXEC_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_get_signature {
        __DUCKDB_V2_SCALAR_FUNCTION_GET_SIGNATURE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_init_get_bind_data {
        __DUCKDB_V2_SCALAR_FUNCTION_INIT_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_init_get_user_data {
        __DUCKDB_V2_SCALAR_FUNCTION_INIT_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_init_set_init_data {
        __DUCKDB_V2_SCALAR_FUNCTION_INIT_SET_INIT_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_set_bind_callback {
        __DUCKDB_V2_SCALAR_FUNCTION_SET_BIND_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_set_exec_callback {
        __DUCKDB_V2_SCALAR_FUNCTION_SET_EXEC_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_set_init_callback {
        __DUCKDB_V2_SCALAR_FUNCTION_SET_INIT_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_set_name {
        __DUCKDB_V2_SCALAR_FUNCTION_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_set_user_data {
        __DUCKDB_V2_SCALAR_FUNCTION_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_bind_set_return_type {
        __DUCKDB_V2_AGGREGATE_FUNCTION_BIND_SET_RETURN_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_combine_get_bind_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_combine_get_sources {
        __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_SOURCES
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_combine_get_state_count {
        __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_STATE_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_combine_get_targets {
        __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_TARGETS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_combine_get_user_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_COMBINE_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_create {
        __DUCKDB_V2_AGGREGATE_FUNCTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_destroy {
        __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_destroy_get_bind_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_destroy_get_state_count {
        __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_STATE_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_destroy_get_states {
        __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_STATES
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_destroy_get_user_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_DESTROY_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_finalize_get_bind_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_finalize_get_result {
        __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_RESULT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_finalize_get_result_offset {
        __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_RESULT_OFFSET
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_finalize_get_state_count {
        __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_STATE_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_finalize_get_states {
        __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_STATES
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_finalize_get_user_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_FINALIZE_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_get_signature {
        __DUCKDB_V2_AGGREGATE_FUNCTION_GET_SIGNATURE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_init_get_bind_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_init_get_state_count {
        __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_STATE_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_init_get_states {
        __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_STATES
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_init_get_user_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_INIT_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_bind_callback {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_BIND_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_combine_callback {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_COMBINE_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_destroy_callback {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_DESTROY_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_finalize_callback {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_FINALIZE_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_init_callback {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_INIT_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_name {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_size_callback {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_SIZE_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_update_callback {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_UPDATE_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_user_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_size_get_bind_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_size_get_user_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_size_set_state_size {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SIZE_SET_STATE_SIZE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_update_get_arg {
        __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ARG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_update_get_arg_count {
        __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ARG_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_update_get_bind_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_update_get_row_count {
        __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_ROW_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_update_get_states {
        __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_STATES
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_update_get_user_data {
        __DUCKDB_V2_AGGREGATE_FUNCTION_UPDATE_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_aggregate_function {
        __DUCKDB_V2_CONNECTION_REGISTER_AGGREGATE_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_aggregate_function {
        __DUCKDB_V2_EXTENSION_REGISTER_AGGREGATE_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_set_property {
        __DUCKDB_V2_AGGREGATE_FUNCTION_SET_PROPERTY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_set_property {
        __DUCKDB_V2_SCALAR_FUNCTION_SET_PROPERTY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_table_function {
        __DUCKDB_V2_CONNECTION_REGISTER_TABLE_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_table_function {
        __DUCKDB_V2_EXTENSION_REGISTER_TABLE_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_bind_add_result_column {
        __DUCKDB_V2_TABLE_FUNCTION_BIND_ADD_RESULT_COLUMN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_bind_set_cardinality {
        __DUCKDB_V2_TABLE_FUNCTION_BIND_SET_CARDINALITY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_create {
        __DUCKDB_V2_TABLE_FUNCTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_destroy {
        __DUCKDB_V2_TABLE_FUNCTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_exec_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_exec_get_global_state {
        __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_exec_get_local_state {
        __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_LOCAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_exec_get_output_chunk {
        __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_OUTPUT_CHUNK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_exec_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_get_signature {
        __DUCKDB_V2_TABLE_FUNCTION_GET_SIGNATURE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_global_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_global_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_global_set_global_state {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_SET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_global_set_max_threads {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_SET_MAX_THREADS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_local_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_local_get_global_state {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_local_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_local_set_local_state {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_SET_LOCAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_progress_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_progress_get_global_state {
        __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_progress_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_progress_set_progress {
        __DUCKDB_V2_TABLE_FUNCTION_PROGRESS_SET_PROGRESS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_bind_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_BIND_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_exec_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_EXEC_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_init_global_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_INIT_GLOBAL_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_init_local_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_INIT_LOCAL_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_name {
        __DUCKDB_V2_TABLE_FUNCTION_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_progress_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_PROGRESS_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_create {
        __DUCKDB_V2_CAST_FUNCTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_destroy {
        __DUCKDB_V2_CAST_FUNCTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_exec_get_input {
        __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_INPUT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_exec_get_mode {
        __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_MODE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_exec_get_output {
        __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_OUTPUT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_exec_get_row_count {
        __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_ROW_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_exec_get_user_data {
        __DUCKDB_V2_CAST_FUNCTION_EXEC_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_set_exec_callback {
        __DUCKDB_V2_CAST_FUNCTION_SET_EXEC_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_set_implicit_cast_cost {
        __DUCKDB_V2_CAST_FUNCTION_SET_IMPLICIT_CAST_COST
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_set_source_type {
        __DUCKDB_V2_CAST_FUNCTION_SET_SOURCE_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_set_target_type {
        __DUCKDB_V2_CAST_FUNCTION_SET_TARGET_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_cast_function_set_user_data {
        __DUCKDB_V2_CAST_FUNCTION_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_data_collection_clear {
        __DUCKDB_V2_COLUMN_DATA_COLLECTION_CLEAR
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_cast_function {
        __DUCKDB_V2_CONNECTION_REGISTER_CAST_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_custom_type {
        __DUCKDB_V2_CONNECTION_REGISTER_CUSTOM_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_replacement_scan {
        __DUCKDB_V2_CONNECTION_REGISTER_REPLACEMENT_SCAN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_context_get_file_system {
        __DUCKDB_V2_CONTEXT_GET_FILE_SYSTEM
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_type_create {
        __DUCKDB_V2_CUSTOM_TYPE_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_type_destroy {
        __DUCKDB_V2_CUSTOM_TYPE_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_type_set_base_type {
        __DUCKDB_V2_CUSTOM_TYPE_SET_BASE_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_type_set_name {
        __DUCKDB_V2_CUSTOM_TYPE_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_cast_function {
        __DUCKDB_V2_EXTENSION_REGISTER_CAST_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_custom_type {
        __DUCKDB_V2_EXTENSION_REGISTER_CUSTOM_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_replacement_scan {
        __DUCKDB_V2_EXTENSION_REGISTER_REPLACEMENT_SCAN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_close {
        __DUCKDB_V2_FILE_CLOSE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_destroy {
        __DUCKDB_V2_FILE_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_open_options_create {
        __DUCKDB_V2_FILE_OPEN_OPTIONS_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_open_options_destroy {
        __DUCKDB_V2_FILE_OPEN_OPTIONS_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_open_options_set_flag {
        __DUCKDB_V2_FILE_OPEN_OPTIONS_SET_FLAG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_open_options_set_value {
        __DUCKDB_V2_FILE_OPEN_OPTIONS_SET_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_read {
        __DUCKDB_V2_FILE_READ
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_read_at {
        __DUCKDB_V2_FILE_READ_AT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_seek {
        __DUCKDB_V2_FILE_SEEK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_size {
        __DUCKDB_V2_FILE_SIZE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_sync {
        __DUCKDB_V2_FILE_SYNC
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_system_open {
        __DUCKDB_V2_FILE_SYSTEM_OPEN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_tell {
        __DUCKDB_V2_FILE_TELL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_write {
        __DUCKDB_V2_FILE_WRITE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_write_at {
        __DUCKDB_V2_FILE_WRITE_AT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_register_replacement_scan {
        __DUCKDB_V2_INSTANCE_REGISTER_REPLACEMENT_SCAN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_qname_create {
        __DUCKDB_V2_QNAME_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_qname_destroy {
        __DUCKDB_V2_QNAME_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_qname_equals {
        __DUCKDB_V2_QNAME_EQUALS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_qname_get_part {
        __DUCKDB_V2_QNAME_GET_PART
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_qname_get_part_count {
        __DUCKDB_V2_QNAME_GET_PART_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_qname_hash {
        __DUCKDB_V2_QNAME_HASH
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_qname_parse {
        __DUCKDB_V2_QNAME_PARSE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_qname_render {
        __DUCKDB_V2_QNAME_RENDER
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_add_argument {
        __DUCKDB_V2_REPLACEMENT_SCAN_ADD_ARGUMENT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_add_named_argument {
        __DUCKDB_V2_REPLACEMENT_SCAN_ADD_NAMED_ARGUMENT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_create {
        __DUCKDB_V2_REPLACEMENT_SCAN_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_destroy {
        __DUCKDB_V2_REPLACEMENT_SCAN_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_get_name {
        __DUCKDB_V2_REPLACEMENT_SCAN_GET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_get_user_data {
        __DUCKDB_V2_REPLACEMENT_SCAN_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_set_alias {
        __DUCKDB_V2_REPLACEMENT_SCAN_SET_ALIAS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_set_callback {
        __DUCKDB_V2_REPLACEMENT_SCAN_SET_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_set_collection {
        __DUCKDB_V2_REPLACEMENT_SCAN_SET_COLLECTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_set_function_name {
        __DUCKDB_V2_REPLACEMENT_SCAN_SET_FUNCTION_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_set_subquery {
        __DUCKDB_V2_REPLACEMENT_SCAN_SET_SUBQUERY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_replacement_scan_set_user_data {
        __DUCKDB_V2_REPLACEMENT_SCAN_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_exporter_append {
        __DUCKDB_V2_ARROW_EXPORTER_APPEND
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_exporter_create {
        __DUCKDB_V2_ARROW_EXPORTER_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_exporter_destroy {
        __DUCKDB_V2_ARROW_EXPORTER_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_exporter_get_schema {
        __DUCKDB_V2_ARROW_EXPORTER_GET_SCHEMA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_exporter_next_array {
        __DUCKDB_V2_ARROW_EXPORTER_NEXT_ARRAY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_importer_append {
        __DUCKDB_V2_ARROW_IMPORTER_APPEND
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_importer_create {
        __DUCKDB_V2_ARROW_IMPORTER_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_importer_destroy {
        __DUCKDB_V2_ARROW_IMPORTER_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_importer_get_schema {
        __DUCKDB_V2_ARROW_IMPORTER_GET_SCHEMA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_importer_next_chunk {
        __DUCKDB_V2_ARROW_IMPORTER_NEXT_CHUNK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_description_destroy {
        __DUCKDB_V2_COLUMN_DESCRIPTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_description_get_name {
        __DUCKDB_V2_COLUMN_DESCRIPTION_GET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_description_get_type {
        __DUCKDB_V2_COLUMN_DESCRIPTION_GET_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_description_has_default {
        __DUCKDB_V2_COLUMN_DESCRIPTION_HAS_DEFAULT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_column_description_has_generated {
        __DUCKDB_V2_COLUMN_DESCRIPTION_HAS_GENERATED
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_describe_table {
        __DUCKDB_V2_CONNECTION_DESCRIBE_TABLE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_copy_function {
        __DUCKDB_V2_CONNECTION_REGISTER_COPY_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_get_column_count {
        __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_get_column_name {
        __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_get_column_type {
        __DUCKDB_V2_COPY_FROM_BIND_GET_COLUMN_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_get_file_path {
        __DUCKDB_V2_COPY_FROM_BIND_GET_FILE_PATH
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_get_option_count {
        __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_get_option_name {
        __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_get_option_value {
        __DUCKDB_V2_COPY_FROM_BIND_GET_OPTION_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_get_user_data {
        __DUCKDB_V2_COPY_FROM_BIND_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_set_bind_data {
        __DUCKDB_V2_COPY_FROM_BIND_SET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_bind_set_cardinality {
        __DUCKDB_V2_COPY_FROM_BIND_SET_CARDINALITY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_exec_get_bind_data {
        __DUCKDB_V2_COPY_FROM_EXEC_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_exec_get_global_state {
        __DUCKDB_V2_COPY_FROM_EXEC_GET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_exec_get_local_state {
        __DUCKDB_V2_COPY_FROM_EXEC_GET_LOCAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_exec_get_output_chunk {
        __DUCKDB_V2_COPY_FROM_EXEC_GET_OUTPUT_CHUNK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_exec_get_user_data {
        __DUCKDB_V2_COPY_FROM_EXEC_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_init_global_get_bind_data {
        __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_init_global_get_user_data {
        __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_init_global_set_global_state {
        __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_SET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_init_global_set_max_threads {
        __DUCKDB_V2_COPY_FROM_INIT_GLOBAL_SET_MAX_THREADS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_init_local_get_bind_data {
        __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_init_local_get_global_state {
        __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_init_local_get_user_data {
        __DUCKDB_V2_COPY_FROM_INIT_LOCAL_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_init_local_set_local_state {
        __DUCKDB_V2_COPY_FROM_INIT_LOCAL_SET_LOCAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_progress_get_bind_data {
        __DUCKDB_V2_COPY_FROM_PROGRESS_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_progress_get_global_state {
        __DUCKDB_V2_COPY_FROM_PROGRESS_GET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_progress_get_user_data {
        __DUCKDB_V2_COPY_FROM_PROGRESS_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_progress_set_progress {
        __DUCKDB_V2_COPY_FROM_PROGRESS_SET_PROGRESS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_set_bind_callback {
        __DUCKDB_V2_COPY_FROM_SET_BIND_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_set_exec_callback {
        __DUCKDB_V2_COPY_FROM_SET_EXEC_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_set_init_global_callback {
        __DUCKDB_V2_COPY_FROM_SET_INIT_GLOBAL_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_set_init_local_callback {
        __DUCKDB_V2_COPY_FROM_SET_INIT_LOCAL_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_from_set_progress_callback {
        __DUCKDB_V2_COPY_FROM_SET_PROGRESS_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_function_create {
        __DUCKDB_V2_COPY_FUNCTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_function_destroy {
        __DUCKDB_V2_COPY_FUNCTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_function_set_name {
        __DUCKDB_V2_COPY_FUNCTION_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_function_set_user_data {
        __DUCKDB_V2_COPY_FUNCTION_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_batch_get_bind_data {
        __DUCKDB_V2_COPY_TO_BATCH_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_batch_get_init_data {
        __DUCKDB_V2_COPY_TO_BATCH_GET_INIT_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_batch_get_user_data {
        __DUCKDB_V2_COPY_TO_BATCH_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_batch_set_batch_data {
        __DUCKDB_V2_COPY_TO_BATCH_SET_BATCH_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_batch_size_get_bind_data {
        __DUCKDB_V2_COPY_TO_BATCH_SIZE_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_batch_size_get_user_data {
        __DUCKDB_V2_COPY_TO_BATCH_SIZE_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_batch_size_set_target {
        __DUCKDB_V2_COPY_TO_BATCH_SIZE_SET_TARGET
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_batch_take_input {
        __DUCKDB_V2_COPY_TO_BATCH_TAKE_INPUT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_get_column_count {
        __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_get_column_name {
        __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_get_column_type {
        __DUCKDB_V2_COPY_TO_BIND_GET_COLUMN_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_get_file_path {
        __DUCKDB_V2_COPY_TO_BIND_GET_FILE_PATH
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_get_option_count {
        __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_get_option_name {
        __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_get_option_value {
        __DUCKDB_V2_COPY_TO_BIND_GET_OPTION_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_get_user_data {
        __DUCKDB_V2_COPY_TO_BIND_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_bind_set_bind_data {
        __DUCKDB_V2_COPY_TO_BIND_SET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_finalize_get_bind_data {
        __DUCKDB_V2_COPY_TO_FINALIZE_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_finalize_get_init_data {
        __DUCKDB_V2_COPY_TO_FINALIZE_GET_INIT_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_finalize_get_user_data {
        __DUCKDB_V2_COPY_TO_FINALIZE_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_flush_get_batch_data {
        __DUCKDB_V2_COPY_TO_FLUSH_GET_BATCH_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_flush_get_bind_data {
        __DUCKDB_V2_COPY_TO_FLUSH_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_flush_get_init_data {
        __DUCKDB_V2_COPY_TO_FLUSH_GET_INIT_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_flush_get_user_data {
        __DUCKDB_V2_COPY_TO_FLUSH_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_init_get_bind_data {
        __DUCKDB_V2_COPY_TO_INIT_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_init_get_file_path {
        __DUCKDB_V2_COPY_TO_INIT_GET_FILE_PATH
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_init_get_user_data {
        __DUCKDB_V2_COPY_TO_INIT_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_init_set_init_data {
        __DUCKDB_V2_COPY_TO_INIT_SET_INIT_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_set_batch_callback {
        __DUCKDB_V2_COPY_TO_SET_BATCH_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_set_batch_size_callback {
        __DUCKDB_V2_COPY_TO_SET_BATCH_SIZE_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_set_bind_callback {
        __DUCKDB_V2_COPY_TO_SET_BIND_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_set_finalize_callback {
        __DUCKDB_V2_COPY_TO_SET_FINALIZE_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_set_flush_callback {
        __DUCKDB_V2_COPY_TO_SET_FLUSH_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_set_init_callback {
        __DUCKDB_V2_COPY_TO_SET_INIT_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_cast_get_mode {
        __DUCKDB_V2_EXPRESSION_CAST_GET_MODE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_column_ref_get_index {
        __DUCKDB_V2_EXPRESSION_COLUMN_REF_GET_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_constant_get_value {
        __DUCKDB_V2_EXPRESSION_CONSTANT_GET_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_function_get_name {
        __DUCKDB_V2_EXPRESSION_FUNCTION_GET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_function_get_qname {
        __DUCKDB_V2_EXPRESSION_FUNCTION_GET_QNAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_get_child {
        __DUCKDB_V2_EXPRESSION_GET_CHILD
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_get_child_count {
        __DUCKDB_V2_EXPRESSION_GET_CHILD_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_get_return_type {
        __DUCKDB_V2_EXPRESSION_GET_RETURN_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_expression_get_type {
        __DUCKDB_V2_EXPRESSION_GET_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_copy_function {
        __DUCKDB_V2_EXTENSION_REGISTER_COPY_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_identifier_render_quoted {
        __DUCKDB_V2_IDENTIFIER_RENDER_QUOTED
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_prepared_statement_create {
        __DUCKDB_V2_PREPARED_STATEMENT_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_prepared_statement_destroy {
        __DUCKDB_V2_PREPARED_STATEMENT_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_prepared_statement_execute {
        __DUCKDB_V2_PREPARED_STATEMENT_EXECUTE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_prepared_statement_reuses_plan {
        __DUCKDB_V2_PREPARED_STATEMENT_REUSES_PLAN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_description_destroy {
        __DUCKDB_V2_TABLE_DESCRIPTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_description_get_column {
        __DUCKDB_V2_TABLE_DESCRIPTION_GET_COLUMN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_description_get_column_count {
        __DUCKDB_V2_TABLE_DESCRIPTION_GET_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_description_get_qname {
        __DUCKDB_V2_TABLE_DESCRIPTION_GET_QNAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_description_is_readonly {
        __DUCKDB_V2_TABLE_DESCRIPTION_IS_READONLY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_exec_get_column_count {
        __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_exec_get_column_index {
        __DUCKDB_V2_TABLE_FUNCTION_EXEC_GET_COLUMN_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_filter_pushdown_accept {
        __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_ACCEPT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_filter_pushdown_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_filter_pushdown_get_column_count
    {
        __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_filter_pushdown_get_column_index
    {
        __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_COLUMN_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_filter_pushdown_get_filter {
        __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_FILTER
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_filter_pushdown_get_filter_count
    {
        __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_FILTER_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_filter_pushdown_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_FILTER_PUSHDOWN_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_global_get_column_count {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_global_get_column_index {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_GLOBAL_GET_COLUMN_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_local_get_column_count {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_init_local_get_column_index {
        __DUCKDB_V2_TABLE_FUNCTION_INIT_LOCAL_GET_COLUMN_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_filter_pushdown_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_FILTER_PUSHDOWN_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_projection_pushdown {
        __DUCKDB_V2_TABLE_FUNCTION_SET_PROJECTION_PUSHDOWN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_sql_statement_get_parameter_count {
        __DUCKDB_V2_SQL_STATEMENT_GET_PARAMETER_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_sql_statement_get_parameter_name {
        __DUCKDB_V2_SQL_STATEMENT_GET_PARAMETER_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_sql_statement_get_text {
        __DUCKDB_V2_SQL_STATEMENT_GET_TEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_sql_statement_get_type {
        __DUCKDB_V2_SQL_STATEMENT_GET_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_token_iterator_destroy {
        __DUCKDB_V2_TOKEN_ITERATOR_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_token_iterator_ends_unterminated {
        __DUCKDB_V2_TOKEN_ITERATOR_ENDS_UNTERMINATED
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_token_iterator_next {
        __DUCKDB_V2_TOKEN_ITERATOR_NEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_tokenize_sql {
        __DUCKDB_V2_TOKENIZE_SQL
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_attach_options_create {
        __DUCKDB_V2_ATTACH_OPTIONS_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_attach_options_destroy {
        __DUCKDB_V2_ATTACH_OPTIONS_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_attach_options_set {
        __DUCKDB_V2_ATTACH_OPTIONS_SET
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_set_default {
        __DUCKDB_V2_INSTANCE_SET_DEFAULT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_partition_data_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_partition_data_get_global_state
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_partition_data_get_local_state {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_LOCAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_table_function_partition_data_get_partition_column_count
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_PARTITION_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_table_function_partition_data_get_partition_column_index
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_PARTITION_COLUMN_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_partition_data_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_table_function_partition_data_requires_batch_index
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_REQUIRES_BATCH_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_table_function_partition_data_requires_partition_columns
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_REQUIRES_PARTITION_COLUMNS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_partition_data_set_batch_index {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_SET_BATCH_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_table_function_partition_data_set_partition_value
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITION_DATA_SET_PARTITION_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_partitioning_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_table_function_partitioning_get_partition_column_count
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_PARTITION_COLUMN_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_table_function_partitioning_get_partition_column_index
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_PARTITION_COLUMN_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_partitioning_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_partitioning_set_partition_info
    {
        __DUCKDB_V2_TABLE_FUNCTION_PARTITIONING_SET_PARTITION_INFO
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_partition_data_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_PARTITION_DATA_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_partitioning_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_PARTITIONING_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_validate_utf8 {
        __DUCKDB_V2_VALIDATE_UTF8
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_multi_file_function {
        __DUCKDB_V2_CONNECTION_REGISTER_MULTI_FILE_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_set_statistics_callback {
        __DUCKDB_V2_COPY_TO_SET_STATISTICS_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_statistics_get_bind_data {
        __DUCKDB_V2_COPY_TO_STATISTICS_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_statistics_get_init_data {
        __DUCKDB_V2_COPY_TO_STATISTICS_GET_INIT_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_statistics_get_user_data {
        __DUCKDB_V2_COPY_TO_STATISTICS_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_statistics_set_file_size {
        __DUCKDB_V2_COPY_TO_STATISTICS_SET_FILE_SIZE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_to_statistics_set_row_count {
        __DUCKDB_V2_COPY_TO_STATISTICS_SET_ROW_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_data_chunk_get_capacity {
        __DUCKDB_V2_DATA_CHUNK_GET_CAPACITY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_multi_file_function {
        __DUCKDB_V2_EXTENSION_REGISTER_MULTI_FILE_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_multi_file_function_create {
        __DUCKDB_V2_MULTI_FILE_FUNCTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_multi_file_function_destroy {
        __DUCKDB_V2_MULTI_FILE_FUNCTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_multi_file_function_set_file_extension {
        __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_FILE_EXTENSION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_multi_file_function_set_name {
        __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_multi_file_function_set_reader_type {
        __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_READER_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_multi_file_function_set_single_file_function {
        __DUCKDB_V2_MULTI_FILE_FUNCTION_SET_SINGLE_FILE_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_claim_batch_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_claim_batch_get_global_state {
        __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_GLOBAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_claim_batch_get_local_state {
        __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_LOCAL_STATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_claim_batch_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_claim_batch_set_claimed {
        __DUCKDB_V2_TABLE_FUNCTION_CLAIM_BATCH_SET_CLAIMED
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_claim_batch_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_CLAIM_BATCH_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_bind_get_arg_count {
        __DUCKDB_V2_FUNCTION_BIND_GET_ARG_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_bind_get_arg_index {
        __DUCKDB_V2_FUNCTION_BIND_GET_ARG_INDEX
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_bind_get_arg_name {
        __DUCKDB_V2_FUNCTION_BIND_GET_ARG_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_bind_get_arg_type {
        __DUCKDB_V2_FUNCTION_BIND_GET_ARG_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_bind_get_arg_value {
        __DUCKDB_V2_FUNCTION_BIND_GET_ARG_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_bind_get_user_data {
        __DUCKDB_V2_FUNCTION_BIND_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_bind_set_bind_data {
        __DUCKDB_V2_FUNCTION_BIND_SET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_bind_set_order_preservation {
        __DUCKDB_V2_TABLE_FUNCTION_BIND_SET_ORDER_PRESERVATION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_destroy {
        __DUCKDB_V2_ARROW_RESULT_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_drain {
        __DUCKDB_V2_ARROW_RESULT_DRAIN
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_fetch_array {
        __DUCKDB_V2_ARROW_RESULT_FETCH_ARRAY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_get_result_type {
        __DUCKDB_V2_ARROW_RESULT_GET_RESULT_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_get_schema {
        __DUCKDB_V2_ARROW_RESULT_GET_SCHEMA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_get_statement_type {
        __DUCKDB_V2_ARROW_RESULT_GET_STATEMENT_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_step {
        __DUCKDB_V2_ARROW_RESULT_STEP
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_to_arrow_c_stream {
        __DUCKDB_V2_ARROW_RESULT_TO_ARROW_C_STREAM
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_arrow_result_wait {
        __DUCKDB_V2_ARROW_RESULT_WAIT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_prepared_statement_execute_arrow {
        __DUCKDB_V2_PREPARED_STATEMENT_EXECUTE_ARROW
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_statement_execute_arrow {
        __DUCKDB_V2_STATEMENT_EXECUTE_ARROW
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_resolve_types_set_return_type {
        __DUCKDB_V2_SCALAR_FUNCTION_RESOLVE_TYPES_SET_RETURN_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_set_resolve_types_callback {
        __DUCKDB_V2_SCALAR_FUNCTION_SET_RESOLVE_TYPES_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_get_bind_info_get_bind_data {
        __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_GET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_get_bind_info_get_user_data {
        __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api)
        .duckdb_v2_table_function_get_bind_info_set_column_identifier
    {
        __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_SET_COLUMN_IDENTIFIER
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_get_bind_info_set_option {
        __DUCKDB_V2_TABLE_FUNCTION_GET_BIND_INFO_SET_OPTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_set_get_bind_info_callback {
        __DUCKDB_V2_TABLE_FUNCTION_SET_GET_BIND_INFO_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_get_factory {
        __DUCKDB_V2_CONNECTION_GET_FACTORY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_context_get_factory {
        __DUCKDB_V2_CONTEXT_GET_FACTORY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_get_factory {
        __DUCKDB_V2_INSTANCE_GET_FACTORY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_bind_set_bind_data {
        __DUCKDB_V2_SCALAR_FUNCTION_BIND_SET_BIND_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_config_get_option_value {
        __DUCKDB_V2_CONFIG_GET_OPTION_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_config_set_option_text {
        __DUCKDB_V2_CONFIG_SET_OPTION_TEXT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_config_set_option_value {
        __DUCKDB_V2_CONFIG_SET_OPTION_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_get_config {
        __DUCKDB_V2_CONNECTION_GET_CONFIG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_get_file_system {
        __DUCKDB_V2_CONNECTION_GET_FILE_SYSTEM
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_log {
        __DUCKDB_V2_CONNECTION_LOG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_context_get_config {
        __DUCKDB_V2_CONTEXT_GET_CONFIG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_get_config {
        __DUCKDB_V2_INSTANCE_GET_CONFIG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_get_file_system {
        __DUCKDB_V2_INSTANCE_GET_FILE_SYSTEM
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_log {
        __DUCKDB_V2_INSTANCE_LOG
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_option_get_default_scope {
        __DUCKDB_V2_OPTION_GET_DEFAULT_SCOPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_option_supports_scope {
        __DUCKDB_V2_OPTION_SUPPORTS_SCOPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_aggregate_function_get_docs {
        __DUCKDB_V2_AGGREGATE_FUNCTION_GET_DOCS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_pragma_function {
        __DUCKDB_V2_CONNECTION_REGISTER_PRAGMA_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_pragma_function {
        __DUCKDB_V2_EXTENSION_REGISTER_PRAGMA_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_factory_create_common_type {
        __DUCKDB_V2_FACTORY_CREATE_COMMON_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_docs_add_category {
        __DUCKDB_V2_FUNCTION_DOCS_ADD_CATEGORY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_docs_add_example {
        __DUCKDB_V2_FUNCTION_DOCS_ADD_EXAMPLE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_function_docs_set_description {
        __DUCKDB_V2_FUNCTION_DOCS_SET_DESCRIPTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_create {
        __DUCKDB_V2_PRAGMA_FUNCTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_destroy {
        __DUCKDB_V2_PRAGMA_FUNCTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_get_docs {
        __DUCKDB_V2_PRAGMA_FUNCTION_GET_DOCS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_get_signature {
        __DUCKDB_V2_PRAGMA_FUNCTION_GET_SIGNATURE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_query_set_query {
        __DUCKDB_V2_PRAGMA_FUNCTION_QUERY_SET_QUERY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_set_exec_callback {
        __DUCKDB_V2_PRAGMA_FUNCTION_SET_EXEC_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_set_name {
        __DUCKDB_V2_PRAGMA_FUNCTION_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_set_query_callback {
        __DUCKDB_V2_PRAGMA_FUNCTION_SET_QUERY_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_pragma_function_set_user_data {
        __DUCKDB_V2_PRAGMA_FUNCTION_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_scalar_function_get_docs {
        __DUCKDB_V2_SCALAR_FUNCTION_GET_DOCS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_table_function_get_docs {
        __DUCKDB_V2_TABLE_FUNCTION_GET_DOCS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_register_custom_option {
        __DUCKDB_V2_CONNECTION_REGISTER_CUSTOM_OPTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_create {
        __DUCKDB_V2_CUSTOM_OPTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_destroy {
        __DUCKDB_V2_CUSTOM_OPTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_set_default_scope {
        __DUCKDB_V2_CUSTOM_OPTION_SET_DEFAULT_SCOPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_set_default_value {
        __DUCKDB_V2_CUSTOM_OPTION_SET_DEFAULT_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_set_description {
        __DUCKDB_V2_CUSTOM_OPTION_SET_DESCRIPTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_set_name {
        __DUCKDB_V2_CUSTOM_OPTION_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_set_supports_scope {
        __DUCKDB_V2_CUSTOM_OPTION_SET_SUPPORTS_SCOPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_set_type {
        __DUCKDB_V2_CUSTOM_OPTION_SET_TYPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_set_update_callback {
        __DUCKDB_V2_CUSTOM_OPTION_SET_UPDATE_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_set_user_data {
        __DUCKDB_V2_CUSTOM_OPTION_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_update_get_scope {
        __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_SCOPE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_update_get_user_data {
        __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_update_get_value {
        __DUCKDB_V2_CUSTOM_OPTION_UPDATE_GET_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_update_is_reset {
        __DUCKDB_V2_CUSTOM_OPTION_UPDATE_IS_RESET
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_custom_option_update_set_value {
        __DUCKDB_V2_CUSTOM_OPTION_UPDATE_SET_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_custom_option {
        __DUCKDB_V2_EXTENSION_REGISTER_CUSTOM_OPTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_log_sink {
        __DUCKDB_V2_EXTENSION_REGISTER_LOG_SINK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_extension_register_macro_function {
        __DUCKDB_V2_EXTENSION_REGISTER_MACRO_FUNCTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_system_path_exists {
        __DUCKDB_V2_FILE_SYSTEM_PATH_EXISTS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_system_path_expand {
        __DUCKDB_V2_FILE_SYSTEM_PATH_EXPAND
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_system_path_is_remote {
        __DUCKDB_V2_FILE_SYSTEM_PATH_IS_REMOTE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_instance_register_log_sink {
        __DUCKDB_V2_INSTANCE_REGISTER_LOG_SINK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_create {
        __DUCKDB_V2_LOG_SINK_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_destroy {
        __DUCKDB_V2_LOG_SINK_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_set_flush_callback {
        __DUCKDB_V2_LOG_SINK_SET_FLUSH_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_set_name {
        __DUCKDB_V2_LOG_SINK_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_set_user_data {
        __DUCKDB_V2_LOG_SINK_SET_USER_DATA
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_set_write_callback {
        __DUCKDB_V2_LOG_SINK_SET_WRITE_CALLBACK
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_write_info_get_connection_id {
        __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_CONNECTION_ID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_write_info_get_query_id {
        __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_QUERY_ID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_write_info_get_thread_id {
        __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_THREAD_ID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_log_sink_write_info_get_transaction_id {
        __DUCKDB_V2_LOG_SINK_WRITE_INFO_GET_TRANSACTION_ID
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_macro_function_create {
        __DUCKDB_V2_MACRO_FUNCTION_CREATE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_macro_function_destroy {
        __DUCKDB_V2_MACRO_FUNCTION_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_macro_function_get_docs {
        __DUCKDB_V2_MACRO_FUNCTION_GET_DOCS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_macro_function_get_signature {
        __DUCKDB_V2_MACRO_FUNCTION_GET_SIGNATURE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_macro_function_set_body {
        __DUCKDB_V2_MACRO_FUNCTION_SET_BODY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_macro_function_set_name {
        __DUCKDB_V2_MACRO_FUNCTION_SET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_vector_cast {
        __DUCKDB_V2_VECTOR_CAST
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_enable_profiling {
        __DUCKDB_V2_CONNECTION_ENABLE_PROFILING
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_connection_get_query_metrics {
        __DUCKDB_V2_CONNECTION_GET_QUERY_METRICS
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_copy_function_set_file_extension {
        __DUCKDB_V2_COPY_FUNCTION_SET_FILE_EXTENSION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_data_chunk_clear {
        __DUCKDB_V2_DATA_CHUNK_CLEAR
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_system_path_glob {
        __DUCKDB_V2_FILE_SYSTEM_PATH_GLOB
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_system_path_move {
        __DUCKDB_V2_FILE_SYSTEM_PATH_MOVE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_file_system_path_remove {
        __DUCKDB_V2_FILE_SYSTEM_PATH_REMOVE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_destroy {
        __DUCKDB_V2_QUERY_METRICS_DESTROY
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_get_root {
        __DUCKDB_V2_QUERY_METRICS_GET_ROOT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_node_get_child {
        __DUCKDB_V2_QUERY_METRICS_NODE_GET_CHILD
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_node_get_child_count {
        __DUCKDB_V2_QUERY_METRICS_NODE_GET_CHILD_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_node_get_metric {
        __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_node_get_metric_count {
        __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_COUNT
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_node_get_metric_name {
        __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_node_get_metric_value {
        __DUCKDB_V2_QUERY_METRICS_NODE_GET_METRIC_VALUE
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_query_metrics_node_get_name {
        __DUCKDB_V2_QUERY_METRICS_NODE_GET_NAME
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    if let Some(fun) = (*p_api).duckdb_v2_statement_add_collection {
        __DUCKDB_V2_STATEMENT_ADD_COLLECTION
            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
    }
    Ok(true)
}