diff --git a/.github/scripts/build-research-recipes.sh b/.github/scripts/build-research-recipes.sh
index 73b6ebf0c..4962b327c 100755
--- a/.github/scripts/build-research-recipes.sh
+++ b/.github/scripts/build-research-recipes.sh
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # Compile owners concurrently. Keep each owner's recipes and target writes serial.
 set -euo pipefail
-[[ $# == 2 || $# == 5 ]] || exit 2
+[[ $# == 2 || $# == 6 ]] || exit 2
 product=${1:?product required}
 phase=${2:?recipe measurement phase required}
 [[ $phase == after-cache-lookup || $phase == warm-local || $phase == dependency-warm-serial || $phase == dependency-warm-parallel ]] || exit 2
@@ -58,7 +58,7 @@ if [[ $# == 2 ]]; then
   trap 'cancel_scheduler 143' TERM
   # Background execution lets Bash handle a signal sent only to its own PID.
   # The Ruby supervisor receives that signal and reaps its owned process groups.
-  ruby -rjson - "$root/.github/scripts/build-research-recipes.sh" "$product" "$phase" "$inputs" "$cpus" "$memory_mib" <<'RUBY' &
+  ruby -rjson -rtmpdir -rfileutils - "$root/.github/scripts/build-research-recipes.sh" "$product" "$phase" "$inputs" "$cpus" "$memory_mib" <<'RUBY' &
 script, product, phase, inputs, cpus, memory = ARGV
 cpus, memory = Integer(cpus), Integer(memory)
 requested = ENV.fetch('MONDAY_RESEARCH_BUILD_CONCURRENCY', '2')
@@ -71,6 +71,8 @@ owners = JSON.parse(File.read(inputs)).fetch('recipes').map { |recipe| recipe.fe
 concurrency = [Integer(requested), owners.length, budget, [memory / 4096, 1].max].min
 jobs = budget / concurrency
 pending, active = owners.dup, {}
+lease_root = Dir.mktmpdir('research-recipe-jobs.', ENV.fetch('RUNNER_TEMP'))
+leases = {}
 failed_groups = []
 status = 0
 interrupted = nil
@@ -85,13 +87,25 @@ begin
   until pending.empty? && active.empty?
     while !interrupted && active.length < concurrency && !pending.empty?
       owner = pending.shift
-      pid = Process.spawn('bash', script, product, phase, owner, jobs.to_s, concurrency.to_s, pgroup: true)
+      lease = File.join(lease_root, owner.delete_suffix('/Cargo.toml').tr('/', '-') + '.jobs')
+      File.write(lease, jobs.to_s)
+      pid = Process.spawn('bash', script, product, phase, owner, jobs.to_s, concurrency.to_s, lease, pgroup: true)
       active[pid] = owner
+      leases[pid] = lease
     end
     if interrupted
       status = 128 + Signal.list.fetch(interrupted)
       break
     end
+    # Increase only the final owner's next recipe. No pending or sibling owner
+    # can claim these CPUs. An in-flight Cargo/cc jobserver keeps its old budget.
+    if pending.empty? && active.length == 1
+      lease = leases.fetch(active.keys.first)
+      unless File.read(lease) == budget.to_s
+        File.write(lease + '.next', budget.to_s)
+        File.rename(lease + '.next', lease)
+      end
+    end
     completed = Process.wait2(-1, Process::WNOHANG)
     unless completed
       IO.select([wake_read])
@@ -114,6 +128,7 @@ ensure
   sleep 0.2 unless groups.empty?
   groups.each { |pid| Process.kill('KILL', -pid) rescue Errno::ESRCH }
   groups.each { |pid| Process.wait(pid) rescue Errno::ECHILD }
+  FileUtils.remove_entry(lease_root)
   wake_read.close
   wake_write.close
 end
@@ -147,31 +162,42 @@ RUBY
   [[ $(sha256sum "$inputs" | awk '{print $1}') == "$inputs_sha" ]]
   exit "$status"
 fi
-manifest=$3 cargo_jobs=$4 concurrency=$5
+manifest=$3 cargo_jobs=$4 concurrency=$5 lease=$6
 [[ $cargo_jobs =~ ^[1-9][0-9]*$ && $concurrency =~ ^[12]$ ]]
 (( cargo_jobs * concurrency <= cpus ))
 jq -e --arg manifest "$manifest" 'any(.[]; .manifest==$manifest)' <<<"$recipes" >/dev/null
 owner=${manifest%/Cargo.toml}
 timings="$work/$phase-${owner//\//--}.timings.jsonl"
 while IFS= read -r recipe; do
+  # The supervisor grants a larger budget only after all other owners exit.
+  # Read once per recipe; never change Cargo's budget during compilation.
+  next_jobs=$(cat "$lease")
+  [[ $next_jobs =~ ^[1-9][0-9]*$ ]]
+  (( next_jobs >= cargo_jobs && next_jobs <= cpus ))
+  cargo_jobs=$next_jobs
   package=$(jq -r .package <<<"$recipe")
-  args=(build --manifest-path "$manifest" --target x86_64-unknown-linux-gnu --release --locked --jobs "$cargo_jobs" -p "$package")
-  features=$(jq -r .features <<<"$recipe")
-  [[ -z $features ]] || args+=(--features "$features")
-  while IFS= read -r binary; do args+=(--bin "$binary"); done < <(jq -r '.binaries[]' <<<"$recipe")
   start=$(date +%s)
   recipe_target=$(bash "$root/.github/scripts/research-cache-layout.sh" target-dir "$(jq -r .manifest <<<"$recipe")")
-  CARGO_TARGET_DIR="$recipe_target" cargo "${args[@]}" --message-format json-render-diagnostics >"$work/$phase-$package.jsonl"
+  # Cargo emits dirty reasons to stderr; keep stdout as compiler JSON only.
+  # Logging belongs to orchestration, not the dependency compilation identity.
+  fingerprint_log="$work/$phase-$package.fingerprint.log"
+  status=0
+  { CARGO_LOG=cargo::core::compiler::fingerprint=info CARGO_TERM_COLOR=never \
+      CARGO_TARGET_DIR="$recipe_target" bash "$root/.github/scripts/compile-research-recipe.sh" "$recipe" "$cargo_jobs" \
+      >"$work/$phase-$package.jsonl"; } 2>&1 | tee "$fingerprint_log" >&2 || status=$?
+  (( status == 0 )) || exit "$status"
   jq -es 'any(.[]; .reason=="compiler-artifact") and any(.[]; .reason=="build-finished" and .success==true)' \
     "$work/$phase-$package.jsonl" >/dev/null
   seconds=$(( $(date +%s) - start ))
   jq -s -c --arg cache_match "$cache_match" --arg phase "$phase" --arg source "$source_sha" --arg inputs "$inputs_sha" \
     --argjson requested_concurrency "${MONDAY_RESEARCH_BUILD_CONCURRENCY:-2}" \
     --argjson cargo_jobs "$cargo_jobs" --argjson concurrency "$concurrency" \
+    --rawfile diagnostics "$fingerprint_log" \
     --argjson runner "$runner_context" --arg recipe_target "$recipe_target" --argjson recipe "$recipe" --argjson seconds "$seconds" \
     '{phase:$phase,runner:$runner,recipe_target:$recipe_target,cache_exact_match:$cache_match,source_sha:$source,compilation_inputs_sha256:$inputs,recipe:$recipe,seconds:$seconds,
       scheduler:{requested_owner_concurrency:$requested_concurrency,owner_concurrency:$concurrency,cargo_jobs:$cargo_jobs},
       compiler_artifacts:([.[]|select(.reason=="compiler-artifact")]|length),
+      native_fingerprint_diagnostics:[$diagnostics|split("\n")[]|select(contains("fingerprint") and contains("libduckdb"))],
       native_artifacts:[.[]|select(.reason=="compiler-artifact" and (.package_id|contains("libduckdb-sys")))|{package_id,target:.target.name,fresh}],
       fresh:([.[]|select(.reason=="compiler-artifact" and .fresh==true)]|length),
       rebuilt:([.[]|select(.reason=="compiler-artifact" and .fresh==false)]|length)}' \
diff --git a/.github/scripts/capture-research-build-inputs.sh b/.github/scripts/capture-research-build-inputs.sh
index ffcc600f4..3e8696be4 100755
--- a/.github/scripts/capture-research-build-inputs.sh
+++ b/.github/scripts/capture-research-build-inputs.sh
@@ -4,6 +4,7 @@
 set -euo pipefail
 output=${1:?output JSON required}
 root=$(cd "$(dirname "$0")/../.." && pwd)
+bash "$root/.github/scripts/prepare-research-native-source.sh"
 work=$(mktemp -d)
 trap 'rm -rf "$work"' EXIT
 test "$(uname -s)" = Linux
@@ -29,9 +30,19 @@ for variable in CC CXX AR LD CFLAGS CXXFLAGS LDFLAGS RUSTC_BOOTSTRAP CARGO_BUILD
   LIBRARY_PATH LD_LIBRARY_PATH CPATH C_INCLUDE_PATH CPLUS_INCLUDE_PATH \
   PKG_CONFIG PKG_CONFIG_PATH PKG_CONFIG_LIBDIR PKG_CONFIG_SYSROOT_DIR \
   OPENSSL_DIR OPENSSL_LIB_DIR OPENSSL_INCLUDE_DIR OPENSSL_STATIC \
-  BINDGEN_EXTRA_CLANG_ARGS PROTOC PROTOC_INCLUDE CMAKE_TOOLCHAIN_FILE; do
+  BINDGEN_EXTRA_CLANG_ARGS PROTOC PROTOC_INCLUDE CMAKE_TOOLCHAIN_FILE \
+  DUCKDB_STATIC DUCKDB_LIB_DIR DUCKDB_INCLUDE_DIR DUCKDB_DOWNLOAD_LIB \
+  RANLIB ARFLAGS CXXSTDLIB CRATE_CC_NO_DEFAULTS CC_SHELL_ESCAPED_FLAGS \
+  CMAKE_GENERATOR CMAKE_MAKE_PROGRAM CMAKE_PREFIX_PATH; do
   printf '%s=%s\n' "$variable" "${!variable-}" >>"$work/native"
 done
+# cc-rs also accepts target-specific compiler and flag overrides.
+while IFS= read -r variable; do
+  printf '%s=%s\n' "$variable" "$(printenv "$variable")" >>"$work/native"
+done < <(env | awk -F= '$1 ~ /^(CC|CXX|AR|RANLIB|CFLAGS|CXXFLAGS|ARFLAGS|CXXSTDLIB)_(x86_64|x86-64)/ || $1 ~ /^(HOST|TARGET)_(CC|CXX|AR|RANLIB|CFLAGS|CXXFLAGS|ARFLAGS|CXXSTDLIB)$/ {print $1}' | LC_ALL=C sort)
+for command in cc c++ ar ld ranlib; do
+  sha256sum "$(command -v "$command")" >>"$work/native"
+done
 for command in clang cmake mold pkg-config protoc zstd zstdmt unzstd; do "$command" --version >>"$work/native"; done
 # Bind relevant Cargo overrides without capturing registry or service secrets.
 for variable in RUSTC RUSTDOC RUSTC_WORKSPACE_WRAPPER CARGO_INCREMENTAL; do
@@ -62,17 +73,9 @@ while IFS= read -r manifest; do
 done < <(jq -r '.workspaces[].manifest' "$root/rust_hft/workspaces.json")
 recipes=$(bash "$root/.github/scripts/research-release-products.sh" recipes "${2:-all}" | jq -s .)
 locks=$("$root/.github/scripts/research-workspace-locks.sh" "$root/rust_hft")
-cat "$root/.github/scripts/build-research-release.sh" \
-  "$root/.github/scripts/build-research-recipes.sh" \
-  "$root/.github/scripts/research-cache-layout.sh" \
-  "$root/.github/scripts/research-release-products.sh" \
-  "$root/.github/scripts/research-release-products.json" \
-  "$root/.github/scripts/research-release-source-sha.sh" \
-  "$root/.github/scripts/research-workspace-locks.sh" \
-  "$root/.github/scripts/verify-research-runtime-abi.sh" \
-  "$root/.github/scripts/verify-research-runner-binaries.sh" >"$work/recipe"
-# Bind the fixed CI parser implementation alongside the build recipe.
-find "$root/.github/scripts/vendor/tomlrb/lib" -type f -name '*.rb' -print0 | LC_ALL=C sort -z | xargs -0 cat >>"$work/recipe"
+# The selected recipes below bind catalog contents to exact provenance.
+# Packaging-only catalog edits must not invalidate compatible dependencies.
+bash "$root/.github/scripts/research-cache-layout.sh" recipe-inputs >"$work/recipe"
 jq -S -n --arg compiler "$(sha256sum "$work/compiler" | awk '{print $1}')" \
   --arg native "$(sha256sum "$work/native" | awk '{print $1}')" \
   --arg flags "$(sha256sum "$work/flags" | awk '{print $1}')" \
@@ -86,6 +89,8 @@ jq -S -n --arg compiler "$(sha256sum "$work/compiler" | awk '{print $1}')" \
 if [[ -n ${GITHUB_OUTPUT:-} ]]; then printf 'cache_sha256=%s\n' "$(sha256sum "$output" | awk '{print $1}')" >>"$GITHUB_OUTPUT"; fi
 # This separate restore identity does not replace the complete v3 provenance.
 bash "$root/.github/scripts/research-cache-layout.sh" compatibility-inputs "$output" >"$work/dependency-cache-inputs.json"
+# Retain a small, public native identity summary in the producer log.
+jq -c '.native_dependencies.closures[] | {owner,duckdb:[.packages[] | select(.name=="libduckdb-sys") | {name,version,checksum,features}]}' "$work/dependency-cache-inputs.json"
 if [[ -n ${GITHUB_OUTPUT:-} ]]; then
   printf 'dependency_cache_sha256=%s\n' "$(sha256sum "$work/dependency-cache-inputs.json" | awk '{print $1}')" >>"$GITHUB_OUTPUT"
 fi
diff --git a/.github/scripts/ci-owner-cache.sh b/.github/scripts/ci-owner-cache.sh
index fb1b1d6e8..accf1dd7b 100644
--- a/.github/scripts/ci-owner-cache.sh
+++ b/.github/scripts/ci-owner-cache.sh
@@ -130,14 +130,18 @@ begin
     "rust_hft/workspaces.json", ".github/scripts/ci-owner-cache.sh",
     ".github/scripts/test-rust-workspaces.sh", ".github/scripts/check-collector-test-presence.sh",
     ".github/workflows/ci.yml", ".github/scripts/select-rust-ci-scope.sh",
-    "deployment/aliyun/test-polymarket-raw-ops-control-plane.sh"]
+    "deployment/aliyun/test-polymarket-raw-ops-control-plane.sh", ".github/scripts/prepare-research-native-source.sh"]
   parser = Dir.glob("#{root}/.github/scripts/vendor/tomlrb/lib/**/*.rb").sort.to_h do |path|
     [path.delete_prefix("#{root}/"), file_digest(path)]
   end
   abort 'missing Cargo TOML parser' if parser.empty?
-  compatibility = {schema: 'monday.ci-owner-cache-compat.v2', compiler: compiler, target: host,
+  native_root = "#{root}/rust_hft/native/libduckdb-sys"
+  native_files = Dir.glob("#{native_root}/**/*", File::FNM_DOTMATCH).select { |path| File.file?(path) }.sort
+  abort 'native patch contains symlinks' if native_files.any? { |path| File.symlink?(path) }
+  native_patch = native_files.to_h { |path| [path.delete_prefix(native_root + '/'), file_digest(path)] }
+  compatibility = {native_patch: native_patch, native_preparation: file_digest("#{root}/.github/scripts/prepare-research-native-source.sh"), schema: 'monday.ci-owner-cache-compat.v3', compiler: compiler, target: host,
     profile: 'dev-test', native: native, flags: flags, configs: configs, profiles: profiles, owners: admitted, parser: parser}
-  prefix = "rust_hft-ci-owner-v2-#{digest(compatibility)}-"
+  prefix = "rust_hft-ci-owner-v3-#{digest(compatibility)}-"
   exact = {coverage: coverage, manifests: manifests, configs: configs,
     helpers: helpers.to_h { |path| [path, file_digest("#{root}/#{path}")] }}
   puts "compat_prefix=#{prefix}"
@@ -188,7 +192,8 @@ if [[ $mode == native-input ]]; then
       CPATH C_INCLUDE_PATH CPLUS_INCLUDE_PATH PKG_CONFIG PKG_CONFIG_PATH \
       PKG_CONFIG_LIBDIR PKG_CONFIG_SYSROOT_DIR BINDGEN_EXTRA_CLANG_ARGS \
       OPENSSL_DIR OPENSSL_LIB_DIR OPENSSL_INCLUDE_DIR OPENSSL_STATIC \
-      PROTOC PROTOC_INCLUDE CMAKE_TOOLCHAIN_FILE; do
+      PROTOC PROTOC_INCLUDE CMAKE_TOOLCHAIN_FILE \
+      DUCKDB_STATIC DUCKDB_LIB_DIR DUCKDB_INCLUDE_DIR DUCKDB_DOWNLOAD_LIB; do
       printf '%s=%s\n' "$variable" "${!variable-}"
     done
   } >"$work/native"
@@ -205,11 +210,11 @@ while IFS= read -r manifest; do
     --locked --all-features --format-version 1 >>"$work/metadata.jsonl"
 done <<<"$manifests"
 jq -se --arg root "$root/" \
-  '[.[].packages[]|select(.source == null or (.manifest_path|startswith($root)))|.name,.targets[].name]|unique|
+  '[.[].packages[]|select((.source == null or (.manifest_path|startswith($root))) and (.manifest_path != ($root+"rust_hft/native/libduckdb-sys/Cargo.toml")))|.name,.targets[].name]|unique|
    if length>0 then . else error("no repository-local compilation packages") end' \
   "$work/metadata.jsonl" >"$work/local-names.json"
 jq -s --arg root "$root/" \
-  '[.[].packages[]|select(.source != null and (.manifest_path|startswith($root)|not))|.name,.targets[].name]|unique' \
+  '[.[].packages[]|select((.source != null and (.manifest_path|startswith($root)|not)) or (.name == "libduckdb-sys" and .manifest_path == ($root+"rust_hft/native/libduckdb-sys/Cargo.toml")))|.name,.targets[].name]|unique' \
   "$work/metadata.jsonl" >"$work/external-names.json"
 ruby -rjson -rfileutils - "$root" "$work/local-names.json" "$work/external-names.json" <<'RUBY'
 root, names_file, external_file = ARGV
diff --git a/.github/scripts/compile-research-recipe.sh b/.github/scripts/compile-research-recipe.sh
new file mode 100644
index 000000000..c4e881703
--- /dev/null
+++ b/.github/scripts/compile-research-recipe.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Stable dependency compilation contract. Packaging and scheduling live outside it.
+set -euo pipefail
+recipe=${1:?recipe JSON required}
+jobs=${2:?Cargo jobs required}
+[[ $jobs =~ ^[1-9][0-9]*$ ]]
+manifest=$(jq -er .manifest <<<"$recipe")
+package=$(jq -er .package <<<"$recipe")
+features=$(jq -er .features <<<"$recipe")
+args=(build --manifest-path "$manifest" --target x86_64-unknown-linux-gnu --release --locked --jobs "$jobs" -p "$package")
+[[ -z $features ]] || args+=(--features "$features")
+while IFS= read -r binary; do args+=(--bin "$binary"); done < <(jq -er '.binaries[]' <<<"$recipe")
+cargo "${args[@]}" --message-format json-render-diagnostics
diff --git a/.github/scripts/prepare-research-native-source.sh b/.github/scripts/prepare-research-native-source.sh
new file mode 100755
index 000000000..ac9f02e02
--- /dev/null
+++ b/.github/scripts/prepare-research-native-source.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Cache lookup binds all native bytes. Normalize only a fresh CI source tree.
+set -euo pipefail
+root=$(cd "$(dirname "$0")/../.." && pwd)
+[[ ${GITHUB_ACTIONS:-false} == true ]] || exit 0
+cd "$root"
+source=rust_hft/native/libduckdb-sys
+[[ -z $(git -c safe.directory="$root" status --porcelain --untracked-files=all -- "$source") ]] || {
+  echo 'native source must be committed and clean in CI' >&2; exit 1;
+}
+# Never hide an input change from an existing local or restored Cargo target.
+for target in rust_hft/target rust_hft/research-core/target rust_hft/data-pipelines/target; do
+  [[ ! -e $target ]] || { echo "native timestamp preparation must precede target creation: $target" >&2; exit 1; }
+done
+ruby -ropen3 - "$source" <<'RUBY'
+files, status = Open3.capture2('git', '-c', "safe.directory=#{Dir.pwd}", 'ls-files', '-z', '--', ARGV.fetch(0))
+abort 'native source inventory failed' unless status.success? && !files.empty?
+files.split("\0").each do |file|
+  abort 'native source must contain regular files' unless File.file?(file) && !File.symlink?(file)
+  File.utime(Time.at(946684800), Time.at(946684800), file)
+end
+RUBY
diff --git a/.github/scripts/research-cache-layout.sh b/.github/scripts/research-cache-layout.sh
index d0cc44229..4a47f7452 100644
--- a/.github/scripts/research-cache-layout.sh
+++ b/.github/scripts/research-cache-layout.sh
@@ -38,6 +38,16 @@ validate_recipes() {
       (.binaries|type == "array" and length>0 and all(.[];name)))' "$1" >/dev/null
 }
 case ${1:?command required} in
+  recipe-inputs)
+    # Bind compiler orchestration and cleanup, independently of product selection.
+    # Exact selected recipes remain in compilation inputs and artifact admission.
+    for script in build-research-release.sh build-research-recipes.sh capture-research-build-inputs.sh research-cache-layout.sh \
+      research-release-products.sh research-release-source-sha.sh research-workspace-locks.sh \
+      verify-research-runtime-abi.sh verify-research-runner-binaries.sh research-native-dependency-inputs.rb compile-research-recipe.sh prepare-research-native-source.sh; do
+      cat "$root/.github/scripts/$script"
+    done
+    find "$root/.github/scripts/vendor/tomlrb/lib" -type f -name '*.rb' -print0 | LC_ALL=C sort -z | xargs -0 cat
+    ;;
   compatibility-inputs)
     # Keep local dependency choices in provenance and Cargo's exact cache suffix.
     # The restore prefix still binds every admitted compiler, native and profile input.
@@ -124,9 +134,12 @@ rescue StandardError => error
   exit 1
 end
 RUBY
-    jq -Se --slurpfile owner_profiles "$work/owner-profiles.json" '
-      {schema:"monday.dependency-cache-compat.v3",target,profile,compiler,native,flags,
-        builder_image,recipe,owner_profiles:$owner_profiles[0]}' "$work/validated.json"
+    ruby "$root/.github/scripts/research-native-dependency-inputs.rb" "$root" "$work/cache-recipes.json" >"$work/native-dependencies.json"
+    dependency_recipe=$(cat "$root/.github/scripts/compile-research-recipe.sh" "$root/.github/scripts/research-cache-layout.sh" \
+      "$root/.github/scripts/research-native-dependency-inputs.rb" "$root/.github/scripts/prepare-research-native-source.sh" | sha256sum | awk '{print $1}')
+    jq -Se --arg dependency_recipe "$dependency_recipe" --slurpfile native_dependencies "$work/native-dependencies.json" --slurpfile owner_profiles "$work/owner-profiles.json" '
+      {schema:"monday.dependency-cache-compat.v4",target,profile,compiler,native,flags,
+        builder_image,dependency_recipe:$dependency_recipe,owner_profiles:$owner_profiles[0],native_dependencies:$native_dependencies[0]}' "$work/validated.json"
     ;;
   manifest-inputs)
     # Include local path/patch/default-feature manifests beyond recipe roots.
@@ -198,8 +211,10 @@ RUBY
       fi
       cargo metadata --manifest-path "$root/rust_hft/$manifest" --locked --format-version 1 "${metadata_args[@]}" >>"$work/local.jsonl"
     done <<<"$recipes"
-    jq -s --arg root "$root/" '[.[].packages[]|select(.source == null or (.manifest_path|startswith($root)))|.name, .targets[].name]|unique|if length>0 then . else error("no local compilation packages") end' "$work/local.jsonl" >"$work/names.json"
-    jq -s --arg root "$root/" '[.[].packages[]|select(.source != null and (.manifest_path|startswith($root)|not))|.name, .targets[].name]|unique' "$work/local.jsonl" >"$work/external.json"
+    # The reviewed native patch is a dependency. Its complete source enters the
+    # native compatibility identity; application path packages remain excluded.
+    jq -s --arg root "$root/" '[.[].packages[]|select((.source == null or (.manifest_path|startswith($root))) and (.manifest_path != ($root+"rust_hft/native/libduckdb-sys/Cargo.toml")))|.name, .targets[].name]|unique|if length>0 then . else error("no local compilation packages") end' "$work/local.jsonl" >"$work/names.json"
+    jq -s --arg root "$root/" '[.[].packages[]|select((.source != null and (.manifest_path|startswith($root)|not)) or (.name == "libduckdb-sys" and .manifest_path == ($root+"rust_hft/native/libduckdb-sys/Cargo.toml")))|.name, .targets[].name]|unique' "$work/local.jsonl" >"$work/external.json"
     ruby -rjson -rfileutils - "$root" "$work/names.json" "$work/external.json" "$work/cache-recipes.json" <<'RUBY'
 root, names_file, external_file, recipes_file = ARGV
 names = JSON.parse(File.read(names_file)).flat_map { |n| [n, n.tr('-', '_'), "lib#{n.tr('-', '_')}"] }.uniq
diff --git a/.github/scripts/research-native-dependency-inputs.rb b/.github/scripts/research-native-dependency-inputs.rb
new file mode 100644
index 000000000..81e5cda30
--- /dev/null
+++ b/.github/scripts/research-native-dependency-inputs.rb
@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# Cargo resolves native features. This identity excludes application source and packaging scripts.
+require 'json'
+require 'open3'
+require 'digest'
+
+root, recipes_file = ARGV
+abort 'root and recipes required' unless root && recipes_file
+$LOAD_PATH.unshift("#{root}/.github/scripts/vendor/tomlrb/lib")
+require 'tomlrb'
+# Cargo metadata resolves the workspace. Reuse only identical command arguments.
+# Keep feature selections separate; never union them across recipe invocations.
+resolutions = {}
+records = JSON.parse(File.read(recipes_file)).flat_map do |recipe|
+  manifest = recipe.fetch('manifest')
+  args = ['cargo', 'metadata', '--manifest-path', "#{root}/rust_hft/#{manifest}",
+          '--locked', '--format-version', '1', '--filter-platform', 'x86_64-unknown-linux-gnu']
+  lock = Tomlrb.load_file("#{root}/rust_hft/#{File.dirname(manifest)}/Cargo.lock").fetch('package')
+  features = recipe.fetch('features')
+  unless features.empty?
+    args += ['--features', features.split(',').map { |feature| "#{recipe.fetch('package')}/#{feature}" }.join(',')]
+  end
+  metadata = resolutions[args] ||= begin
+    output, status = Open3.capture2(*args, chdir: "#{root}/rust_hft")
+    abort "native dependency resolution failed: #{manifest}" unless status.success?
+    JSON.parse(output)
+  end
+  packages = metadata.fetch('packages').to_h { |package| [package.fetch('id'), package] }
+  nodes = metadata.fetch('resolve').fetch('nodes').to_h { |node| [node.fetch('id'), node] }
+  native_roots = packages.values.select { |package| package.fetch('name') == 'libduckdb-sys' }
+  native_roots.map do |native|
+    pending = [native.fetch('id')]
+    visited = {}
+    until pending.empty?
+      id = pending.shift
+      next if visited.key?(id)
+      package = packages.fetch(id)
+      node = nodes.fetch(id)
+      source = package['source']
+      checksum = nil
+      if source&.start_with?('registry+')
+        entry = lock.find { |item| item['name'] == package['name'] && item['version'] == package['version'] && item['source'] == source }
+        checksum = entry&.fetch('checksum', nil)
+        abort 'native registry source has no checksum' unless checksum&.match?(/\A[0-9a-f]{64}\z/)
+      end
+      # Registry versions and git revisions are immutable Cargo identities.
+      # Local overrides also bind source bytes, including the native build script.
+      local = nil
+      unless source
+        directory = File.dirname(package.fetch('manifest_path'))
+        files = Dir.glob("#{directory}/**/*", File::FNM_DOTMATCH).select { |file| File.file?(file) }
+        abort 'native local dependency contains a symlink' if files.any? { |file| File.symlink?(file) }
+        local = files.sort.to_h { |file| [file.delete_prefix(directory + '/'), Digest::SHA256.file(file).hexdigest] }
+      end
+      visited[id] = { 'name' => package.fetch('name'), 'version' => package.fetch('version'),
+                      'source' => source, 'checksum' => checksum,
+                      'features' => node.fetch('features').sort, 'local' => local }
+      pending.concat(node.fetch('dependencies'))
+    end
+    { 'owner' => manifest, 'packages' => visited.values.sort_by { |package| JSON.generate(package) } }
+  end
+end
+puts JSON.generate({ 'schema' => 'monday.native-dependencies.v1', 'closures' => records.uniq.sort_by { |record| JSON.generate(record) } })
diff --git a/.github/scripts/research-release-products.json b/.github/scripts/research-release-products.json
index 7e09900ed..3f5588a32 100644
--- a/.github/scripts/research-release-products.json
+++ b/.github/scripts/research-release-products.json
@@ -8,8 +8,7 @@
       "binance-market-tape-slicer",
       "binance-replay-parquet-materializer",
       "clickhouse-analytics-materializer",
-      "monday-cex-prepare",
-      "monday-offline-baseline"
+      "monday-cex-prepare"
     ],
     "prediction-runner": [
       "monday-prediction-research",
@@ -39,14 +38,6 @@
         "alpha-harness"
       ]
     },
-    {
-      "manifest": "research-core/Cargo.toml",
-      "package": "alpha-harness",
-      "features": "offline-diagnostic",
-      "binaries": [
-        "monday-offline-baseline"
-      ]
-    },
     {
       "manifest": "research-core/Cargo.toml",
       "package": "hft-cex-research-worker",
diff --git a/.github/scripts/select-rust-ci-scope.sh b/.github/scripts/select-rust-ci-scope.sh
index 142e05578..222800062 100755
--- a/.github/scripts/select-rust-ci-scope.sh
+++ b/.github/scripts/select-rust-ci-scope.sh
@@ -660,7 +660,7 @@ for path in "${paths[@]}"; do
       select_job ploy/workflow-lint
       continue
       ;;
-    .github/scripts/research-release-products.sh|.github/scripts/research-release-products.json|.github/scripts/test-research-release-products.sh|.github/scripts/research-release-bundle.rb|.github/scripts/research-release-source-sha.sh|.github/scripts/test-research-checkout-ownership.sh|.github/scripts/verify-research-runtime-abi.sh|.github/scripts/test-research-runtime-abi.sh|.github/scripts/research-cache-layout.sh|.github/scripts/test-research-cache-layout.sh|.github/scripts/build-research-release.sh|.github/scripts/build-research-recipes.sh|.github/scripts/capture-research-build-inputs.sh|.github/scripts/research-image-smoke.sh|.github/scripts/verify-research-product-image.sh|.github/scripts/test-research-product-image.sh|.github/scripts/verify-research-controller-image.sh|.github/scripts/test-research-controller-image.sh|.github/scripts/download-research-release.sh|.github/scripts/test-download-research-release.sh)
+    rust_hft/native/libduckdb-sys/*|.github/scripts/prepare-research-native-source.sh|.github/scripts/test-duckdb-build-modes.sh|.github/scripts/research-release-products.sh|.github/scripts/research-release-products.json|.github/scripts/test-research-release-products.sh|.github/scripts/research-release-bundle.rb|.github/scripts/research-release-source-sha.sh|.github/scripts/test-research-checkout-ownership.sh|.github/scripts/verify-research-runtime-abi.sh|.github/scripts/test-research-runtime-abi.sh|.github/scripts/research-cache-layout.sh|.github/scripts/test-research-cache-layout.sh|.github/scripts/build-research-release.sh|.github/scripts/build-research-recipes.sh|.github/scripts/compile-research-recipe.sh|.github/scripts/research-native-dependency-inputs.rb|.github/scripts/capture-research-build-inputs.sh|.github/scripts/research-image-smoke.sh|.github/scripts/verify-research-product-image.sh|.github/scripts/test-research-product-image.sh|.github/scripts/verify-research-controller-image.sh|.github/scripts/test-research-controller-image.sh|.github/scripts/download-research-release.sh|.github/scripts/test-download-research-release.sh)
       select_research_image_jobs
       select_job ci/ci-contracts
       select_job ploy/workflow-lint
diff --git a/.github/scripts/test-ci-owner-cache.sh b/.github/scripts/test-ci-owner-cache.sh
index 35e601690..d2a797a85 100644
--- a/.github/scripts/test-ci-owner-cache.sh
+++ b/.github/scripts/test-ci-owner-cache.sh
@@ -52,6 +52,8 @@ fi
 native_before=$(PATH="$work/native-bin:$PATH" bash "$root/.github/scripts/ci-owner-cache.sh" native-input)
 native_after=$(PATH="$work/native-bin:$PATH" CXXFLAGS=-DFIXTURE_NATIVE_INPUT_CHANGED bash "$root/.github/scripts/ci-owner-cache.sh" native-input)
 [[ $native_before != "$native_after" ]]
+native_duckdb=$(PATH="$work/native-bin:$PATH" DUCKDB_LIB_DIR=/fixture/other-duckdb bash "$root/.github/scripts/ci-owner-cache.sh" native-input)
+[[ $native_before != "$native_duckdb" ]]
 # A narrow first save must not become an exact hit for wider coverage.
 plan=$(jq -cn '{handoff:"false",json:"false",ondo:"false",collector:"false",control:"false",focused:"true",loop:"false",owning_packages:",,",focused_packages:",hft-live,",loop_packages:""}')
 coverage() { MONDAY_CI_CACHE_PLAN="$1" bash "$root/.github/scripts/ci-owner-cache.sh" coverage-input; }
@@ -98,7 +100,7 @@ if [[ $1 == metadata ]]; then
       {id:"hft-data",name:"hft-data",manifest_path:($root+"/rust_hft/data-pipelines/core/Cargo.toml"),targets:[{name:"data"}]}] +
      if $extra then [{id:"vendor",name:"hidden-local",manifest_path:($root+"/vendor/hidden/Cargo.toml"),targets:[{name:"hidden_local"}]},
        {id:"outside",name:"external-local",source:null,manifest_path:"/external/path/Cargo.toml",targets:[{name:"external_local"}]},
-       {id:"registry",name:"libduckdb-sys",source:"registry+https://github.com/rust-lang/crates.io-index",manifest_path:"/registry/libduckdb/Cargo.toml",targets:[{name:"libduckdb_sys"}]},
+       {id:"registry",name:"libduckdb-sys",source:null,manifest_path:($root+"/rust_hft/native/libduckdb-sys/Cargo.toml"),targets:[{name:"libduckdb_sys"}]},
        {id:"encoding",name:"data-encoding",source:"registry+https://github.com/rust-lang/crates.io-index",manifest_path:"/registry/data-encoding/Cargo.toml",targets:[{name:"data_encoding"}]}] else [] end)}'
 else
   [[ ${FAIL_CARGO:-0} != 1 ]] || exit 19
@@ -312,6 +314,11 @@ Dir.mktmpdir('ci-cache-coverage') do |fixture|
   _, _, status = Open3.capture3('git', '-C', fixture, 'add', '.')
   abort 'fixture git add failed' unless status.success?
   baseline = cache_inputs.call(fixture)
+  native_file = "#{fixture}/rust_hft/native/libduckdb-sys/build.rs"
+  FileUtils.mkdir_p(File.dirname(native_file))
+  File.write(native_file, 'changed native source fixture')
+  abort 'native source bytes crossed compatibility boundary' if cache_inputs.call(fixture)['compat_prefix'] == baseline['compat_prefix']
+  FileUtils.rm_f(native_file)
   wide = cache_inputs.call(fixture, plan.merge('focused_packages' => 'hft-live,hft-cex-research-worker'))
   abort 'coverage changed compatible restore prefix' unless wide['compat_prefix'] == baseline['compat_prefix']
   abort 'coverage changed no exact key' if wide['key'] == baseline['key']
diff --git a/.github/scripts/test-duckdb-build-modes.sh b/.github/scripts/test-duckdb-build-modes.sh
new file mode 100755
index 000000000..a1a326d5e
--- /dev/null
+++ b/.github/scripts/test-duckdb-build-modes.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# Run the patched build script in each mode. Bundled native linking remains in
+# the image producer and offline smoke, with their admitted compiler and ABI.
+set -euo pipefail
+root=$(cd "$(dirname "$0")/../.." && pwd)
+work=$(mktemp -d)
+trap 'rm -rf "$work"' EXIT
+mkdir -p "$work/src"
+cat >"$work/Cargo.toml" <<TOML
+[package]
+name = "monday-native-validation"
+version = "0.0.0"
+edition = "2024"
+[workspace]
+[features]
+bundled = ["libduckdb-sys/bundled"]
+download = ["libduckdb-sys/download"]
+[dependencies]
+libduckdb-sys = { path = "$root/rust_hft/native/libduckdb-sys" }
+TOML
+printf 'fn main() {}\n' >"$work/src/main.rs"
+# Reuse the admitted dependency versions. Do not resolve a new latest baseline.
+cp "$root/rust_hft/research-core/Cargo.lock" "$work/Cargo.lock"
+export CARGO_TARGET_DIR="${MONDAY_NATIVE_TEST_TARGET:-$work/target}"
+cargo check --manifest-path "$work/Cargo.toml"
+if DUCKDB_DOWNLOAD_LIB=1 cargo check --manifest-path "$work/Cargo.toml" >"$work/rejected" 2>&1; then
+  echo 'download without its feature was accepted' >&2; exit 1
+fi
+grep -q 'requires the libduckdb-sys/download feature' "$work/rejected"
+# Explicit feature must compile the original downloader. Keep network fetching
+# disabled here; the download itself is a separately reported integration check.
+cargo check --manifest-path "$work/Cargo.toml" --features download
+cargo tree --manifest-path "$work/Cargo.toml" --features bundled --edges build,normal >"$work/bundled-tree"
+if grep -Eq 'reqwest|rustls|zip v' "$work/bundled-tree"; then
+  echo 'bundled native dependency still includes the downloader' >&2; exit 1
+fi
+# A fresh CI checkout uses stable mtimes, and refuses to normalize dirty source
+# or an existing target. These fixtures do not establish Cargo artifact freshness.
+fixture="$work/fixture"
+mkdir -p "$fixture/.github/scripts" "$fixture/rust_hft/native/libduckdb-sys"
+cp "$root/.github/scripts/prepare-research-native-source.sh" "$fixture/.github/scripts/"
+printf 'native fixture' >"$fixture/rust_hft/native/libduckdb-sys/build.rs"
+git -C "$fixture" init -q
+git -C "$fixture" add .
+git -C "$fixture" -c user.name=fixture -c user.email=fixture@example.invalid commit -qm fixture
+GITHUB_ACTIONS=true bash "$fixture/.github/scripts/prepare-research-native-source.sh"
+ruby -e 'abort "unstable mtime" unless File.mtime(ARGV[0]).to_i == 946684800' "$fixture/rust_hft/native/libduckdb-sys/build.rs"
+mkdir -p "$fixture/rust_hft/target/research-core"
+if GITHUB_ACTIONS=true bash "$fixture/.github/scripts/prepare-research-native-source.sh"; then exit 1; fi
+rmdir "$fixture/rust_hft/target/research-core"
+printf 'dirty' >>"$fixture/rust_hft/native/libduckdb-sys/build.rs"
+if GITHUB_ACTIONS=true bash "$fixture/.github/scripts/prepare-research-native-source.sh"; then exit 1; fi
+printf 'PASS: system and downloader compile, missing feature rejects, bundled graph excludes download dependencies, timestamp guards reject stale/dirty preparation\n'
diff --git a/.github/scripts/test-loop-nextest.sh b/.github/scripts/test-loop-nextest.sh
index 09719e019..65216dc85 100755
--- a/.github/scripts/test-loop-nextest.sh
+++ b/.github/scripts/test-loop-nextest.sh
@@ -247,16 +247,18 @@ abort 'loop step still runs cargo test' if loop.fetch('run').include?('cargo-sco
 abort 'loop step does not wait for shards' unless loop.fetch('run').include?('loop-nextest-wait.sh')
 archive = jobs.fetch('rust_loop_nextest_archive')
 abort 'archive must depend only on scope' unless archive.fetch('needs') == 'scope'
-cache = archive.fetch('steps').find { |step| step['uses'].to_s.include?('Swatinem/rust-cache@') }
-abort 'archive cache key drifted' unless cache && cache.dig('with', 'key') == 'loop-nextest-research-owner-v2-${{ steps.cache-info.outputs.rust }}'
-cache_pairs = cache.dig('with', 'workspaces').lines.map(&:strip).reject(&:empty?).map { |line| line.split(/\s*->\s*/) }
-abort 'archive cleanup must use only the research owner' unless cache_pairs.length == 1 && cache_pairs[0][0] == 'rust_hft/research-core'
-cache_source, cache_target = cache_pairs.fetch(0)
-abort 'archive cache target is missing' unless cache_target
-target = Pathname.new(cache_source).join(cache_target).cleanpath.to_s
-build_target = archive.fetch('env').fetch('CARGO_TARGET_DIR').delete_prefix('${{ github.workspace }}/')
-abort 'archive cache does not cover its Cargo target' unless target == build_target
-abort 'archive cache save drifted' unless cache.dig('with', 'save-if') == "${{ github.ref == 'refs/heads/main' }}"
+archive_steps = archive.fetch('steps')
+cache = archive_steps.find { |step| step['uses'].to_s.start_with?('actions/cache/restore@') }
+save = archive_steps.find { |step| step['uses'].to_s.start_with?('actions/cache/save@') }
+abort 'archive must retain its path native dependency' unless cache && save && archive.dig('env', 'MONDAY_CARGO_TARGET_LAYOUT') == 'owning-workspace-v1'
+abort 'archive cache key drifted' unless cache.dig('with', 'key') == 'loop-nextest-${{ steps.cache-info.outputs.key }}'
+abort 'archive restore/save identities differ' unless %w[key path].all? { |key| cache.dig('with',key) == save.dig('with',key) }
+abort 'archive compatible restore missing' unless cache.dig('with','restore-keys') == 'loop-nextest-${{ steps.cache-info.outputs.compat_prefix }}'
+cleanup = archive_steps.index { |step| step['run'].to_s.include?('ci-owner-cache.sh" cleanup') }
+abort 'archive cache must clean local application bytes before save' unless cleanup && cleanup < archive_steps.index(save)
+abort 'archive cache is not main/success bound' unless save.fetch('if').include?("github.ref == 'refs/heads/main' && success()")
+prepare = archive_steps.index { |step| step['run'].to_s.include?('prepare-research-native-source.sh') }
+abort 'archive native source preparation must precede restore' unless prepare && prepare < archive_steps.index(cache)
 shard = jobs.fetch('rust_loop_nextest_shard')
 abort 'shard must depend only on the archive' unless shard.fetch('needs') == 'rust_loop_nextest_archive'
 abort 'shard fail-fast must stay off' unless shard.dig('strategy', 'fail-fast') == false
diff --git a/.github/scripts/test-research-cache-layout.sh b/.github/scripts/test-research-cache-layout.sh
index 866935b90..9c1aed346 100644
--- a/.github/scripts/test-research-cache-layout.sh
+++ b/.github/scripts/test-research-cache-layout.sh
@@ -23,6 +23,13 @@ while IFS= read -r manifest; do
   cp "$root/rust_hft/$manifest" "$compat_repo/rust_hft/$manifest"
   printf 'fixture lock\n' >"$compat_repo/rust_hft/${manifest%Cargo.toml}Cargo.lock"
 done < <(jq -r '.workspaces[].manifest' "$root/rust_hft/workspaces.json")
+# Use the real compiler recipe input path, not a fabricated recipe digest.
+for script in build-research-release.sh build-research-recipes.sh capture-research-build-inputs.sh research-release-products.sh \
+  research-release-source-sha.sh research-workspace-locks.sh verify-research-runtime-abi.sh \
+  verify-research-runner-binaries.sh research-native-dependency-inputs.rb compile-research-recipe.sh prepare-research-native-source.sh; do
+  cp "$root/.github/scripts/$script" "$compat_repo/.github/scripts/"
+done
+cp "$root/.github/scripts/research-image-release-artifact.sh" "$compat_repo/.github/scripts/"
 printf '[features]\ndefault=[]\n' >"$compat_repo/rust_hft/alpha-harness/app/Cargo.toml"
 git -C "$compat_repo" init -q
 git -C "$compat_repo" add rust_hft
@@ -40,12 +47,62 @@ fixture_inputs() {
   digest=$(printf 'compiler/native fixture\n' | sha256sum | awk '{print $1}')
   jq -Sn --arg digest "$digest" --arg profiles "$(sha256sum "$work/profiles" | awk '{print $1}')" \
     --argjson owners "$profiles" \
+    --arg recipe "$(bash "$compat_helper" recipe-inputs | sha256sum | awk '{print $1}')" \
     --argjson locks "$(bash "$root/.github/scripts/research-workspace-locks.sh" "$compat_repo/rust_hft")" \
-    --argjson recipes "$(bash "$root/.github/scripts/research-release-products.sh" recipes "${1:-cex-runner,controller}" | jq -s .)" \
+    --argjson recipes "$(bash "$compat_repo/.github/scripts/research-release-products.sh" recipes "${1:-cex-runner,controller}" | jq -s .)" \
     '{schema:"monday.compilation-inputs.v3",target:"x86_64-unknown-linux-gnu",profile:"release",
-      compiler:$digest,native:$digest,flags:$digest,profiles:$profiles,recipe:$digest,
+      compiler:$digest,native:$digest,flags:$digest,profiles:$profiles,recipe:$recipe,
       builder_image:("rust:fixture@sha256:"+$digest),recipes:$recipes,workspace_profiles:$owners,locks:$locks}'
 }
+# Metadata fixtures exercise identity derivation without compiling DuckDB.
+original_path=$PATH
+mkdir -p "$work/native-bin"
+cat >"$work/native-bin/cargo" <<'NATIVE_CARGO'
+#!/usr/bin/env bash
+set -euo pipefail
+[[ $1 == metadata ]]
+if [[ -n ${MONDAY_NATIVE_CALLS:-} ]]; then printf '%s\n' "$*" >>"$MONDAY_NATIVE_CALLS"; fi
+cat "$MONDAY_NATIVE_FIXTURE"
+NATIVE_CARGO
+chmod +x "$work/native-bin/cargo"
+export MONDAY_NATIVE_FIXTURE="$work/native-metadata.json"
+export PATH="$work/native-bin:$PATH"
+cat >"$MONDAY_NATIVE_FIXTURE" <<'NATIVE_JSON'
+{"packages":[{"id":"native","name":"libduckdb-sys","version":"1.10504.0","source":"registry+https://github.com/rust-lang/crates.io-index"},{"id":"cc","name":"cc","version":"1.2.0","source":"registry+https://github.com/rust-lang/crates.io-index"}],"resolve":{"nodes":[{"id":"native","features":["bundled"],"dependencies":["cc"]},{"id":"cc","features":[],"dependencies":[]}]}}
+NATIVE_JSON
+cp "$MONDAY_NATIVE_FIXTURE" "$work/native-original.json"
+native_fixture_locks() {
+  ruby -rjson - "$MONDAY_NATIVE_FIXTURE" "$compat_repo/rust_hft" <<'NATIVE_LOCKS'
+metadata, root = ARGV
+lock = "version = 3\n" + JSON.parse(File.read(metadata)).fetch('packages').map do |package|
+  "[[package]]\nname=#{package.fetch('name').to_json}\nversion=#{package.fetch('version').to_json}\nsource=#{package.fetch('source').to_json}\nchecksum=\"#{'1' * 64}\"\n"
+end.join
+Dir.glob("#{root}/**/Cargo.lock").each { |path| File.write(path, lock) }
+NATIVE_LOCKS
+}
+native_fixture_locks
+# Repeated recipes share resolution only when the full Cargo command is identical.
+export MONDAY_NATIVE_CALLS="$work/native-calls"
+bash "$compat_repo/.github/scripts/research-release-products.sh" recipes all | jq -s . >"$work/native-recipes.json"
+ruby "$compat_repo/.github/scripts/research-native-dependency-inputs.rb" "$compat_repo" "$work/native-recipes.json" >"$work/native-deduplicated.json"
+[[ $(wc -l <"$MONDAY_NATIVE_CALLS") -eq 4 ]]
+# Running each recipe separately is the prior behavior and identity oracle.
+: >"$work/native-separate.jsonl"
+while IFS= read -r recipe; do
+  printf '[%s]\n' "$recipe" >"$work/native-single.json"
+  ruby "$compat_repo/.github/scripts/research-native-dependency-inputs.rb" "$compat_repo" "$work/native-single.json" >>"$work/native-separate.jsonl"
+done < <(jq -c '.[]' "$work/native-recipes.json")
+jq -sS '{schema:.[0].schema,closures:([.[].closures[]]|unique)}' "$work/native-separate.jsonl" >"$work/native-expected.json"
+jq -S '.closures |= sort' "$work/native-deduplicated.json" >"$work/native-actual.json"
+cmp "$work/native-expected.json" "$work/native-actual.json"
+# Different package-qualified feature arguments must not share resolution.
+jq '[.[0], (.[0] + {features:"extra"}), (.[1] + {features:"extra"}), .[0]]' "$work/native-recipes.json" >"$work/native-features.json"
+: >"$MONDAY_NATIVE_CALLS"
+ruby "$compat_repo/.github/scripts/research-native-dependency-inputs.rb" "$compat_repo" "$work/native-features.json" >/dev/null
+[[ $(wc -l <"$MONDAY_NATIVE_CALLS") -eq 3 ]]
+unset MONDAY_NATIVE_CALLS
+printf 'PASS: native metadata resolves four distinct commands instead of eight recipes; identity matches separate resolution\n'
+cp "$compat_repo/rust_hft/research-core/Cargo.lock" "$work/original-fixture-lock"
 fixture_inputs >"$work/full.json"
 cp "$work/full.json" "$work/full-before.json"
 bash "$compat_helper" compatibility-inputs "$work/full.json" >"$work/compat.json"
@@ -59,19 +116,103 @@ check_identity_change() {
   actual=$(sha256sum "$work/changed-compat.json" | awk '{print $1}')
   if [[ $expected == reuse ]]; then [[ $actual == "$compat_sha" ]]; else [[ $actual != "$compat_sha" ]]; fi
 }
+# A valid catalog edit changes exact provenance, not dependency compatibility.
+# Both feature sets build the same operator binary; only the recipe identity differs.
+catalog="$compat_repo/.github/scripts/research-release-products.json"
+cp "$catalog" "$work/catalog-original"
+release="$work/catalog-release"
+mkdir -p "$release/research-bin"
+while IFS= read -r binary; do
+  printf 'catalog fixture executable: %s\n' "$binary" >"$release/research-bin/$binary"
+  chmod 0755 "$release/research-bin/$binary"
+done < <(bash "$compat_repo/.github/scripts/research-release-products.sh" binaries cex-runner,controller)
+artifact="$compat_repo/.github/scripts/research-image-release-artifact.sh"
+source_sha=1111111111111111111111111111111111111111
+MONDAY_BUILD_INPUTS_FILE="$work/full.json" bash "$artifact" create "$release" "$source_sha" 42 "$compat_repo/rust_hft" 1 7 cex-runner,controller
+bash "$artifact" verify "$release" "$source_sha" 42 "$compat_repo/rust_hft" 1 7 cex-runner,controller
+bash "$compat_helper" recipe-inputs >"$work/compiler-recipe"
+jq '(.recipes[] | select(.package=="alpha-harness" and .binaries==["alpha-harness"]) | .features)="operator"' \
+  "$work/catalog-original" >"$catalog"
+fixture_inputs >"$work/changed.json"
+check_identity_change reuse
+bash "$compat_helper" recipe-inputs >"$work/catalog-recipe"
+cmp "$work/compiler-recipe" "$work/catalog-recipe"
+if bash "$artifact" verify "$release" "$source_sha" 42 "$compat_repo/rust_hft" 1 7 cex-runner,controller >"$work/rejection" 2>&1; then
+  echo 'old catalog recipes were accepted as current provenance' >&2; exit 1
+fi
+# The same executable fixture with current provenance is valid. This isolates
+# the rejection above to the recipe change, rather than an unrelated fixture error.
+rm "$release/research-image-release.json"
+MONDAY_BUILD_INPUTS_FILE="$work/changed.json" bash "$artifact" create "$release" "$source_sha" 42 "$compat_repo/rust_hft" 1 7 cex-runner,controller
+bash "$artifact" verify "$release" "$source_sha" 42 "$compat_repo/rust_hft" 1 7 cex-runner,controller
+cp "$work/catalog-original" "$catalog"
+printf '\n# changed compiler orchestration\n' >>"$compat_repo/.github/scripts/build-research-recipes.sh"
+fixture_inputs >"$work/changed.json"
+check_identity_change reuse
+cp "$root/.github/scripts/build-research-recipes.sh" "$compat_repo/.github/scripts/"
+for script in build-research-release.sh verify-research-runtime-abi.sh verify-research-runner-binaries.sh; do
+  printf '\n# packaging or validation text change\n' >>"$compat_repo/.github/scripts/$script"
+  fixture_inputs >"$work/changed.json"
+  check_identity_change reuse
+  cp "$root/.github/scripts/$script" "$compat_repo/.github/scripts/"
+done
+for script in compile-research-recipe.sh research-cache-layout.sh prepare-research-native-source.sh; do
+  printf '\n# changed actual compile or cleanup contract\n' >>"$compat_repo/.github/scripts/$script"
+  fixture_inputs >"$work/changed.json"
+  check_identity_change isolate
+  cp "$root/.github/scripts/$script" "$compat_repo/.github/scripts/"
+done
+printf 'PASS: valid catalog edit preserves dependency identity, changes exact inputs and rejects old artifact recipes\n'
+# Cargo-resolved native version/source/features and build dependencies must isolate.
+for update in '.packages[0].version="1.10505.0"' '.packages[0].source="git+https://example.invalid/duckdb#1234"' \
+  '.resolve.nodes[0].features=["bundled","json"]' '.packages[1].version="1.3.0"'; do
+  jq "$update" "$work/native-original.json" >"$MONDAY_NATIVE_FIXTURE"
+  native_fixture_locks
+  bash "$compat_helper" compatibility-inputs "$work/full.json" >"$work/native-changed.json"
+  [[ $(sha256sum "$work/native-changed.json" | awk '{print $1}') != "$compat_sha" ]]
+done
+cp "$work/native-original.json" "$MONDAY_NATIVE_FIXTURE"
+native_fixture_locks
+jq '.packages += [{id:"business",name:"unrelated-business",version:"2.0.0",source:null}]' \
+  "$work/native-original.json" >"$MONDAY_NATIVE_FIXTURE"
+bash "$compat_helper" compatibility-inputs "$work/full.json" >"$work/native-unrelated.json"
+cmp "$work/compat.json" "$work/native-unrelated.json"
+cp "$work/native-original.json" "$MONDAY_NATIVE_FIXTURE"
+ruby - "$compat_repo/rust_hft/research-core/Cargo.lock" <<'NATIVE_CHECKSUM'
+path = ARGV.fetch(0)
+File.write(path, File.read(path).sub('1' * 64, '2' * 64))
+NATIVE_CHECKSUM
+bash "$compat_helper" compatibility-inputs "$work/full.json" >"$work/native-checksum.json"
+[[ $(sha256sum "$work/native-checksum.json" | awk '{print $1}') != "$compat_sha" ]]
+native_fixture_locks
+# A path patch binds native archive and build script bytes, not checkout mtimes.
+mkdir -p "$compat_repo/rust_hft/native/libduckdb-sys"
+printf 'native archive fixture' >"$compat_repo/rust_hft/native/libduckdb-sys/duckdb.tar.gz"
+printf 'native build fixture' >"$compat_repo/rust_hft/native/libduckdb-sys/build.rs"
+jq --arg path "$compat_repo/rust_hft/native/libduckdb-sys/Cargo.toml" \
+  '.packages[0].source=null | .packages[0].manifest_path=$path' \
+  "$work/native-original.json" >"$MONDAY_NATIVE_FIXTURE"
+bash "$compat_helper" compatibility-inputs "$work/full.json" >"$work/native-local-before.json"
+for file in duckdb.tar.gz build.rs; do
+  printf 'changed bytes' >>"$compat_repo/rust_hft/native/libduckdb-sys/$file"
+  bash "$compat_helper" compatibility-inputs "$work/full.json" >"$work/native-local-after.json"
+  ! cmp -s "$work/native-local-before.json" "$work/native-local-after.json"
+  cp "$work/native-local-after.json" "$work/native-local-before.json"
+done
+cp "$work/native-original.json" "$MONDAY_NATIVE_FIXTURE"
 # Local feature and lock changes remain in complete provenance, not the restore prefix.
 cp "$compat_repo/rust_hft/alpha-harness/app/Cargo.toml" "$work/leaf-before"
 printf '[features]\ndefault=["scientific"]\n' >"$compat_repo/rust_hft/alpha-harness/app/Cargo.toml"
 fixture_inputs >"$work/changed.json"
 check_identity_change reuse
 cp "$work/leaf-before" "$compat_repo/rust_hft/alpha-harness/app/Cargo.toml"
-printf 'new fixture lock\n' >"$compat_repo/rust_hft/research-core/Cargo.lock"
+printf '\n# unrelated lock metadata\n' >>"$compat_repo/rust_hft/research-core/Cargo.lock"
 fixture_inputs >"$work/changed.json"
 check_identity_change reuse
-printf 'fixture lock\n' >"$compat_repo/rust_hft/research-core/Cargo.lock"
+cp "$work/original-fixture-lock" "$compat_repo/rust_hft/research-core/Cargo.lock"
 
 changed_digest=$(printf 'changed environment\n' | sha256sum | awk '{print $1}')
-for field in compiler native flags recipe; do
+for field in compiler native flags; do
   jq -S --arg field "$field" --arg digest "$changed_digest" '.[$field]=$digest' "$work/full.json" >"$work/changed.json"
   check_identity_change isolate
 done
@@ -226,6 +367,7 @@ end
 abort 'producer cache namespaces drifted' unless restores.uniq.length == 1
 RUBY
 printf 'PASS: dependency compatibility identity, provenance preservation and fail-closed input contracts\n'
+export PATH="$original_path"
 [[ ${1:-} != --compatibility-key ]] || exit 0
 
 bash "$root/.github/scripts/research-release-products.sh" recipes all | jq -s '{recipes:.}' >"$work/inputs"
@@ -254,7 +396,7 @@ jq -n --arg root "$FIXTURE/repo" --argjson extra "$extra" '{packages:([
   {name:"hidden-local",manifest_path:($root+"/vendor/hidden-local/Cargo.toml"),targets:[{name:"hidden_local"}]},
   {name:"outside-local",source:null,manifest_path:"/external/local/Cargo.toml",targets:[{name:"outside_local"}]},
   {name:"data-encoding",source:"registry+https://example.invalid",manifest_path:"/external/registry/data-encoding/Cargo.toml",targets:[{name:"data_encoding"}]},
-  {name:"libduckdb-sys",source:"registry+https://example.invalid",manifest_path:"/external/registry/libduckdb-sys/Cargo.toml",targets:[{name:"libduckdb_sys"}]},
+  {name:"libduckdb-sys",source:null,manifest_path:($root+"/rust_hft/native/libduckdb-sys/Cargo.toml"),targets:[{name:"libduckdb_sys"}]},
   {name:"local-code",source:"registry+https://example.invalid",manifest_path:"/external/registry/local-code/Cargo.toml",targets:[{name:"local_code"}]}
 ] else [] end)}'
 MOCK
diff --git a/.github/scripts/test-research-publication-budget.sh b/.github/scripts/test-research-publication-budget.sh
index adbc6cbb1..47041d9e8 100644
--- a/.github/scripts/test-research-publication-budget.sh
+++ b/.github/scripts/test-research-publication-budget.sh
@@ -10,9 +10,9 @@ products=cex-runner,controller,prediction-runner
 bash "$script_dir/research-publication-budget.sh" estimate "$source_sha" "$products" 744 "$work/estimate.json"
 jq -e '
  .basis=="catalog-static-upper-bound" and .source_archive.bytes>0 and
- [.allocations[].executable_count]==[9,1,5] and [.allocations[].build_count]==[6,1,3] and
- [.allocations[].native_requests]==[90,21,51] and
- .total.object_count==48 and .total.oss_requests==150 and .total.native_requests==162 and
+ [.allocations[].executable_count]==[8,1,5] and [.allocations[].build_count]==[5,1,3] and
+ [.allocations[].native_requests]==[78,21,51] and
+ .total.object_count==44 and .total.oss_requests==138 and .total.native_requests==150 and
  .total.request_body_bytes==(.allocations|map(.request_body_bytes)|add) and
  .total.response_body_bytes==(.allocations|map(.response_body_bytes)|add) and
  .pricing.estimated_micro_cny==(.pricing.request_micro_cny+.pricing.egress_micro_cny+.pricing.storage_micro_cny) and
@@ -46,7 +46,7 @@ run_admit() {
 run_admit "$work/policy.json"
 jq -e '.admission.single_run and .admission.publisher_run_id==456 and .admission.publisher_run_number==123' \
   "$work/admission.json" >/dev/null
-jq -e '.schema=="monday.oss-publication-budget.v1" and .limits.requests==162 and
+jq -e '.schema=="monday.oss-publication-budget.v1" and .limits.requests==150 and
  .publisher_run_id==456 and .publisher_run_attempt==1 and .expires_at_ms==1791684000000 and
  .publication_namespaces==["research/builds/","research/sources/"] and
  .limits.requests==(.allocations|map(.limits.requests)|add) and
@@ -150,7 +150,7 @@ jq --slurpfile estimate "$work/pair-estimate.json" '
  .max_request_body_bytes=$estimate[0].total.request_body_bytes |
  .max_response_body_bytes=$estimate[0].total.response_body_bytes |
  .max_new_storage_bytes=$estimate[0].total.new_storage_bytes' "$work/operations.json" >"$work/pair-policy.json"
-jq -e '.total.oss_requests==103' "$work/pair-estimate.json" >/dev/null
+jq -e '.total.oss_requests==91' "$work/pair-estimate.json" >/dev/null
 for order in 'cex-runner controller' 'controller cex-runner'; do
   run=500
   for product in $order; do
@@ -182,7 +182,7 @@ done
 # Both single-product estimates individually fit these underfunded source caps;
 # neither may spend until the complete fixed set fits. A failed sibling does not
 # return its reserved share to the other product.
-for expression in '.max_oss_requests=102' '.max_estimated_micro_cny-=1' \
+for expression in '.max_oss_requests=90' '.max_estimated_micro_cny-=1' \
  '.max_request_body_bytes-=1' '.max_response_body_bytes-=1' '.max_new_storage_bytes-=1'; do
   jq "$expression" "$work/pair-policy.json" >"$work/undersized-pair-policy.json"
   for product in cex-runner controller; do
diff --git a/.github/scripts/test-research-release-products.sh b/.github/scripts/test-research-release-products.sh
index 05b042811..725fb747d 100755
--- a/.github/scripts/test-research-release-products.sh
+++ b/.github/scripts/test-research-release-products.sh
@@ -13,11 +13,11 @@ products="$root/.github/scripts/research-release-products.sh"
 bash "$products" recipes prediction-runner >"$work/prediction-recipes"
 jq -s -e 'length==3 and all(.[]; .manifest=="prediction-markets/Cargo.toml") and any(.[]; .package=="ploy-research" and (.binaries|length)==3) and any(.[]; .package=="hft-prediction-research-worker" and .binaries==["monday-prediction-worker"]) and any(.[]; .package=="hft-prediction-research-operator" and .binaries==["monday-prediction-operator"])' "$work/prediction-recipes" >/dev/null
 bash "$products" recipes cex-runner >"$work/cex-recipes"
-jq -s -e 'length==6 and any(.[]; .package=="hft-cex-data-preparation" and .manifest=="data-pipelines/Cargo.toml" and .binaries==["monday-cex-prepare"]) and any(.[]; .package=="hft-cex-research-worker" and .binaries==["monday-cex-worker"]) and all(.[]; .package!="ploy-research" and .manifest!="prediction-markets/Cargo.toml")' "$work/cex-recipes" >/dev/null
-jq -s -e 'any(.[]; .package=="alpha-harness" and .features=="offline-diagnostic" and .binaries==["monday-offline-baseline"]) and any(.[]; .package=="alpha-harness" and .features=="" and .binaries==["alpha-harness"])' "$work/cex-recipes" >/dev/null
-[[ $(bash "$products" binaries cex-runner | wc -l) -eq 9 ]]
-[[ $(bash "$products" binaries all | wc -l) -eq 14 ]]
-[[ $(bash "$products" binaries cex-runner,controller | wc -l) -eq 9 ]]
+jq -s -e 'length==5 and any(.[]; .package=="hft-cex-data-preparation" and .manifest=="data-pipelines/Cargo.toml" and .binaries==["monday-cex-prepare"]) and any(.[]; .package=="hft-cex-research-worker" and .binaries==["monday-cex-worker"]) and all(.[]; .package!="ploy-research" and .manifest!="prediction-markets/Cargo.toml")' "$work/cex-recipes" >/dev/null
+jq -s -e 'all(.[]; (.binaries|index("monday-offline-baseline"))==null) and any(.[]; .package=="alpha-harness" and .features=="" and .binaries==["alpha-harness"])' "$work/cex-recipes" >/dev/null
+[[ $(bash "$products" binaries cex-runner | wc -l) -eq 8 ]]
+[[ $(bash "$products" binaries all | wc -l) -eq 13 ]]
+[[ $(bash "$products" binaries cex-runner,controller | wc -l) -eq 8 ]]
 [[ $(bash "$products" merge controller prediction-runner) == controller,prediction-runner ]]
 for invalid in runner paired '' 'cex-runner,cex-runner' 'prediction-runner,unknown' 'all,controller'; do
   if bash "$products" normalize "$invalid" >"$work/rejection" 2>&1; then
@@ -33,6 +33,10 @@ catalog=JSON.parse(File.read(File.join(root,'.github/scripts/research-release-pr
   prebuilt=text.split(/^FROM runtime-base AS prebuilt\s*$/,2).fetch(1).split(/^FROM /,2).first
   copied=prebuilt.scan(/^COPY --chmod=0755 research-bin\/(\S+) \/usr\/local\/bin\/(\S+)$/)
   abort "unexpected prebuilt COPY: #{product}" unless copied.all? { |source,target| source==target } && copied.map(&:first).sort==catalog.fetch(product).sort
+  builder=text.split(/^FROM .* AS runtime-base\s*$/,2).first
+  installed=builder.scan(/install -D -m 0755 (\S+) \/out\/bin\/(\S+)/)
+  target=product=='cex-runner' ? '/work/target/release' : '/work/target/prediction-markets/release'
+  abort "unexpected source install: #{product}" unless installed.all? { |source,binary| source=="#{target}/#{binary}" } && installed.map(&:last).sort==catalog.fetch(product).sort
   foreign=catalog.fetch(product=='cex-runner' ? 'prediction-runner' : 'cex-runner')
   abort "source builder imports another domain: #{product}" if foreign.any? { |binary| text.include?(binary) }
 end
@@ -88,7 +92,7 @@ bash "$root/.github/scripts/test-research-product-image.sh"
 # binaries. Only the target recorded by compiler inputs may reach the archive.
 fixture="$work/producer"
 mkdir -p "$fixture/.github/scripts" "$fixture/rust_hft" "$fixture/bin" "$fixture/output"
-for script in research-cache-layout.sh build-research-release.sh build-research-recipes.sh research-release-source-sha.sh research-release-products.sh research-release-products.json research-workspace-locks.sh research-image-release-artifact.sh verify-research-runner-binaries.sh research-release-bundle.rb; do
+for script in research-cache-layout.sh build-research-release.sh build-research-recipes.sh compile-research-recipe.sh research-release-source-sha.sh research-release-products.sh research-release-products.json research-workspace-locks.sh research-image-release-artifact.sh verify-research-runner-binaries.sh research-release-bundle.rb; do
   cp "$root/.github/scripts/$script" "$fixture/.github/scripts/$script"
 done
 cp "$root/rust_hft/workspaces.json" "$fixture/rust_hft/workspaces.json"
@@ -143,6 +147,9 @@ if [[ $1 == metadata ]]; then
   jq -n --arg root "$PWD" '{packages:[{name:"alpha-harness",manifest_path:($root+"/alpha-harness/Cargo.toml"),targets:[{name:"alpha_harness"}]}]}'
   exit
 fi
+[[ ${CARGO_LOG:-} == cargo::core::compiler::fingerprint=info ]]
+[[ ${CARGO_TERM_COLOR:-} == never ]]
+printf ' INFO cargo::core::compiler::fingerprint: fingerprint error for libduckdb-sys: missing fixture fingerprint\n' >&2
 printf 'build\n' >>"${MONDAY_TEST_CARGO_BUILD_LOG:?}"
 [[ ${FAIL_RECIPE:-0} != 1 ]] || exit 37
 target='' manifest='' package='' features='' jobs='' binaries=()
@@ -171,6 +178,17 @@ File.open(file, 'a') { |out| out.flock(File::LOCK_EX); out.puts(JSON.generate(re
 RUBY
   }
   event start
+  if [[ ${MONDAY_TEST_CARGO_MODE:-} == reclaim && $package == alpha-harness ]]; then
+    # Hold the slow owner until the supervisor observes both fast owners exit.
+    # Its current invocation keeps two jobs; only its next recipe may use four.
+    released=0
+    for ((wait_count=0; wait_count<200; wait_count++)); do
+      leases=("$RUNNER_TEMP"/research-recipe-jobs.*/research-core.jobs)
+      if [[ ${#leases[@]} == 1 && -f ${leases[0]} && $(cat "${leases[0]}") == 4 ]]; then released=1; break; fi
+      sleep 0.05
+    done
+    (( released == 1 )) || { echo 'final owner never reclaimed idle CPUs' >&2; exit 95; }
+  fi
   if [[ ${MONDAY_TEST_CARGO_MODE:-} == fail-and-cancel || ${MONDAY_TEST_CARGO_MODE:-} == interrupted ]]; then
     if [[ $package == hft-collector ]]; then
       ruby -e 'Signal.trap("TERM") {}; File.write(ARGV[0], Process.pid.to_s); sleep 30' "${MONDAY_TEST_COMPILER_PID:?}" &
@@ -218,6 +236,7 @@ jq --argjson count "$(bash "$products" recipes controller | jq -s length)" -es '
   and ([.[].phase]|unique)==["after-cache-lookup","dependency-warm-parallel","dependency-warm-serial","warm-local"]
   and ([.[].compilation_inputs_sha256]|unique|length)==1
   and ([.[].build_inputs]|unique|length)==1
+  and all(.[]; (.native_fingerprint_diagnostics|length)==1 and (.native_fingerprint_diagnostics[0]|contains("libduckdb-sys")))
   and all(.[]; .build_inputs.profile=="release" and .build_inputs.target=="x86_64-unknown-linux-gnu" and .phase_seconds>=0)
   and all(.[]|select(.phase=="dependency-warm-serial"); .scheduler.requested_owner_concurrency==1 and .scheduler.owner_concurrency==1 and .scheduler.cargo_jobs==8)
   and all(.[]|select(.phase=="dependency-warm-parallel"); .scheduler.requested_owner_concurrency==2 and .scheduler.owner_concurrency==1 and .scheduler.cargo_jobs==8)
@@ -283,9 +302,41 @@ events.sort_by { |event| event.fetch('at') }.each do |event|
 end
 abort 'independent owners never overlapped' unless maximum == 2 && active.empty?
 RUBY
-jq --argjson count "$(bash "$products" recipes all | jq -s length)" -es 'length==$count and all(.[]; .scheduler.owner_concurrency==2 and .scheduler.cargo_jobs==2)' \
+jq --argjson count "$(bash "$products" recipes all | jq -s length)" -es 'length==$count and all(.[]; .scheduler.owner_concurrency==2 and (.scheduler.cargo_jobs==2 or .scheduler.cargo_jobs==4))' \
   "$fixture/parallel-output/research-recipe-probe/timings.jsonl" >/dev/null
 
+# Reclaim only after both other owners exit, without changing an in-flight build.
+rm -f "$MONDAY_TEST_CARGO_EVENTS"
+mkdir -p "$fixture/reclaim-output"
+MONDAY_TEST_CARGO_MODE=reclaim PATH="$fixture/bin:$PATH" RUNNER_TEMP="$fixture/reclaim-output" MONDAY_SOURCE_REVISION="$sha" \
+  MONDAY_BUILD_INPUTS_FILE="$fixture/all-inputs.json" CARGO_BUILD_JOBS=4 \
+  bash "$fixture/.github/scripts/build-research-recipes.sh" all after-cache-lookup >"$work/reclaim.log"
+ruby -rjson - "$MONDAY_TEST_CARGO_EVENTS" <<'RUBY'
+events = File.readlines(ARGV[0]).map { |line| JSON.parse(line) }.sort_by { |event| event.fetch('at') }
+active = {}
+reclaimed = false
+events.each do |event|
+  owner = event.fetch('manifest')
+  if event.fetch('event') == 'start'
+    abort 'overlapping owner target writes' if active.key?(owner)
+    if event.fetch('package') == 'alpha-harness'
+      abort 'in-flight budget changed' unless event.fetch('jobs') == 2
+    elsif event.fetch('package') == 'hft-cex-research-worker'
+      abort 'idle CPUs were not reclaimed' unless event.fetch('jobs') == 4 && active.empty?
+      reclaimed = true
+    end
+    active[owner] = event.fetch('jobs')
+  else
+    abort 'completion without owner' unless active.delete(owner)
+  end
+  abort 'CPU or owner budget exceeded' unless active.length <= 2 && active.values.sum <= 4
+end
+abort 'reclaim evidence incomplete' unless reclaimed && active.empty?
+RUBY
+jq -es 'any(.[]; .recipe.package=="hft-cex-research-worker" and .scheduler.cargo_jobs==4)' \
+  "$fixture/reclaim-output/research-recipe-probe/timings.jsonl" >/dev/null
+[[ -z $(find "$fixture/reclaim-output" -name 'research-recipe-jobs.*' -print) ]]
+
 # Low available memory reduces overlap. Explicit serial mode uses the same recipes.
 printf 'MemAvailable: 4194304 kB\n' >"$MONDAY_TEST_MEMINFO_FILE"
 for mode in memory serial; do
@@ -306,6 +357,7 @@ MONDAY_TEST_CARGO_MODE=fail-and-cancel PATH="$fixture/bin:$PATH" RUNNER_TEMP="$f
   GITHUB_REPOSITORY=fixture/monday GITHUB_RUN_ID=42 MONDAY_BUILD_INPUTS_FILE="$fixture/all-inputs.json" \
   bash "$fixture/.github/scripts/build-research-release.sh" all >"$work/cancel.log" 2>&1 || code=$?
 [[ $code == 37 && ! -e $fixture/cancel-output/research-image-release.tar ]]
+[[ -z $(find "$fixture/cancel-output" -name 'research-recipe-jobs.*' -print) ]]
 for pid_file in "$MONDAY_TEST_COMPILER_PID" "$MONDAY_TEST_FAILED_COMPILER_PID"; do
   compiler_pid=$(cat "$pid_file")
   # PID 1 may retain an exited orphan as a zombie; it cannot execute anymore.
@@ -356,6 +408,7 @@ ensure
 end
 RUBY
 [[ ! -e $fixture/interrupted-output/research-image-release.tar ]]
+[[ -z $(find "$fixture/interrupted-output" -name 'research-recipe-jobs.*' -print) ]]
 
 # Invalid resource requests fail before starting a compiler.
 for request in cpu concurrency; do
diff --git a/.github/scripts/test-rust-docker-workspaces.rb b/.github/scripts/test-rust-docker-workspaces.rb
index f21ab055b..2be89d199 100644
--- a/.github/scripts/test-rust-docker-workspaces.rb
+++ b/.github/scripts/test-rust-docker-workspaces.rb
@@ -30,6 +30,12 @@ def tracked(pattern)
   block = block.split(/^\[/, 2)[0]
   name = block[/^name\s*=\s*"([^"]+)"/, 1]
   next unless name
+  # This checksum-documented native dependency is not an application owner.
+  if relative == 'rust_hft/native/libduckdb-sys/Cargo.toml'
+    abort 'unexpected native patch package' unless name == 'libduckdb-sys' &&
+      block.match?(/^version\s*=\s*"1\.10504\.0"/) && text.match?(/^\[workspace\]/)
+    next
+  end
   declared = block[/^workspace\s*=\s*"([^"]+)"/, 1]
   owner = if declared
             File.expand_path(File.join(declared, 'Cargo.toml'), File.dirname(file))
diff --git a/.github/scripts/test-select-rust-ci-scope.sh b/.github/scripts/test-select-rust-ci-scope.sh
index b7d90f495..b72e1db3f 100755
--- a/.github/scripts/test-select-rust-ci-scope.sh
+++ b/.github/scripts/test-select-rust-ci-scope.sh
@@ -708,6 +708,12 @@ manual_scope=$(run_case production-manual workflow_dispatch dev-input.txt "$prod
 assert_flag "$manual_scope" research_product cex-runner,controller,prediction-runner
 assert_flag "$manual_scope" production_trading_image true
 assert_flag "$manual_scope" production_collector_image true
+for helper in compile-research-recipe.sh research-native-dependency-inputs.rb prepare-research-native-source.sh test-duckdb-build-modes.sh; do
+  printf '%s\n' ".github/scripts/$helper" >"$tmp_dir/native-compile-helper.txt"
+  native_output=$(run_case native-compile-helper pull_request native-compile-helper.txt)
+  assert_jobs "$native_output" 'ploy/commit-hygiene,ploy/research-image-binaries,ploy/research-image-smoke,ploy/safety-scans,ci/ci-contracts,ploy/workflow-lint'
+done
+
 if [[ ${1:-} == --production-scope ]]; then
   printf 'production dependency scope contracts passed\n'
   exit 0
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4e4d51a74..9a23c7dd2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -209,6 +209,10 @@ jobs:
         uses: dtolnay/rust-toolchain@89b12181fb390509a0842a86cc55eeb8eb928c1d # stable
         with:
           toolchain: 1.98.1
+      - name: Verify DuckDB build modes and source freshness guards
+        env:
+          MONDAY_NATIVE_TEST_TARGET: ${{ runner.temp }}/native-mode-target
+        run: bash .github/scripts/test-duckdb-build-modes.sh
       - name: Verify selection, cancellation and aggregate admission
         run: |
           bash .github/scripts/test-collector-control-scheduling.sh
@@ -259,6 +263,7 @@ jobs:
       CARGO_TERM_COLOR: always
       CARGO_TARGET_DIR: ${{ github.workspace }}/rust_hft/target
       CARGO_INCREMENTAL: "0"
+      MONDAY_CARGO_TARGET_LAYOUT: owning-workspace-v1
       CARGO_PROFILE_DEV_DEBUG: "0"
       CARGO_PROFILE_TEST_DEBUG: "0"
     steps:
@@ -275,21 +280,27 @@ jobs:
       - name: Install Linux build tools
         run: bash "$GITHUB_WORKSPACE/.github/workflows/install-ubuntu-packages.sh" clang mold protobuf-compiler ruby
 
+      - name: Prepare committed native source before cache restore
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/prepare-research-native-source.sh"
+
       - name: Record cache dimensions
         id: cache-info
-        shell: bash
-        run: echo "rust=$(rustc -Vv | awk '/^release:/ {print $2}')" >> "$GITHUB_OUTPUT"
+        env:
+          MONDAY_CI_CACHE_PLAN: ${{ toJSON(needs.scope.outputs) }}
+        run: |
+          native=$(bash "$GITHUB_WORKSPACE/.github/scripts/ci-owner-cache.sh" native-input)
+          coverage=$(bash "$GITHUB_WORKSPACE/.github/scripts/ci-owner-cache.sh" coverage-input)
+          export MONDAY_CI_CACHE_NATIVE=${native#native=}
+          export MONDAY_CI_CACHE_COVERAGE=${coverage#coverage=}
+          bash "$GITHUB_WORKSPACE/.github/scripts/ci-owner-cache.sh" cache-input >> "$GITHUB_OUTPUT"
 
       - name: Cache Rust
-        uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2
+        id: owner-cache
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
-          # The archive builds research-core. Cleanup must use that owner's
-          # dependency graph, including native DuckDB compilation outputs.
-          workspaces: |
-            rust_hft/research-core -> ../target
-          key: loop-nextest-research-owner-v2-${{ steps.cache-info.outputs.rust }}
-          cache-all-crates: false
-          save-if: ${{ github.ref == 'refs/heads/main' }}
+          path: ${{ steps.cache-info.outputs.cache_paths }}
+          key: loop-nextest-${{ steps.cache-info.outputs.key }}
+          restore-keys: loop-nextest-${{ steps.cache-info.outputs.compat_prefix }}
 
       - name: Install cargo-nextest
         run: bash "$GITHUB_WORKSPACE/.github/scripts/install-cargo-nextest.sh"
@@ -322,6 +333,17 @@ jobs:
           if-no-files-found: error
           retention-days: 7
 
+      - name: Retain dependencies for the trusted archive cache
+        if: success()
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/ci-owner-cache.sh" cleanup
+
+      - name: Save trusted archive dependencies
+        if: ${{ github.ref == 'refs/heads/main' && success() && steps.owner-cache.outputs.cache-hit != 'true' }}
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
+        with:
+          path: ${{ steps.cache-info.outputs.cache_paths }}
+          key: loop-nextest-${{ steps.cache-info.outputs.key }}
+
   rust_loop_nextest_shard:
     name: Loop nextest shard (${{ matrix.shard }})
     needs: rust_loop_nextest_archive
@@ -424,6 +446,10 @@ jobs:
         if: ${{ (needs.scope.outputs.toolchain == 'true') }}
         run: bash "$GITHUB_WORKSPACE/.github/workflows/install-ubuntu-packages.sh" clang mold protobuf-compiler
 
+      - name: Prepare committed native source before cache restore
+        if: ${{ needs.scope.outputs.toolchain == 'true' }}
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/prepare-research-native-source.sh"
+
       - name: Record cache dimensions
         if: ${{ (needs.scope.outputs.toolchain == 'true') }}
         id: cache-info
diff --git a/docs/research/CEX_IMAGE_BUILD_SCOPE.md b/docs/research/CEX_IMAGE_BUILD_SCOPE.md
new file mode 100644
index 000000000..82ec6c82c
--- /dev/null
+++ b/docs/research/CEX_IMAGE_BUILD_SCOPE.md
@@ -0,0 +1,88 @@
+# CEX image build scope
+
+The production CEX image packages eight executables through five release recipes.
+The offline diagnostic has a separate local build documented in [OFFLINE_BASELINE.md](OFFLINE_BASELINE.md).
+Removing that executable removes its operator-plus-offline recipe from every CEX image build.
+It does not remove the scientific worker's offline-diagnostic library feature.
+
+## Entry points and dependency boundaries
+
+| Entry | Build owner and features | Packaging decision |
+| --- | --- | --- |
+| `hft-backtest` | research-core; default | Retain the existing Docker entry point. |
+| `alpha-harness` | research-core; default operator | Retain Campaign freeze, finalize and dispatch commands. Controller shares these exact bytes. |
+| `monday-cex-worker` | research-core; scientific, without alpha-harness default features | Retain the admitted Campaign execution entry point. |
+| `monday-offline-baseline` | Explicit local alpha-harness offline-diagnostic build, without defaults | Exclude from production images. No production entry point invokes it. |
+| `lob-pit-materializer` | data-pipelines; collector | Retain materialization script dependency. |
+| `binance-market-tape-slicer` | data-pipelines; collector | Retain materialization script dependency. |
+| `binance-replay-parquet-materializer` | data-pipelines; collector | Retain materialization script dependency. |
+| `clickhouse-analytics-materializer` | data-pipelines; collector | Retain data preparation tooling. |
+| `monday-cex-prepare` | data-pipelines; preparation | Retain preparation and its source-version smoke check. |
+
+The catalog and both Docker build paths must agree. Product tests check the exact
+prebuilt copies, producer archive, binary startup and compiler failure handling.
+The existing dependency graph still propagates shared source changes conservatively.
+No source path is excluded from CI by this change.
+
+## Reuse and identity
+
+Parameter-only experiments reuse an admitted immutable Build and verified prepared inputs.
+Data semantics, including label windows, still invalidate prepared-input reuse.
+See [CAMPAIGN_PREPARATION_REUSE.md](CAMPAIGN_PREPARATION_REUSE.md).
+
+The release profile, target, compiler, native environment and workspace inputs remain
+bound to compilation provenance. Cargo targets stay isolated by owning workspace.
+The changed recipe list remains part of exact build inputs and artifact validation.
+The dependency restore identity binds the small compiler helper, cache cleanup,
+compiler, native environment, flags and owning-workspace profiles.
+Cargo metadata resolves DuckDB's version, immutable source, features and dependency
+closure. Native closure changes isolate the dependency cache.
+Business source, unrelated resolved packages, packaging and smoke scripts remain
+outside this identity. Complete recipe provenance still binds those scripts.
+This migration starts a new key. Branch CI cannot populate trusted main caches.
+The historical main run restored dependencies and marked DuckDB artifacts fresh;
+its 13m48s recipe phase does not establish that every main build was cold.
+Dependency cache reuse does not authenticate executable bytes: builds still produce,
+hash and smoke-test the complete selected product at the admitted source revision.
+No research-profile executable is presented as a release artifact.
+
+## Measurement and remaining scope
+
+The prior reference is Monorepo 38429350564 at 14m19s and Prediction 38429350500
+at 20m51s. Research job 115408859232 took about 15m57s, including 13m52s build.
+The reported merge-to-ACR interval was 24m43s. These are historical observations,
+not a controlled benchmark for this change.
+
+This change reduces nine executables and six recipes to eight and five.
+It does not promise a proportional wall-time reduction: owners run concurrently,
+and the scientific worker still compiles its fitting and offline library closure.
+Use retained recipe timings, exact cache-hit state and runner identity to compare runs.
+Report queue, compilation, packaging and publication separately; overlapping phases
+must not be added together. A draft PR provides no merge-to-ACR measurement.
+
+Further separation of preparation, operator and scientific images requires a complete
+consumer and signed-product protocol change. This patch preserves that boundary.
+The 10–15 minute small-change target remains unproven until comparable CI measurements exist.
+
+The existing diagnostic run 38525297670 tested commit
+`4e64020efbda664eef46790de8373c4b6c5368aa` on one EPYC 9V45 runner with four CPUs.
+Its cold recipe phase took 1481s. Full local reuse took 2s.
+After removing local compilation bytes, serial rebuilding took 568s and parallel
+rebuilding took 502s. DuckDB artifacts stayed fresh in both dependency-warm phases;
+local packages rebuilt and the binary hashes agreed.
+These are recipe timings, not full CI or publication timings.
+The runner differs from the historical EPYC 7763 baseline. This is not an old/new
+code speedup estimate. The dependency identity patch still needs its own CI validation.
+
+## Native resolution deduplication
+
+The catalog repeats Cargo metadata requests for recipes with identical workspace and feature arguments.
+Resolve each distinct command once per identity capture. Keep package-qualified feature requests separate.
+This reduces eight catalog requests to four, before adding the independent publisher request.
+Regression tests compare the resulting native identity with separate per-recipe resolution.
+The memo exists only inside one process. It cannot reuse metadata after source or lockfile changes.
+
+This reduces metadata overhead, not Rust compilation. The helper remains part of the compatibility key.
+Its first CI execution therefore needs a new cache identity. Only successful main builds save trusted bytes.
+A PR rerun cannot establish cross-run warm-cache performance before that identity exists on main.
+Do not interpret same-run diagnostic phases as cross-run cache evidence.
diff --git a/docs/research/DUCKDB_CACHE_AUDIT_20261016.md b/docs/research/DUCKDB_CACHE_AUDIT_20261016.md
new file mode 100644
index 000000000..daa1e9204
--- /dev/null
+++ b/docs/research/DUCKDB_CACHE_AUDIT_20261016.md
@@ -0,0 +1,185 @@
+# DuckDB cache and build budget audit
+
+Evidence date: 2026-10-16. Times below are durations. GitHub timestamps use UTC.
+PR: [#1430](https://github.com/proerror77/monday/pull/1430).
+Reviewed branch head: `22c909b727c3f7f5e365b304925844e3f14dcf81`.
+This includes the fingerprint diagnostics added after `073396357`.
+
+## Actual run evidence
+
+| Run | Source tested | Cache result | Recipe phase | Complete Prediction CI |
+| --- | --- | --- | --- | --- |
+| [38429350500](https://github.com/proerror77/monday/actions/runs/38429350500) | main `08b98142` | Previous-run cache restored; DuckDB build script and library fresh | 13m48s | 20m51s |
+| [38767757268](https://github.com/proerror77/monday/actions/runs/38767757268) | main `7de64784` | Previous-run cache restored; first DuckDB recipe not fresh | 26m17s | 30m14s |
+| [38831045248](https://github.com/proerror77/monday/actions/runs/38831045248) | PR merge `0be6aab8`, head `07339635` | Exact and compatible keys absent | 36m30s | 39m35s |
+| [38836120877](https://github.com/proerror77/monday/actions/runs/38836120877) | PR merge `70eccba8`, head `22c909b7` | Exact and compatible keys absent | 26m01s | 29m19s |
+
+The last run used EPYC 9V45 with four CPUs. Its image job took 27m24s.
+The build step took 26m04s. The operator recipe took 19m21s.
+The scientific worker took 4m49s and marked both DuckDB artifacts fresh.
+The offline smoke step took 48s. Steps overlap or nest; do not add their durations.
+The preceding PR run used EPYC 7763. These are not controlled speed comparisons.
+
+## What directly caused the latest native compilation
+
+Run 38836120877 logged failed reads for all three DuckDB fingerprints:
+
+```text
+target/research-core/x86_64-unknown-linux-gnu/release/.fingerprint/libduckdb-sys-52f9d69926e21174/lib-libduckdb_sys
+target/research-core/x86_64-unknown-linux-gnu/release/.fingerprint/libduckdb-sys-bdeb33e435cea0fa/run-build-script-build-script-build
+target/research-core/release/.fingerprint/libduckdb-sys-e0e6c3cde5c60cd6/build-script-build-script-build
+```
+
+The restore log also says `Cache not found`. This directly establishes a cold
+target, rather than a dirty fingerprint caused by a dependency update.
+Both PR runs requested compatibility identity
+`11f7e6516ebdf509e52dba420622288cdae7e4546fb6ffa5ab64c3b01e7adf49`.
+The instrumentation-only change preserved that identity.
+
+Historical main runs used compatibility identity
+`875c4a7d72813afb1feadc78bb76e0876d08ac727ec9f1ad648ef51ff634c37c`.
+The identity migration intentionally separates those caches.
+Successful main builds alone save cleaned dependency bytes. PR runs do not save them.
+Therefore repeated PR runs cannot populate the new trusted identity.
+Do not broaden writes to untrusted PR contexts to obtain a warm measurement.
+
+## Build dependencies and real Cargo units
+
+The downloaded `libduckdb-sys 1.10504.0` registry archive matched the lock checksum:
+`94e67523a40ee3da30411e00e243990b3760d91877202ab2f39c03ab34f8dbfc`.
+Its manifest unconditionally declares reqwest with blocking and rustls-tls features.
+Only the non-bundled source module uses the download client.
+
+Locked metadata at tested source `70eccba8` contains the dependency chain:
+
+```text
+libduckdb-sys 1.10504.0 build script -> reqwest 0.12.28 -> rustls 0.23.46
+```
+
+A read-only Cargo 1.98.1 unit graph confirms a host reqwest/rustls build beneath
+the bundled DuckDB build script. This is an actual build dependency, not only
+an unused lockfile entry. The graph command used `RUSTC_BOOTSTRAP=1` only for
+the diagnostic `-Z unstable-options --unit-graph` operation. It compiled no
+production bytes and changed no workflow, lockfile, cache admission or compiler flags.
+Production builds continue to use the existing stable Cargo command.
+
+Security commit `7fbeb700` changes rustls from 0.23.45 to 0.23.46.
+That identity change can legitimately invalidate the DuckDB build script and its native outputs.
+Run 38767757268 restored the exact cache saved by run 38429350500, then rebuilt DuckDB.
+However, it did not retain Cargo dirty reasons. The dependency change supports
+this explanation; the historical invalidation reason cannot be recovered from those logs.
+Do not claim it was the sole reason.
+
+A separate three-package Cargo 1.98.1 experiment tested this mechanism.
+A bundled C archive had a download build dependency referenced only under the disabled cfg branch.
+Cold build: native build script/library fresh=false. Unchanged build: both fresh=true.
+Changing only the unused build dependency made both fresh=false and reran the C build.
+Cargo reported `StaleDepFingerprint`; the archive hash stayed identical across all three phases.
+The consumer executed successfully each time. This is a small mechanism reproduction,
+not a DuckDB compilation benchmark or historical-run fingerprint evidence.
+
+## Conservative boundaries
+
+The exact suffix binds full provenance. Source and packaging changes can alter it
+without preventing compatible dependency restoration.
+The compatible prefix binds the compiler, builder digest, native environment,
+flags, profiles, compiler helper, cleanup contract and native dependency identities.
+Final executable hashes, source admission, ABI checks and offline smoke remain separate.
+
+There is still excess scope:
+
+- Native environment capture hashes every installed dpkg package, including packaging tools.
+- One combined prefix covers the cached owners. A native change can prevent restoration for all owners.
+- Cargo metadata resolves workspace feature unions rather than exact host compilation units.
+  At `70eccba8`, metadata adds reqwest json, stream, h2 and http2 features.
+  The DuckDB host reqwest unit uses blocking/rustls without those extra features.
+  The metadata closure contains 137 package identities; the host build closure contains 113.
+  The excess includes quinn, h2 and their dependencies. This proves excess key scope,
+  not an observed cache miss caused by any one of those packages.
+- The native identity helper and cache-layout script bytes enter the compiler contract hash.
+  A semantics-preserving helper edit still migrates the identity.
+
+These are potential miss amplifiers. They are not dirty reasons for the latest cold run.
+Removing rustls from the identity alone would not stop Cargo from rebuilding it.
+It would also discard a real build-dependency identity boundary.
+This change therefore retains the native key, checksum and feature controls.
+
+Safe future narrowing needs either an authenticated native artifact boundary or
+a reviewed upstream change that makes download dependencies conditional.
+The latter must preserve non-bundled behavior and regenerate every owning lockfile.
+Exact host-unit projection also needs a supported producer interface and regression evidence.
+The diagnostic unstable Cargo interface is not added to production key generation.
+
+## CPU allocation correction
+
+The old scheduler assigned two jobs to each owner on a four-CPU runner.
+That allocation remained fixed after both faster owners exited.
+In run 38831045248, Prediction finished at 00:59:59 UTC.
+The research-core owner then ran alone until 01:21:07 UTC with two jobs.
+This is 21m08s of nominal two-job capacity left unassigned.
+It does not prove the CPUs were physically idle or quantify recoverable time.
+
+The correction grants the final owner the admitted total budget only after every
+sibling exits and the pending owner queue is empty. Each recipe reads its budget
+once before Cargo starts. An atomic file replacement prevents partial reads.
+Current Cargo/cc jobservers retain their initial allocation.
+Therefore this correction does not accelerate an already-running DuckDB build.
+It can reclaim CPUs for the following scientific-worker recipe.
+
+The global CPU budget, memory overlap limit and one writer per owning target remain enforced.
+Regression tests exercise a delayed owner, reclaim on its next recipe, total active
+jobs, failure cancellation, TERM-ignoring descendants and removal of budget files.
+The compiler helper and native compatibility identity remain unchanged.
+These tests establish scheduling behavior, not elapsed-time improvement.
+
+## Remaining 10–15 minute conditions
+
+1. Obtain a compatible, successful trusted producer cache and verify restoration
+   in a different run. Do not label same-run reuse as cross-run evidence.
+2. Capture dirty reasons on a genuine restored-but-rebuilt case. Distinguish
+   missing files, build-dependency units, features, compiler/environment and file freshness.
+3. Measure the CPU correction on comparable hardware and cache state. It cannot
+   reclaim CPUs inside an already-running native build.
+4. Budget the full critical path: admission, setup, build, archive transfer, smoke
+   and final CI gate. Historical warm Prediction CI still exceeded 15 minutes.
+5. Measure publication separately only under an authorized publication task.
+   A successful PR CI run does not establish merge-to-registry or production latency.
+
+Cold native compilation already exceeds the complete target on the measured runners.
+The existing 8m22s same-run dependency-warm recipe result is not complete CI.
+No measured result here establishes a 10–15 minute full delivery outcome.
+
+## Download isolation implementation
+
+The continuation starts from PR head `f82a1ad2` and merges main `4310dc7e`.
+The patch vendors the checksum-verified `libduckdb-sys 1.10504.0` package at
+`rust_hft/native/libduckdb-sys`. Its C++ archive and native compiler backends match upstream bytes. Bindings keep
+upstream code with one trailing blank line removed. The functional changes affect
+only its manifest and downloader cfg gates.
+The license and patch provenance remain beside the source.
+
+Research-core and data-pipelines select this patch. Their lockfiles retain all
+other package versions. Bundled and system linking exclude reqwest and zip.
+The `download` feature retains the upstream downloader and requires the existing
+`DUCKDB_DOWNLOAD_LIB` switch. Requesting a download without that feature fails.
+Prediction retains its independently locked upstream `1.10501.0` package.
+
+Research cache identities hash every native patch file and the resolved native
+closure. The dev/test owner cache also binds patch bytes and source preparation.
+Both cleaners retain this exact native path while deleting application artifacts.
+Loop nextest uses the same owner-cache contract, with its own namespace. This
+avoids Swatinem removing the newly local native dependency before a trusted save.
+PR jobs still cannot save trusted dependency caches.
+
+Fresh CI checkouts normalize native source mtimes before any target restore.
+Preparation rejects dirty source or existing owning targets. Local builds retain
+actual mtimes. This handles local-path freshness without hiding changed source
+bytes from the compatibility identity. Native library ABI, flags, compiler,
+profiles, artifact hashing and offline smoke remain enforced.
+
+Focused checks cover system/downloader compilation, rejection without the
+feature, bundled dependency exclusion, source-byte cache invalidation, cleanup
+retention and source timestamp guards. Actual macOS integration checks use
+`SELECT 42` with the explicit downloader and system linking. The bundled native
+build and complete existing CI are reported separately; fixture and dependency
+graph checks do not establish a 10–15 minute full pipeline.
diff --git a/docs/research/OFFLINE_BASELINE.md b/docs/research/OFFLINE_BASELINE.md
index 2d095f0bb..4b7b7a5e1 100644
--- a/docs/research/OFFLINE_BASELINE.md
+++ b/docs/research/OFFLINE_BASELINE.md
@@ -2,6 +2,9 @@
 
 The Rust `monday-offline-baseline` driver fits fixed Ridge folds on prepared native rows and evaluates their full rolling out-of-sample ledger. This diagnostic cannot complete a production Campaign or grant compute authority.
 
+The production `cex-runner` image excludes this diagnostic executable. Build it explicitly with the recipe below.
+Its local output is not a signed production Build or an admitted Campaign runner.
+
 ## Reproduce a local synthetic run
 
 From the repository root:
diff --git a/rust_hft/data-pipelines/Cargo.lock b/rust_hft/data-pipelines/Cargo.lock
index 01b473709..568a96fb2 100644
--- a/rust_hft/data-pipelines/Cargo.lock
+++ b/rust_hft/data-pipelines/Cargo.lock
@@ -4014,18 +4014,14 @@ checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 [[package]]
 name = "libduckdb-sys"
 version = "1.10504.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94e67523a40ee3da30411e00e243990b3760d91877202ab2f39c03ab34f8dbfc"
 dependencies = [
  "cc",
  "flate2",
  "pkg-config",
- "reqwest 0.12.28",
  "serde",
  "serde_json",
  "tar",
  "vcpkg",
- "zip",
 ]
 
 [[package]]
diff --git a/rust_hft/data-pipelines/Cargo.toml b/rust_hft/data-pipelines/Cargo.toml
index 62c0a01e3..3ef23c4f3 100644
--- a/rust_hft/data-pipelines/Cargo.toml
+++ b/rust_hft/data-pipelines/Cargo.toml
@@ -57,4 +57,5 @@ codegen-units = 1
 debug = false
 
 [patch.crates-io]
+libduckdb-sys = { path = "../native/libduckdb-sys" }
 rust_decimal = { git = "https://github.com/proerror77/monday-rust-decimal-security-694", rev = "4f7bc6f02d7920b6416988914ae86d25f6670b22" }
diff --git a/rust_hft/deployment/docker/Dockerfile.research b/rust_hft/deployment/docker/Dockerfile.research
index 998f11fd6..6122ebb1e 100644
--- a/rust_hft/deployment/docker/Dockerfile.research
+++ b/rust_hft/deployment/docker/Dockerfile.research
@@ -44,10 +44,6 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry,sharing=locked \
     && MONDAY_SOURCE_REVISION="$SOURCE_REVISION" cargo --config 'build.rustc-wrapper=""' build \
     --manifest-path data-pipelines/Cargo.toml --release --locked \
     -p hft-cex-data-preparation --bin monday-cex-prepare \
-    && MONDAY_SOURCE_REVISION="$SOURCE_REVISION" cargo --config 'build.rustc-wrapper=""' build \
-    --manifest-path research-core/Cargo.toml --release --locked \
-    -p alpha-harness --features offline-diagnostic --bin monday-offline-baseline \
-    && install -D -m 0755 /work/target/release/monday-offline-baseline /out/bin/monday-offline-baseline \
     && install -D -m 0755 /work/target/release/monday-cex-prepare /out/bin/monday-cex-prepare \
     && install -D -m 0755 /work/target/release/hft-backtest /out/bin/hft-backtest \
     && install -D -m 0755 /work/target/release/alpha-harness /out/bin/alpha-harness \
@@ -78,8 +74,6 @@ ENTRYPOINT ["/usr/bin/tini", "--", "/usr/local/bin/hft-backtest"]
 
 FROM runtime-base AS prebuilt
 
-COPY --chmod=0755 research-bin/monday-offline-baseline /usr/local/bin/monday-offline-baseline
-
 COPY --chmod=0755 research-bin/monday-cex-prepare /usr/local/bin/monday-cex-prepare
 
 COPY --chmod=0755 research-bin/hft-backtest /usr/local/bin/hft-backtest
diff --git a/rust_hft/native/libduckdb-sys/Cargo.toml b/rust_hft/native/libduckdb-sys/Cargo.toml
new file mode 100644
index 000000000..44abbe03f
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/Cargo.toml
@@ -0,0 +1,155 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2024"
+rust-version = "1.85.1"
+name = "libduckdb-sys"
+version = "1.10504.0"
+authors = [
+    "DuckDB Labs and contributors",
+    "wangfenjin <wangfenj@gmail.com>",
+]
+build = "build.rs"
+links = "duckdb"
+exclude = ["duckdb-sources"]
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Native bindings to the libduckdb library, C API"
+homepage = "https://github.com/duckdb/duckdb-rs"
+readme = "README.md"
+keywords = [
+    "duckdb",
+    "database",
+    "ffi",
+]
+categories = [
+    "external-ffi-bindings",
+    "database",
+]
+license = "MIT"
+repository = "https://github.com/duckdb/duckdb-rs"
+
+[workspace]
+
+[features]
+download = ["dep:reqwest", "dep:zip"]
+autocomplete = ["bundled-cmake"]
+buildtime_bindgen = [
+    "bindgen",
+    "pkg-config",
+    "vcpkg",
+]
+bundled = ["cc"]
+bundled-cmake = [
+    "bundled",
+    "dep:cmake",
+    "dep:which",
+    "parquet",
+]
+default = [
+    "vcpkg",
+    "pkg-config",
+]
+extensions-full = [
+    "json",
+    "parquet",
+]
+icu = ["bundled-cmake"]
+json = ["bundled"]
+loadable-extension = [
+    "prettyplease",
+    "quote",
+    "syn",
+]
+parquet = ["bundled"]
+tpcds = ["bundled-cmake"]
+tpch = ["bundled-cmake"]
+winduckdb = []
+
+[lib]
+name = "libduckdb_sys"
+path = "src/lib.rs"
+
+[dev-dependencies.arrow]
+version = "58"
+features = ["ffi"]
+default-features = false
+
+[build-dependencies.bindgen]
+version = "0.72.1"
+features = ["runtime"]
+optional = true
+default-features = false
+
+[build-dependencies.cc]
+version = "1.0"
+features = ["parallel"]
+optional = true
+
+[build-dependencies.cmake]
+version = "0.1"
+optional = true
+
+[build-dependencies.flate2]
+version = "1.0"
+
+[build-dependencies.pkg-config]
+version = "0.3.24"
+optional = true
+
+[build-dependencies.prettyplease]
+version = "0.2.20"
+optional = true
+
+[build-dependencies.quote]
+version = "1.0.21"
+optional = true
+
+[build-dependencies.reqwest]
+optional = true
+version = "0.12"
+features = [
+    "blocking",
+    "rustls-tls",
+]
+default-features = false
+
+[build-dependencies.serde]
+version = "1.0"
+features = ["derive"]
+
+[build-dependencies.serde_json]
+version = "1.0"
+
+[build-dependencies.syn]
+version = "2.0.15"
+optional = true
+
+[build-dependencies.tar]
+version = "0.4.38"
+
+[build-dependencies.vcpkg]
+version = "0.2"
+optional = true
+
+[build-dependencies.which]
+version = "8"
+optional = true
+
+[build-dependencies.zip]
+optional = true
+version = "6"
+features = ["deflate"]
+default-features = false
diff --git a/rust_hft/native/libduckdb-sys/LICENSE b/rust_hft/native/libduckdb-sys/LICENSE
new file mode 100644
index 000000000..ccccdf5f0
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/LICENSE
@@ -0,0 +1,7 @@
+Copyright 2021-2026 Stichting DuckDB Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/rust_hft/native/libduckdb-sys/MONDAY-PATCH.md b/rust_hft/native/libduckdb-sys/MONDAY-PATCH.md
new file mode 100644
index 000000000..118d47b76
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/MONDAY-PATCH.md
@@ -0,0 +1,22 @@
+# Monday download dependency isolation
+
+Upstream: `libduckdb-sys 1.10504.0`, MIT, from crates.io.
+Registry archive SHA-256:
+`94e67523a40ee3da30411e00e243990b3760d91877202ab2f39c03ab34f8dbfc`.
+
+The native source archive and compiler backends are unchanged.
+Bindings retain upstream code; one generated file loses a trailing blank line.
+`download` explicitly enables reqwest and zip. System linking and bundled
+compilation do not compile these dependencies. Set both the feature and
+`DUCKDB_DOWNLOAD_LIB=1` to use the original upstream downloader. Without the
+feature, that environment variable fails with an actionable error.
+Bundled mode retains precedence over the download environment variable.
+
+The owning research-core and data-pipelines manifests select this patch.
+Prediction keeps its distinct locked upstream version.
+The native cache identity binds every patch file, features, dependency checksums,
+compiler, ABI, flags and profiles. Only this exact native path is retained during
+cache cleanup. Application path dependencies are still removed.
+Fresh CI checkouts normalize committed native source timestamps before cache
+lookup. Complete source hashes isolate changed bytes. Preparation rejects dirty
+source and existing owning targets. Local builds retain actual timestamps.
diff --git a/rust_hft/native/libduckdb-sys/README.md b/rust_hft/native/libduckdb-sys/README.md
new file mode 100644
index 000000000..020d7d093
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/README.md
@@ -0,0 +1,342 @@
+# duckdb-rs
+
+[![Latest Version](https://img.shields.io/crates/v/duckdb.svg)](https://crates.io/crates/duckdb)
+[![Documentation](https://img.shields.io/badge/docs.rs-duckdb-orange)](https://docs.rs/duckdb)
+[![MIT License](https://img.shields.io/crates/l/duckdb.svg)](LICENSE)
+[![Downloads](https://img.shields.io/crates/d/duckdb.svg)](https://crates.io/crates/duckdb)
+[![CI](https://github.com/duckdb/duckdb-rs/workflows/CI/badge.svg)](https://github.com/duckdb/duckdb-rs/actions)
+
+duckdb-rs is an ergonomic Rust wrapper for [DuckDB](https://github.com/duckdb/duckdb).
+
+You can use it to:
+
+- Query DuckDB with type-safe bindings and an API inspired by [rusqlite](https://github.com/rusqlite/rusqlite).
+- Read and write Arrow, Parquet, JSON, and CSV formats natively.
+- Create DuckDB extensions in Rust with custom scalar and table functions.
+
+## Quickstart
+
+Create a new project and add the `duckdb` crate:
+
+```shell
+cargo new quack-in-rust
+cd quack-in-rust
+cargo add duckdb -F bundled
+```
+
+Update `src/main.rs` with the following code:
+
+```rust
+use duckdb::{params, Connection, Result};
+
+struct Duck {
+    id: i32,
+    name: String,
+}
+
+fn main() -> Result<()> {
+    let conn = Connection::open_in_memory()?;
+
+    conn.execute(
+        "CREATE TABLE ducks (id INTEGER PRIMARY KEY, name TEXT)",
+        [], // empty list of parameters
+    )?;
+
+    conn.execute_batch(
+        r#"
+        INSERT INTO ducks (id, name) VALUES (1, 'Donald Duck');
+        INSERT INTO ducks (id, name) VALUES (2, 'Scrooge McDuck');
+        "#,
+    )?;
+
+    conn.execute(
+        "INSERT INTO ducks (id, name) VALUES (?, ?)",
+        params![3, "Darkwing Duck"],
+    )?;
+
+    let ducks = conn
+        .prepare("FROM ducks")?
+        .query_map([], |row| {
+            Ok(Duck {
+                id: row.get(0)?,
+                name: row.get(1)?,
+            })
+        })?
+        .collect::<Result<Vec<_>>>()?;
+
+    for duck in ducks {
+        println!("{}) {}", duck.id, duck.name);
+    }
+
+    Ok(())
+}
+```
+
+Execute the program with `cargo run` and watch DuckDB in action!
+
+## Examples
+
+The following [examples](crates/duckdb/examples) demonstrate various features and use cases of duckdb-rs:
+
+- **basic** - Basic usage including creating tables, inserting data, and querying with and without Arrow.
+- **appender** - Bulk data insertion using the appender API with transactions.
+- **parquet** - Reading Parquet files directly using DuckDB's Parquet extension.
+- **vscalar** - Defining and registering a custom scalar function (requires the `vscalar` feature).
+- **vtab** - Defining a custom table function returning primitive, LIST, and STRUCT columns (requires the `vtab` feature).
+- **repl** - Interactive SQL REPL.
+- **hello-ext** - A DuckDB extension written in Rust (see [Building and loading extensions](#building-and-loading-extensions)).
+
+Run any example with `cargo run --example <name>`.
+
+## Feature flags
+
+The `duckdb` crate provides a number of Cargo features that can be enabled to add functionality:
+
+### Virtual tables and functions
+
+- `vtab` - Base support for creating custom table functions and virtual tables.
+- `vtab-arrow` - Apache Arrow integration for virtual tables. Enables conversion between Arrow RecordBatch and DuckDB data chunks.
+- `vtab-excel` - Deprecated no-op retained for feature compatibility.
+- `vscalar` - Create custom scalar functions that operate on individual values or rows.
+- `vscalar-arrow` - Arrow-optimized scalar functions for vectorized operations.
+
+### File formats
+
+- `json` - Enables reading and writing JSON files. Implies `bundled`.
+- `parquet` - Enables reading and writing Parquet files. Implies `bundled`.
+
+### Bundled DuckDB extensions
+
+These extensions are only available through the CMake build backend and imply `bundled-cmake`.
+
+- `autocomplete` - DuckDB's autocomplete extension.
+- `icu` - DuckDB's ICU extension for locale-aware operations.
+- `tpch` - DuckDB's TPC-H benchmark extension.
+- `tpcds` - DuckDB's TPC-DS benchmark extension.
+
+### Data integration
+
+- `appender-arrow` - Efficient bulk insertion of Arrow data into DuckDB tables.
+- `polars` - Integration with Polars DataFrames.
+
+### Convenience features
+
+- `vtab-full` - Enables virtual table features: `vtab-arrow` and `appender-arrow`; retains the deprecated `vtab-excel` compatibility flag.
+- `extensions-full` - Enables all major extensions: `json`, `parquet`, and `vtab-full`.
+- `modern-full` - Enables modern Rust ecosystem integrations: `chrono`, `serde_json`, `url`, `r2d2`, `uuid`, and `polars`.
+
+### Build configuration
+
+- `bundled` - Uses a bundled version of DuckDB's source code and compiles it during build. This is the simplest way to get started and avoids needing DuckDB system libraries.
+- `bundled-cmake` - _Experimental_. Builds DuckDB via its upstream CMake build system instead of `cc`. Requires a duckdb-rs checkout (not available from crates.io). See [step 2](#notes-on-building-duckdb-and-libduckdb-sys) below for details.
+- `buildtime_bindgen` - Use bindgen at build time to generate fresh bindings instead of using pre-generated ones.
+- `loadable-extension` - _Experimental_ support for creating loadable DuckDB extensions. Includes procedural macros for extension development. Only enable this when building an extension, never for a client application - see [Database client or extension?](#database-client-or-extension)
+
+## Installation
+
+### Versioning
+
+Starting with DuckDB `v1.5.0`, the duckdb-rs version encodes the DuckDB version in its second semver component.
+The format is `1.MAJOR_MINOR_PATCH.x`, e.g., DuckDB `v1.5.0` maps to duckdb-rs `1.10500.x`.
+Use a tilde requirement to receive duckdb-rs patch releases without automatically moving to a different bundled DuckDB version.
+
+### Using stable releases from crates.io
+
+The recommended way to use duckdb-rs is to add it from crates.io:
+
+```shell
+cargo add duckdb -F bundled
+```
+
+Or manually add it to your `Cargo.toml`:
+
+```toml
+[dependencies]
+duckdb = { version = "~1.10504.0", features = ["bundled"] }
+```
+
+### Using the development version from git
+
+To use the latest development version from the main branch, you can specify a git dependency in your `Cargo.toml`:
+
+```toml
+# Use a specific branch
+duckdb = { git = "https://github.com/duckdb/duckdb-rs", branch = "main", features = ["bundled"] }
+
+# Use a specific commit
+duckdb = { git = "https://github.com/duckdb/duckdb-rs", rev = "abc123def", features = ["bundled"] }
+```
+
+Note: Using the main branch of duckdb-rs means you'll get the latest Rust bindings and features, but you'll still be using whatever version of DuckDB core is bundled with that commit (when using the `bundled` feature).
+
+## Notes on building duckdb and libduckdb-sys
+
+`libduckdb-sys` is a separate crate from `duckdb-rs` that provides the Rust
+declarations for DuckDB's C API. By default, `libduckdb-sys` attempts to find a DuckDB library that already exists on your system using pkg-config, or a
+[Vcpkg](https://github.com/Microsoft/vcpkg) installation for MSVC ABI builds.
+
+You can adjust this behavior in a number of ways:
+
+1. If you use the `bundled` feature, `libduckdb-sys` will use the
+   [cc](https://crates.io/crates/cc) crate to compile DuckDB from source and
+   link against that. This source is embedded in the `libduckdb-sys` crate and
+   tracks the DuckDB version vendored for that duckdb-rs release.
+   This is probably the simplest solution to any build problems. You can enable this by adding the following in your `Cargo.toml` file:
+
+   ```bash
+   cargo add duckdb --features bundled
+   ```
+
+   `Cargo.toml` will be updated.
+
+   ```toml
+   [dependencies]
+   duckdb = { version = "~1.10504.0", features = ["bundled"] }
+   ```
+
+2. If you use the `bundled-cmake` feature, `libduckdb-sys` will build DuckDB from the local checkout in `crates/libduckdb-sys/duckdb-sources` using upstream CMake. This keeps plain `bundled` unchanged while allowing CMake-only extensions such as `icu`.
+
+   Example:
+
+   ```toml
+   [dependencies]
+   duckdb = { git = "https://github.com/duckdb/duckdb-rs", branch = "main", features = ["bundled-cmake", "icu"] }
+   ```
+
+   Notes:
+   - `bundled-cmake` is _experimental_ and requires a git/workspace checkout. Published crates omit the full `duckdb-sources` tree.
+   - It implies `bundled` for conditional-compilation gates, but uses CMake instead of the `cc` backend. Any CMake-only extension feature (e.g. `icu`) enables it automatically.
+   - It always links DuckDB's default static extensions (`core_functions` and `parquet`) and therefore implies the `parquet` Cargo feature.
+   - Plain `bundled` uses DuckDB's standard allocator and skips jemalloc. `bundled-cmake` enables upstream jemalloc on supported 64-bit, non-musl Linux targets. Other targets follow DuckDB's CMake checks. Set `DUCKDB_DISABLE_JEMALLOC=1` to force the standard allocator.
+   - Extension autoload/autoinstall are enabled to match `bundled`, despite upstream CMake defaults. Set `DUCKDB_DISABLE_EXTENSION_LOAD=1` or `DISABLE_EXTENSION_LOAD=1` to disable external extension install/load support and force autoload/autoinstall off. Statically linked extensions remain available.
+   - If `ninja` is on `PATH`, the build uses Ninja by default. Set `CMAKE_GENERATOR` to override.
+   - DuckDB builds in `Release` mode by default, even for Rust debug builds, avoiding DuckDB's much slower debug/sanitizer profile. Override with `DUCKDB_CMAKE_BUILD_TYPE` or `CMAKE_BUILD_TYPE`. `DUCKDB_CMAKE_BUILD_TYPE` takes precedence.
+   - `DUCKDB_EXTENSION_CONFIGS` is unsupported. Setting it fails fast.
+   - Use `cargo build -vv -F bundled-cmake` for CMake configure/build logs.
+
+3. When linking against a DuckDB library already on the system (so _not_ using any of the `bundled` features), you can set the `DUCKDB_LIB_DIR` environment variable to point to a directory containing the library. You can also set the `DUCKDB_INCLUDE_DIR` variable to point to the directory containing `duckdb.h`.
+
+   Linux example:
+
+   ```shell
+   wget https://github.com/duckdb/duckdb/releases/download/v1.5.4/libduckdb-linux-arm64.zip
+   unzip libduckdb-linux-arm64.zip -d libduckdb
+
+   export DUCKDB_LIB_DIR=$PWD/libduckdb
+   export DUCKDB_INCLUDE_DIR=$DUCKDB_LIB_DIR
+   export LD_LIBRARY_PATH=$DUCKDB_LIB_DIR
+
+   cargo build --examples
+   ```
+
+   macOS example:
+
+   ```shell
+   wget https://github.com/duckdb/duckdb/releases/download/v1.5.4/libduckdb-osx-universal.zip
+   unzip libduckdb-osx-universal.zip -d libduckdb
+
+   export DUCKDB_LIB_DIR=$PWD/libduckdb
+   export DUCKDB_INCLUDE_DIR=$DUCKDB_LIB_DIR
+   export DYLD_FALLBACK_LIBRARY_PATH=$DUCKDB_LIB_DIR
+
+   cargo build --examples
+   ```
+
+4. Setting `DUCKDB_DOWNLOAD_LIB=1` makes the build script download pre-built DuckDB binaries from GitHub Releases. This always links against the dynamic library in the archive (setting `DUCKDB_STATIC` has no effect), and it effectively automates the manual steps above. The archives are cached in `target/duckdb-download/<target>/<version>` and that directory is automatically added to the linker search path. The downloaded version always matches the DuckDB version encoded in the `libduckdb-sys` crate version.
+
+   ```shell
+   DUCKDB_DOWNLOAD_LIB=1 cargo test
+   ```
+
+5. Installing the DuckDB development packages will usually be all that is required, but
+   the build helpers for [pkg-config](https://github.com/alexcrichton/pkg-config-rs)
+   and [vcpkg](https://github.com/mcgoo/vcpkg-rs) have some additional configuration
+   options. The default when using vcpkg is to dynamically link,
+   which must be enabled by setting `VCPKGRS_DYNAMIC=1` environment variable before build.
+
+When none of the options above are used, the build script falls back to this discovery path and will emit the appropriate `cargo:rustc-link-lib` directives if DuckDB is found on your system.
+
+Cross-compiling with `bundled` is best-effort (not covered by CI): it compiles DuckDB from C++ source and so needs a working C++ cross-compiler for the target, not just the Rust toolchain. If you can't get one working, prefer one of the non-`bundled` options above (e.g. `DUCKDB_LIB_DIR` or `DUCKDB_DOWNLOAD_LIB=1`) and link a pre-built library for the target instead.
+
+### ICU extension and the bundled features
+
+When using the `bundled` feature, the ICU extension is not included due to crates.io's 10MB package size limit. This means some date/time operations (like `now() - interval '1 day'` or `ts::date` casts) will fail. You can load ICU at runtime:
+
+```rust,ignore
+conn.execute_batch("INSTALL icu; LOAD icu;")?;
+```
+
+Alternatively, link against a system libduckdb that was compiled with ICU (see build instructions above).
+
+If you are working from a duckdb-rs checkout, you can also use `bundled-cmake,icu` to compile ICU in through DuckDB's CMake build.
+
+### Binding generation
+
+We use [bindgen](https://crates.io/crates/bindgen) to generate the Rust
+declarations from DuckDB's C header file. `bindgen`
+[recommends](https://github.com/servo/rust-bindgen#library-usage-with-buildrs)
+running this as part of the build process for libraries that use it. We tried
+this briefly (`duckdb` 0.10.0, specifically), but it had some annoyances:
+
+- The build time for `libduckdb-sys` (and therefore `duckdb`) increased
+  dramatically.
+- Running `bindgen` requires a relatively recent version of Clang, which many
+  systems do not have installed by default.
+- Running `bindgen` also requires the DuckDB header file to be present.
+
+So we try to avoid running `bindgen` at build time by shipping
+pregenerated bindings for DuckDB.
+
+If you use the `bundled` feature, you will get pregenerated bindings for the
+bundled version of DuckDB. If you want to run `bindgen` at build time to
+produce your own bindings, use the `buildtime_bindgen` Cargo feature.
+
+## Thread safety
+
+A `Connection` is `Send` but not `Sync`: you may move it between threads, but you cannot share a single connection across threads at the same time. DuckDB does support concurrent access through _multiple_ connections to the same database (see [DuckDB's concurrency docs](https://duckdb.org/docs/current/connect/concurrency).
+
+For multi-threaded applications, give each thread its own connection. The simplest way is a connection pool via the `r2d2` feature:
+
+```rust,ignore
+use duckdb::{DuckdbConnectionManager, params};
+
+let manager = DuckdbConnectionManager::file("file.db")?;
+let pool = r2d2::Pool::new(manager)?;
+
+// Each worker checks out its own connection from the pool.
+let conn = pool.get()?;
+conn.execute("INSERT INTO foo (bar) VALUES (?)", params![1])?;
+```
+
+## Database client or extension?
+
+duckdb-rs covers two distinct use cases, and you normally pick exactly one:
+
+- **As a database client** (most common): embed DuckDB in your Rust application to run queries, as shown in the [Quickstart](#quickstart).
+- **For writing DuckDB extensions**: build a loadable `.duckdb_extension` that DuckDB loads at runtime. Enable the `loadable-extension` feature.
+
+Do **not** enable `loadable-extension` for a regular client application. It replaces DuckDB's normal C API functions with extension wrappers that are only initialized when DuckDB loads your extension. Outside an extension context, calls such as `Connection::open_in_memory()` then panic with `DuckDB API not initialized or DuckDB feature omitted`.
+
+## Building and loading extensions
+
+The [`hello-ext`](crates/duckdb/examples/hello-ext) example shows the extension API in action: it registers a `hello(name)` table function via the `loadable-extension` feature and the `duckdb_entrypoint_c_api` macro.
+
+`cargo build` alone does **not** produce a loadable extension though. DuckDB only loads files ending in `.duckdb_extension` that carry a metadata footer matching the target DuckDB version. A bare shared library fails with _The file is not a DuckDB extension. The metadata at the end of the file is invalid_. Appending that footer requires DuckDB's extension build tooling.
+
+So rather than wiring this up by hand, start from the official [extension-template-rs](https://github.com/duckdb/extension-template-rs) template for a complete, ready-to-build Rust extension. It handles the metadata step, platform/version detection, tests, and CI. Its `make debug` builds the shared library and then appends the footer, producing a `.duckdb_extension` you load with `duckdb -unsigned`.
+
+## Rust version compatibility
+
+duckdb-rs is built and tested with stable Rust, and keeps a rolling MSRV (minimum supported Rust version) that may only be updated when the encoded DuckDB major/minor version changes, on a need basis (e.g. project dependencies bump their MSRV or a particular Rust feature is useful for us). The new MSRV will be at least 6 months old. DuckDB patch updates and crate patch releases (e.g. `1.10500.0` to `1.10500.1`) are guaranteed to keep the same MSRV.
+
+## Contributing
+
+We welcome contributions! Take a look at [CONTRIBUTING.md](CONTRIBUTING.md) for more information.
+
+Join our [Discord](https://discord.gg/tcvwpjfnZx) to chat with the community in the #rust channel.
+
+## License
+
+Copyright (c) Stichting DuckDB Foundation
+
+Licensed under the [MIT license](LICENSE).
diff --git a/rust_hft/native/libduckdb-sys/build.rs b/rust_hft/native/libduckdb-sys/build.rs
new file mode 100644
index 000000000..325fe8a13
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/build.rs
@@ -0,0 +1,659 @@
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+/// Tells whether we're building for Windows. This is more suitable than a plain
+/// `cfg!(windows)`, since the latter does not properly handle cross-compilation
+///
+/// Note that there is no way to know at compile-time which system we'll be
+/// targeting, and this test must be made at run-time (of the build script) See
+/// https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-build-scripts
+fn win_target() -> bool {
+    std::env::var("CARGO_CFG_WINDOWS").is_ok()
+}
+
+/// Tells whether a given compiler will be used `compiler_name` is compared to
+/// the content of `CARGO_CFG_TARGET_ENV` (and is always lowercase)
+///
+/// See [`win_target`]
+fn is_compiler(compiler_name: &str) -> bool {
+    std::env::var("CARGO_CFG_TARGET_ENV").is_ok_and(|v| v == compiler_name)
+}
+
+fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let out_path = Path::new(&out_dir).join("bindgen.rs");
+    #[cfg(feature = "bundled")]
+    build_bundled_backend::main(&out_dir, &out_path);
+    #[cfg(not(feature = "bundled"))]
+    build_linked::main(&out_dir, &out_path)
+}
+
+#[cfg(all(feature = "bundled", not(feature = "bundled-cmake")))]
+mod build_bundled_cc;
+#[cfg(all(feature = "bundled", feature = "bundled-cmake"))]
+mod build_bundled_cmake;
+
+#[cfg(all(feature = "bundled", not(feature = "bundled-cmake")))]
+use crate::build_bundled_cc as build_bundled_backend;
+#[cfg(all(feature = "bundled", feature = "bundled-cmake"))]
+use crate::build_bundled_cmake as build_bundled_backend;
+
+#[cfg(feature = "bundled")]
+pub(crate) fn write_bindings(header_dir: &Path, out_path: &Path) {
+    #[cfg(feature = "buildtime_bindgen")]
+    {
+        use crate::{HeaderLocation, bindings};
+        let header = HeaderLocation::IncludeDir(header_dir.to_path_buf());
+        bindings::write_to_out_dir(header, out_path);
+    }
+
+    #[cfg(not(feature = "buildtime_bindgen"))]
+    {
+        let _ = header_dir;
+        copy_pregenerated_bindings(out_path);
+    }
+}
+
+/// Link the Windows system libraries DuckDB needs but that neither `cc` nor a
+/// static CMake link adds automatically. Mirrors DuckDB's `DUCKDB_SYSTEM_LIBS`
+/// (duckdb-sources/src/CMakeLists.txt) — keep in sync on submodule bumps.
+/// Callers apply their own `win_target()` gate.
+#[cfg(feature = "bundled")]
+pub(crate) fn link_windows_system_libs() {
+    println!("cargo:rustc-link-lib=dylib=ws2_32");
+    println!("cargo:rustc-link-lib=dylib=rstrtmgr");
+    if is_compiler("msvc") {
+        println!("cargo:rustc-link-lib=dylib=bcrypt");
+    } else {
+        println!("cargo:rustc-link-lib=dylib=stdc++");
+    }
+}
+
+#[cfg(not(feature = "buildtime_bindgen"))]
+fn copy_pregenerated_bindings(out_path: &Path) {
+    let bindings_path = if is_loadable_extension() {
+        "src/bindgen_bundled_version_loadable.rs"
+    } else {
+        "src/bindgen_bundled_version.rs"
+    };
+    println!("cargo:rerun-if-changed={bindings_path}");
+    std::fs::copy(bindings_path, out_path).expect("Could not copy bindings to output directory");
+}
+
+pub enum HeaderLocation {
+    IncludeDir(PathBuf),
+    HeaderPath(PathBuf),
+    Wrapper,
+}
+
+#[allow(dead_code)]
+fn is_loadable_extension() -> bool {
+    cfg!(feature = "loadable-extension")
+}
+
+#[allow(dead_code)]
+fn header_filename() -> &'static str {
+    if is_loadable_extension() {
+        "duckdb_extension.h"
+    } else {
+        "duckdb.h"
+    }
+}
+
+#[allow(dead_code)]
+impl HeaderLocation {
+    fn from_env(lib_dir: &Path) -> Self {
+        if let Ok(include_dir) = env::var("DUCKDB_INCLUDE_DIR") {
+            return HeaderLocation::IncludeDir(PathBuf::from(include_dir));
+        }
+        let header_path = lib_dir.join(header_filename());
+        if header_path.exists() {
+            HeaderLocation::IncludeDir(lib_dir.to_path_buf())
+        } else {
+            HeaderLocation::HeaderPath(header_path)
+        }
+    }
+
+    #[cfg(feature = "buildtime_bindgen")]
+    fn header_path(&self) -> PathBuf {
+        match self {
+            HeaderLocation::IncludeDir(path) => path.join(header_filename()),
+            HeaderLocation::HeaderPath(path) => path.clone(),
+            HeaderLocation::Wrapper => PathBuf::from(if is_loadable_extension() {
+                "wrapper_ext.h"
+            } else {
+                "wrapper.h"
+            }),
+        }
+    }
+
+    fn include_dir(&self) -> Option<&Path> {
+        match self {
+            HeaderLocation::IncludeDir(path) => Some(path),
+            HeaderLocation::HeaderPath(_) | HeaderLocation::Wrapper => None,
+        }
+    }
+}
+
+#[cfg(not(feature = "bundled"))]
+mod build_linked {
+    #[cfg(feature = "vcpkg")]
+    extern crate vcpkg;
+
+    #[cfg(feature = "buildtime_bindgen")]
+    use super::bindings;
+
+    use super::{HeaderLocation, is_compiler, is_loadable_extension, win_target};
+    use std::{env, path::Path};
+    #[cfg(feature = "download")]
+    use std::{fs, io, path::PathBuf};
+
+    pub fn main(out_dir: &str, out_path: &Path) {
+        // We need this to config the LD_LIBRARY_PATH
+        let header = find_duckdb(out_dir);
+
+        // Publish the resolved include directory so downstream crates
+        // that compile their own C/C++ code can read it from
+        // `DEP_DUCKDB_INCLUDE`. Wrapper-only mode (no explicit dir
+        // from env / vcpkg / pkg-config / download) intentionally
+        // skips the emission — there's no single directory to point
+        // at; the system header is on the default search path already.
+        if let Some(include_dir) = header.include_dir() {
+            println!("cargo:include={}", include_dir.display());
+        }
+
+        #[cfg(not(feature = "buildtime_bindgen"))]
+        super::copy_pregenerated_bindings(out_path);
+
+        #[cfg(feature = "buildtime_bindgen")]
+        bindings::write_to_out_dir(header, out_path);
+    }
+
+    fn link_directive() -> &'static str {
+        // If the user specifies DUCKDB_STATIC, do static
+        // linking, unless it's explicitly set to 0.
+        match env::var("DUCKDB_STATIC") {
+            Ok(v) if v != "0" => "static=duckdb_static",
+            _ => "dylib=duckdb",
+        }
+    }
+
+    fn emit_link_lib(link_directive: &str) {
+        if !is_loadable_extension() {
+            println!("cargo:rustc-link-lib={link_directive}");
+        }
+    }
+
+    #[cfg(feature = "pkg-config")]
+    fn duckdb_pkg_config() -> pkg_config::Config {
+        let mut config = pkg_config::Config::new();
+        if is_loadable_extension() {
+            config.cargo_metadata(false);
+        }
+        config
+    }
+
+    // Prints the necessary cargo link commands and returns the path to the header.
+    fn find_duckdb(_out_dir: &str) -> HeaderLocation {
+        println!("cargo:rerun-if-env-changed=DUCKDB_DOWNLOAD_LIB");
+        if !is_loadable_extension() {
+            println!("cargo:rerun-if-env-changed=DUCKDB_INCLUDE_DIR");
+            println!("cargo:rerun-if-env-changed=DUCKDB_LIB_DIR");
+            println!("cargo:rerun-if-env-changed=DUCKDB_STATIC");
+            if cfg!(feature = "vcpkg") && is_compiler("msvc") {
+                println!("cargo:rerun-if-env-changed=VCPKGRS_DYNAMIC");
+            }
+
+            // dependents can access `DEP_DUCKDB_LINK_TARGET` (`duckdb` being the
+            // `links=` value in our Cargo.toml) to get this value. This might be
+            // useful if you need to ensure whatever crypto library sqlcipher relies
+            // on is available, for example.
+            println!("cargo:link-target=duckdb");
+        }
+
+        if win_target() && cfg!(feature = "winduckdb") {
+            emit_link_lib("dylib=duckdb");
+            return HeaderLocation::Wrapper;
+        }
+        // Allow users to specify where to find DuckDB.
+        if let Ok(dir) = env::var("DUCKDB_LIB_DIR") {
+            println!("cargo:rustc-env=LD_LIBRARY_PATH={dir}");
+            // Try to use pkg-config to determine link commands
+            let pkgconfig_path = Path::new(&dir).join("pkgconfig");
+            unsafe { env::set_var("PKG_CONFIG_PATH", pkgconfig_path) };
+
+            #[cfg(feature = "pkg-config")]
+            let lib_found = duckdb_pkg_config().probe("duckdb").is_ok();
+            #[cfg(not(feature = "pkg-config"))]
+            let lib_found = false;
+
+            if !lib_found {
+                // Otherwise just emit the bare minimum link commands.
+                emit_link_lib(link_directive());
+                println!("cargo:rustc-link-search={dir}");
+            }
+
+            return HeaderLocation::from_env(Path::new(&dir));
+        }
+
+        if should_download_libduckdb() {
+            #[cfg(feature = "download")]
+            return download_libduckdb(_out_dir).unwrap_or_else(|err| panic!("Failed to download libduckdb: {err}"));
+            #[cfg(not(feature = "download"))]
+            panic!("DUCKDB_DOWNLOAD_LIB requires the libduckdb-sys/download feature");
+        }
+
+        if let Some(header) = try_vcpkg() {
+            return header;
+        }
+
+        // See if pkg-config can do everything for us.
+        #[cfg(feature = "pkg-config")]
+        {
+            match duckdb_pkg_config().print_system_libs(false).probe("duckdb") {
+                Ok(mut lib) => {
+                    if let Some(header) = lib.include_paths.pop() {
+                        HeaderLocation::IncludeDir(header)
+                    } else {
+                        HeaderLocation::Wrapper
+                    }
+                }
+                Err(_) => {
+                    // No env var set and pkg-config couldn't help; just output the link-lib
+                    // request and hope that the library exists on the system paths. We used to
+                    // output /usr/lib explicitly, but that can introduce other linking problems;
+                    // see https://github.com/rusqlite/rusqlite/issues/207.
+                    emit_link_lib(link_directive());
+                    HeaderLocation::Wrapper
+                }
+            }
+        }
+        #[cfg(not(feature = "pkg-config"))]
+        {
+            // No pkg-config available; just output the link-lib request and hope
+            // that the library exists on the system paths.
+            emit_link_lib(link_directive());
+            HeaderLocation::Wrapper
+        }
+    }
+
+    fn try_vcpkg() -> Option<HeaderLocation> {
+        #[cfg(feature = "vcpkg")]
+        if is_compiler("msvc") {
+            // See if vcpkg can find it.
+            if let Ok(mut lib) = vcpkg::Config::new().probe("duckdb") {
+                if let Some(header) = lib.include_paths.pop() {
+                    return Some(HeaderLocation::IncludeDir(header));
+                }
+            }
+        }
+        None
+    }
+
+    fn should_download_libduckdb() -> bool {
+        env::var("DUCKDB_DOWNLOAD_LIB")
+            .map(|value| matches!(value.to_ascii_lowercase().as_str(), "1" | "true"))
+            .unwrap_or(false)
+    }
+
+    #[cfg(feature = "download")]
+    fn download_libduckdb(out_dir: &str) -> Result<HeaderLocation, Box<dyn std::error::Error>> {
+        let target = env::var("TARGET")?;
+        let archive = LibduckdbArchive::for_target(&target)
+            .ok_or_else(|| format!("No pre-built libduckdb available for target '{target}'"))?;
+
+        let version = duckdb_version_from_pkg_version(env!("CARGO_PKG_VERSION"));
+
+        // Cache downloads in target/duckdb-download/<target>/<version> so successive builds reuse them
+        let download_dir = workspace_download_dir(out_dir)?.join(&target).join(&version);
+        fs::create_dir_all(&download_dir)?;
+
+        let archive_path = download_dir.join(archive.archive_name);
+        let lib_marker = download_dir.join(archive.dynamic_lib);
+
+        if lib_marker.exists() {
+            println!("cargo:warning=Reusing libduckdb from {}", download_dir.display());
+        } else {
+            let client = http_client()?;
+            let url = archive.download_url(&version);
+            ensure_libduckdb(&client, &url, &archive_path)?;
+            extract_libduckdb(&archive_path, &download_dir)?;
+            if !lib_marker.exists() {
+                return Err(format!(
+                    "Downloaded archive did not contain expected library '{}'",
+                    archive.dynamic_lib
+                )
+                .into());
+            }
+        }
+
+        configure_link_search(&download_dir);
+
+        copy_libduckdb(&download_dir, archive.dynamic_lib, out_dir)?;
+
+        Ok(HeaderLocation::IncludeDir(download_dir))
+    }
+
+    #[cfg(feature = "download")]
+    fn configure_link_search(lib_dir: &Path) {
+        println!("cargo:rustc-link-search=native={}", lib_dir.display());
+        emit_link_lib(link_directive());
+        if !win_target() {
+            println!("cargo:rustc-link-arg=-Wl,-rpath,{}", lib_dir.display());
+        }
+    }
+
+    // Ensures the libduckdb archive exists: reuses an existing zip or
+    // downloads it into a temp file and atomically renames it into place.
+    #[cfg(feature = "download")]
+    fn ensure_libduckdb(
+        client: &reqwest::blocking::Client,
+        url: &str,
+        archive_path: &Path,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        if archive_path.exists() {
+            println!("cargo:warning=libduckdb already present at {}", archive_path.display());
+            return Ok(());
+        }
+        let tmp_path = archive_path.with_extension("download");
+        if let Some(parent) = archive_path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let mut response = client.get(url).send()?.error_for_status()?;
+        let mut tmp_file = fs::File::create(&tmp_path)?;
+        io::copy(&mut response, &mut tmp_file)?;
+        fs::rename(&tmp_path, archive_path)?;
+        println!("cargo:warning=Downloaded libduckdb from {url}");
+        Ok(())
+    }
+
+    #[cfg(feature = "download")]
+    fn extract_libduckdb(archive_path: &Path, destination: &Path) -> Result<(), Box<dyn std::error::Error>> {
+        let file = fs::File::open(archive_path)?;
+        let mut archive = zip::ZipArchive::new(file)?;
+        archive.extract(destination)?;
+        println!("cargo:warning=Extracted libduckdb to {}", destination.display());
+        Ok(())
+    }
+
+    // Copy libduckdb into target/<profile>/deps so executables/tests can load it via
+    // the default Cargo rpath, just like when DUCKDB_LIB_DIR is set.
+    #[cfg(feature = "download")]
+    fn copy_libduckdb(
+        download_dir: &Path,
+        lib_filename: &str,
+        out_dir: &str,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let Some(deps_dir) = profile_deps_dir(out_dir) else {
+            return Err("Could not determine target/deps directory for runtime lib copy".into());
+        };
+        fs::create_dir_all(&deps_dir)?;
+        let source = download_dir.join(lib_filename);
+        let dest = deps_dir.join(lib_filename);
+        if dest.exists() {
+            fs::remove_file(&dest)?;
+        }
+        fs::copy(&source, &dest)?;
+        println!("cargo:warning=Copied libduckdb to {}", dest.display());
+        Ok(())
+    }
+
+    // Finds target/ so downloads survive rebuilds. Respects CARGO_TARGET_DIR if set.
+    #[cfg(feature = "download")]
+    fn workspace_download_dir(out_dir: &str) -> Result<PathBuf, Box<dyn std::error::Error>> {
+        if let Ok(dir) = env::var("CARGO_TARGET_DIR") {
+            return Ok(PathBuf::from(dir).join("duckdb-download"));
+        }
+        let target_root = Path::new(out_dir)
+            .ancestors()
+            .find(|ancestor| {
+                ancestor
+                    .file_name()
+                    .and_then(|name| name.to_str())
+                    .is_some_and(|name| name == "target")
+            })
+            .map(Path::to_path_buf)
+            .unwrap_or_else(|| PathBuf::from("target"));
+        Ok(target_root.join("duckdb-download"))
+    }
+
+    #[cfg(feature = "download")]
+    fn duckdb_version_from_pkg_version(pkg_version: &str) -> String {
+        // duckdb-rs uses 1.MAJOR_MINOR_PATCH.x, e.g. DuckDB 1.5.0 => duckdb-rs 1.10500.x.
+        let encoded = pkg_version
+            .split('.')
+            .nth(1)
+            .expect("CARGO_PKG_VERSION should use the documented 1.MAJOR_MINOR_PATCH.x format")
+            .parse::<u32>()
+            .expect("CARGO_PKG_VERSION should encode the DuckDB version as an integer in its second component");
+        let duckdb_major = encoded / 10_000;
+        let duckdb_minor = (encoded / 100) % 100;
+        let duckdb_patch = encoded % 100;
+        format!("{duckdb_major}.{duckdb_minor}.{duckdb_patch}")
+    }
+
+    // Mirrors Cargo's actual target/<triple>/<profile>/deps (or target/<profile>/deps)
+    // layout by deriving it from OUT_DIR.
+    #[cfg(feature = "download")]
+    fn profile_deps_dir(out_dir: &str) -> Option<PathBuf> {
+        let build_dir = Path::new(out_dir).ancestors().find(|ancestor| {
+            ancestor
+                .file_name()
+                .and_then(|name| name.to_str())
+                .is_some_and(|name| name == "build")
+        })?;
+        let profile_dir = build_dir.parent()?;
+        Some(profile_dir.join("deps"))
+    }
+
+    #[cfg(feature = "download")]
+    struct LibduckdbArchive {
+        archive_name: &'static str,
+        dynamic_lib: &'static str,
+    }
+
+    #[cfg(feature = "download")]
+    impl LibduckdbArchive {
+        fn for_target(target: &str) -> Option<Self> {
+            match target {
+                t if t.ends_with("apple-darwin") => Some(Self {
+                    archive_name: "libduckdb-osx-universal.zip",
+                    dynamic_lib: "libduckdb.dylib",
+                }),
+                "x86_64-unknown-linux-gnu" => Some(Self {
+                    archive_name: "libduckdb-linux-amd64.zip",
+                    dynamic_lib: "libduckdb.so",
+                }),
+                "aarch64-unknown-linux-gnu" => Some(Self {
+                    archive_name: "libduckdb-linux-arm64.zip",
+                    dynamic_lib: "libduckdb.so",
+                }),
+                "x86_64-pc-windows-msvc" => Some(Self {
+                    archive_name: "libduckdb-windows-amd64.zip",
+                    dynamic_lib: "duckdb.dll",
+                }),
+                "aarch64-pc-windows-msvc" => Some(Self {
+                    archive_name: "libduckdb-windows-arm64.zip",
+                    dynamic_lib: "duckdb.dll",
+                }),
+                _ => None,
+            }
+        }
+
+        fn download_url(&self, version: &str) -> String {
+            format!(
+                "https://github.com/duckdb/duckdb/releases/download/v{version}/{}",
+                self.archive_name
+            )
+        }
+    }
+
+    #[cfg(feature = "download")]
+    fn http_client() -> Result<reqwest::blocking::Client, reqwest::Error> {
+        let timeout = env::var("CARGO_HTTP_TIMEOUT")
+            .or_else(|_| env::var("HTTP_TIMEOUT"))
+            .ok()
+            .and_then(|value| value.parse().ok())
+            .unwrap_or(90);
+        reqwest::blocking::Client::builder()
+            .timeout(std::time::Duration::from_secs(timeout))
+            .build()
+    }
+}
+
+#[cfg(feature = "buildtime_bindgen")]
+mod bindings {
+    use super::{HeaderLocation, is_loadable_extension};
+
+    use std::{fs::OpenOptions, io::Write, path::Path};
+
+    #[cfg(feature = "loadable-extension")]
+    fn extract_method(ty: &syn::Type) -> Option<&syn::TypeBareFn> {
+        let syn::Type::Path(type_path) = ty else {
+            return None;
+        };
+        let segment = type_path.path.segments.last()?;
+        let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
+            return None;
+        };
+        let Some(syn::GenericArgument::Type(ty)) = args.args.first() else {
+            return None;
+        };
+        let syn::Type::BareFn(method) = ty else {
+            return None;
+        };
+        Some(method)
+    }
+
+    #[cfg(feature = "loadable-extension")]
+    fn generate_functions(mut output: String) -> String {
+        // (1) parse sqlite3_api_routines fields from bindgen output
+        let ast: syn::File = syn::parse_str(&output).expect("could not parse bindgen output");
+        let duckdb_ext_api_v1: syn::ItemStruct = ast
+            .items
+            .into_iter()
+            .find_map(|i| {
+                if let syn::Item::Struct(s) = i {
+                    if s.ident == "duckdb_ext_api_v1" { Some(s) } else { None }
+                } else {
+                    None
+                }
+            })
+            .expect("could not find duckdb_ext_api_v1");
+
+        let p_api = quote::format_ident!("p_api");
+        let mut stores = Vec::new();
+
+        for field in duckdb_ext_api_v1.fields {
+            let ident = field.ident.expect("unnamed field");
+            let span = ident.span();
+            let function_name = ident.to_string();
+            let ptr_name = syn::Ident::new(format!("__{}", function_name.to_uppercase()).as_ref(), span);
+
+            // Create syntax name
+            let duckdb_fn_name = syn::Ident::new(&function_name, span);
+
+            let method = extract_method(&field.ty).unwrap_or_else(|| panic!("unexpected type for {function_name}"));
+
+            let arg_names: syn::punctuated::Punctuated<&syn::Ident, syn::token::Comma> =
+                method.inputs.iter().map(|i| &i.name.as_ref().unwrap().0).collect();
+
+            let args = &method.inputs;
+
+            let ty = &method.output;
+
+            let tokens = quote::quote! {
+                static #ptr_name: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+                pub unsafe fn #duckdb_fn_name(#args) #ty {
+                    let function_ptr = #ptr_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(#args) #ty = ::std::mem::transmute(function_ptr);
+                    (fun)(#arg_names)
+                }
+            };
+
+            output.push_str(&prettyplease::unparse(
+                &syn::parse2(tokens).expect("could not parse quote output"),
+            ));
+
+            output.push('\n');
+
+            stores.push(quote::quote! {
+                if let Some(fun) = (*#p_api).#ident {
+                    #ptr_name.store(
+                        fun as usize as *mut (),
+                        ::std::sync::atomic::Ordering::Release,
+                    );
+                }
+            });
+        }
+
+        // (3) generate rust code similar to DUCKDB_EXTENSION_API_INIT macro
+        let tokens = quote::quote! {
+            /// Like DUCKDB_EXTENSION_API_INIT macro
+            pub unsafe fn duckdb_rs_extension_api_init(info: duckdb_extension_info, access: *const duckdb_extension_access, version: &str) -> ::std::result::Result<bool, &'static str> {
+                let version_c_string = std::ffi::CString::new(version).unwrap();
+                let #p_api = (*access).get_api.unwrap()(info, version_c_string.as_ptr()) as *const duckdb_ext_api_v1;
+                if #p_api.is_null() {
+                    // get_api can return a nullptr when the version is not matched. In this case, we don't need to set
+                    // an error, but can instead just stop the initialization process and let duckdb handle things
+                    return Ok(false);
+                }
+                #(#stores)*
+                Ok(true)
+            }
+        };
+        output.push_str(&prettyplease::unparse(
+            &syn::parse2(tokens).expect("could not parse quote output"),
+        ));
+        output.push('\n');
+        output
+    }
+
+    pub fn write_to_out_dir(header: HeaderLocation, out_path: &Path) {
+        let header = header.header_path().to_string_lossy().into_owned();
+        let mut output = Vec::new();
+        let mut builder = bindgen::builder();
+
+        if is_loadable_extension() {
+            builder = builder.ignore_functions();
+        }
+
+        // ONLY generate bindings for symbols containing "duckdb" in their name
+        // and for the type `idx_t`
+        // We have to pass DDUCKDB_EXTENSION_API_VERSION_UNSTABLE for now,
+        // until we figure out how to feature gate the generated API
+        builder
+            .trust_clang_mangling(false)
+            .header(header.clone())
+            .allowlist_item(r#"(\w*duckdb\w*)"#)
+            .allowlist_type("idx_t")
+            // Use the concrete ABI layouts from src/arrow_c_data.rs.
+            .blocklist_type("ArrowArray")
+            .blocklist_type("ArrowSchema")
+            .layout_tests(false) // causes problems on WASM builds
+            .clang_arg("-DDUCKDB_EXTENSION_API_VERSION_UNSTABLE")
+            .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+            .generate()
+            .unwrap_or_else(|_| panic!("could not run bindgen on header {header}"))
+            .write(Box::new(&mut output))
+            .expect("could not write output of bindgen");
+
+        let output = String::from_utf8(output).expect("bindgen output was not UTF-8?!");
+
+        #[cfg(feature = "loadable-extension")]
+        let output = generate_functions(output);
+
+        let mut file = OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(out_path)
+            .unwrap_or_else(|_| panic!("Could not write to {out_path:?}"));
+
+        file.write_all(output.as_bytes())
+            .unwrap_or_else(|_| panic!("Could not write to {out_path:?}"));
+    }
+}
diff --git a/rust_hft/native/libduckdb-sys/build_bundled_cc.rs b/rust_hft/native/libduckdb-sys/build_bundled_cc.rs
new file mode 100644
index 000000000..7c9e0e22a
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/build_bundled_cc.rs
@@ -0,0 +1,147 @@
+use crate::{is_compiler, link_windows_system_libs, win_target, write_bindings};
+use std::{
+    collections::{HashMap, HashSet},
+    path::Path,
+};
+
+#[derive(serde::Deserialize)]
+struct Sources {
+    cpp_files: HashSet<String>,
+    include_dirs: HashSet<String>,
+}
+
+#[derive(serde::Deserialize)]
+struct Manifest {
+    base: Sources,
+    extensions: HashMap<String, Sources>,
+}
+
+fn add_extension(
+    manifest: &Manifest,
+    extension: &str,
+    cpp_files: &mut HashSet<String>,
+    include_dirs: &mut HashSet<String>,
+) {
+    let sources = manifest.extensions.get(extension).unwrap_or_else(|| {
+        let mut available = manifest.extensions.keys().cloned().collect::<Vec<_>>();
+        available.sort();
+        panic!(
+            "extension `{extension}` is missing from duckdb manifest; available extensions: {}",
+            available.join(", ")
+        );
+    });
+    cpp_files.extend(sources.cpp_files.clone());
+    include_dirs.extend(sources.include_dirs.clone());
+}
+
+fn extension_enabled(extension: &str) -> bool {
+    // Review build_bundled_cmake::enabled_extensions when changing this gate;
+    // the backend mechanisms and supported extension sets intentionally differ.
+    extension == "core_functions"
+        || (extension == "parquet" && cfg!(feature = "parquet"))
+        || (extension == "json" && cfg!(feature = "json"))
+}
+
+fn untar_archive(out_dir: &str) {
+    let path = "duckdb.tar.gz";
+
+    let tar_gz = std::fs::File::open(path).expect("archive file");
+    let tar = flate2::read::GzDecoder::new(tar_gz);
+    let mut archive = tar::Archive::new(tar);
+    // These archives are generated for reproducibility, not source mtimes.
+    // Skipping mtime restoration also avoids Windows SetFileTime failures on
+    // filesystems such as FAT32, which cannot represent Unix epoch mtimes.
+    archive.set_preserve_mtime(false);
+    archive.unpack(out_dir).expect("archive");
+}
+
+pub fn main(out_dir: &str, out_path: &Path) {
+    untar_archive(out_dir);
+
+    let include_path = Path::new(out_dir).join("duckdb/src/include");
+    write_bindings(&include_path, out_path);
+
+    // Publish the include directory so downstream crates that compile
+    // their own C/C++ code (e.g. extension shims that #include
+    // "duckdb.hpp") can pick it up from `DEP_DUCKDB_INCLUDE` without
+    // having to glob the target tree. Requires `links = "duckdb"` in
+    // the package manifest.
+    println!("cargo:include={}", include_path.display());
+
+    let manifest_file = std::fs::File::open(format!("{out_dir}/duckdb/manifest.json")).expect("manifest file");
+    let manifest: Manifest = serde_json::from_reader(manifest_file).expect("reading manifest file");
+
+    let mut cpp_files = HashSet::new();
+    let mut include_dirs = HashSet::new();
+    let mut extensions = manifest
+        .extensions
+        .keys()
+        .filter(|name| extension_enabled(name))
+        .cloned()
+        .collect::<Vec<String>>();
+    extensions.sort();
+
+    cpp_files.extend(manifest.base.cpp_files.clone());
+    include_dirs.extend(manifest.base.include_dirs.iter().cloned());
+
+    let mut cfg = cc::Build::new();
+
+    for extension in &extensions {
+        add_extension(&manifest, extension, &mut cpp_files, &mut include_dirs);
+        cfg.define(
+            &format!("DUCKDB_EXTENSION_{}_LINKED", extension.to_uppercase()),
+            Some("1"),
+        );
+    }
+    cfg.define("DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT", "1");
+    cfg.define("DUCKDB_EXTENSION_AUTOLOAD_DEFAULT", "1");
+
+    println!("cargo:rerun-if-changed=duckdb.tar.gz");
+
+    cfg.include("duckdb");
+    cfg.includes(include_dirs.iter().map(|dir| format!("{out_dir}/duckdb/{dir}")));
+
+    let mut cpp_files_vec: Vec<String> = cpp_files.into_iter().collect();
+    cpp_files_vec.sort();
+    for f in cpp_files_vec.into_iter().map(|file| format!("{out_dir}/{file}")) {
+        cfg.file(f);
+    }
+
+    cfg.cpp(true)
+        .flag_if_supported("-std=c++11")
+        .flag_if_supported("/utf-8")
+        .flag_if_supported("/bigobj")
+        .warnings(false)
+        .flag_if_supported("-w");
+
+    // Enable C++ exceptions on MSVC: without /EHsc, exception handling is off, the
+    // C API's try/catch blocks are inert, and a thrown exception (e.g. invalid-UTF-8
+    // CSV read) aborts with STATUS_STACK_BUFFER_OVERRUN (#774). Hard flag, not
+    // flag_if_supported, so a spurious probe miss can't silently drop it. gcc/clang
+    // enable exceptions by default and reject /EHsc, so gate on MSVC. Mirrors
+    // build_bundled_cmake.rs.
+    if win_target() && is_compiler("msvc") {
+        cfg.flag("/EHsc");
+    }
+
+    let is_debug = match std::env::var("DEBUG") {
+        Ok(v) => v != "false" && v != "0",
+        Err(_) => false,
+    };
+    if !is_debug {
+        cfg.define("NDEBUG", None);
+    }
+
+    if win_target() {
+        cfg.define("DUCKDB_BUILD_LIBRARY", None);
+    }
+    cfg.compile("duckdb");
+
+    // `cc` does not link DuckDB's Windows system libs automatically (e.g. unresolved
+    // `RmStartSession` from the Restart Manager). See link_windows_system_libs.
+    if win_target() {
+        link_windows_system_libs();
+    }
+
+    println!("cargo:lib_dir={out_dir}");
+}
diff --git a/rust_hft/native/libduckdb-sys/build_bundled_cmake.rs b/rust_hft/native/libduckdb-sys/build_bundled_cmake.rs
new file mode 100644
index 000000000..49194d0ec
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/build_bundled_cmake.rs
@@ -0,0 +1,496 @@
+use crate::{is_compiler, link_windows_system_libs, win_target, write_bindings};
+use std::{
+    collections::BTreeSet,
+    env::{self, VarError},
+    fs, io,
+    path::{Path, PathBuf},
+};
+
+struct Generator {
+    name: Option<String>,
+    out_dir: PathBuf,
+    make_program: Option<String>,
+}
+
+pub fn main(out_dir: &str, out_path: &Path) {
+    let source_dir = Path::new("duckdb-sources");
+    let cmake_lists = source_dir.join("CMakeLists.txt");
+    if !cmake_lists.exists() {
+        panic!(
+            "`bundled-cmake` requires a duckdb-rs checkout with DuckDB sources at {}",
+            cmake_lists.display()
+        );
+    }
+
+    println!("cargo:rerun-if-changed={}", source_dir.display());
+    println!("cargo:rerun-if-env-changed=DUCKDB_EXTENSION_CONFIGS");
+    println!("cargo:rerun-if-env-changed=DUCKDB_CMAKE_BUILD_TYPE");
+    println!("cargo:rerun-if-env-changed=DUCKDB_DISABLE_UNITY");
+    println!("cargo:rerun-if-env-changed=DUCKDB_DISABLE_JEMALLOC");
+    println!("cargo:rerun-if-env-changed=DUCKDB_DISABLE_EXTENSION_LOAD");
+    println!("cargo:rerun-if-env-changed=DISABLE_EXTENSION_LOAD");
+    println!("cargo:rerun-if-env-changed=CMAKE_BUILD_TYPE");
+    println!("cargo:rerun-if-env-changed=CMAKE_GENERATOR");
+    println!("cargo:rerun-if-env-changed=CMAKE_C_COMPILER_LAUNCHER");
+    println!("cargo:rerun-if-env-changed=CMAKE_CXX_COMPILER_LAUNCHER");
+    println!("cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET");
+
+    let include_path = source_dir.join("src/include").canonicalize().unwrap();
+    write_bindings(&include_path, out_path);
+
+    // Publish the include directory so downstream crates that compile
+    // their own C/C++ code can read it from `DEP_DUCKDB_INCLUDE`.
+    // See the matching emission in build_bundled_cc.rs.
+    println!("cargo:include={}", include_path.display());
+
+    if let Some(configs) = env_var("DUCKDB_EXTENSION_CONFIGS") {
+        if !configs.trim().is_empty() {
+            panic!(
+                "DUCKDB_EXTENSION_CONFIGS is not yet supported by bundled-cmake because additional static extension libraries are not auto-linked"
+            );
+        }
+    }
+
+    let cmake_build_type = cmake_build_type();
+    let generator = select_generator(out_dir);
+    let mut config = cmake::Config::new(source_dir);
+    config.out_dir(&generator.out_dir);
+    if let Some(generator_name) = generator.name.as_deref() {
+        config.generator(generator_name);
+    }
+    if let Some(make_program) = generator.make_program.as_deref() {
+        config.define("CMAKE_MAKE_PROGRAM", make_program);
+    }
+    configure_macos_deployment_target(&mut config);
+    config
+        .profile(&cmake_build_type)
+        .define("BUILD_UNITTESTS", "0")
+        .define("BUILD_SHELL", "0")
+        .define("CMAKE_INSTALL_LIBDIR", "lib")
+        .define("CMAKE_C_FLAGS_INIT", warning_suppression_flag())
+        .define("CMAKE_CXX_FLAGS_INIT", warning_suppression_flag());
+
+    // Re-enable C++ exceptions on MSVC. The cmake crate makes its `cxxflag`s the
+    // source of -DCMAKE_CXX_FLAGS, replacing CMake's default (which includes /EHsc),
+    // so exception handling ends up effectively off: a thrown exception (e.g.
+    // invalid-UTF-8 CSV read) then aborts with STATUS_STACK_BUFFER_OVERRUN (#774).
+    //
+    // Don't `config.define("CMAKE_CXX_FLAGS", ..)` here: it overrides the cxxflag
+    // above and silently drops /EHsc, reintroducing #774.
+    // Mirrors build_bundled_cc.rs; gcc/clang enable exceptions by default.
+    if win_target() && is_compiler("msvc") {
+        config.cxxflag("/EHsc");
+    }
+
+    // Unity builds (DuckDB's default) combine .cpp files into fewer translation
+    // units and compile significantly faster. Allow opting out for debugging.
+    // Always set explicitly so the CMake cache doesn't keep a stale value.
+    let disable_unity = env_flag("DUCKDB_DISABLE_UNITY");
+    config.define("DISABLE_UNITY", if disable_unity { "1" } else { "0" });
+
+    // Always set explicitly so the CMake cache does not keep a stale value when
+    // the environment variable changes between builds.
+    let disable_extension_load = env_flag_aliases(&["DUCKDB_DISABLE_EXTENSION_LOAD", "DISABLE_EXTENSION_LOAD"]);
+    config.define("DISABLE_EXTENSION_LOAD", if disable_extension_load { "1" } else { "0" });
+
+    // Forward compiler launcher for sccache/ccache integration.
+    for var in ["CMAKE_C_COMPILER_LAUNCHER", "CMAKE_CXX_COMPILER_LAUNCHER"] {
+        if let Some(launcher) = env_var(var) {
+            config.define(var, &launcher);
+        }
+    }
+
+    let enabled_extensions = enabled_extensions();
+    if !enabled_extensions.is_empty() {
+        config.define("BUILD_EXTENSIONS", enabled_extensions.join(";"));
+    }
+
+    // Always set explicitly so old CMake caches do not keep stale allocator
+    // state. By default this enables jemalloc on DuckDB's supported 64-bit,
+    // non-musl Linux targets and remains a no-op elsewhere. The env var is an
+    // escape hatch back to DuckDB's standard allocator.
+    let disable_jemalloc = env_flag("DUCKDB_DISABLE_JEMALLOC");
+    config.define("SKIP_EXTENSIONS", "");
+    config.define("ENABLE_JEMALLOC", if disable_jemalloc { "OFF" } else { "ON" });
+
+    // Upstream CMake defaults these to OFF, but duckdb-rs `bundled` has historically
+    // shipped with both enabled. Keep `bundled-cmake` aligned with `bundled` unless
+    // extension loading is compiled out entirely.
+    config
+        .define(
+            "ENABLE_EXTENSION_AUTOLOADING",
+            if disable_extension_load { "0" } else { "1" },
+        )
+        .define(
+            "ENABLE_EXTENSION_AUTOINSTALL",
+            if disable_extension_load { "0" } else { "1" },
+        );
+
+    // Windows MAX_PATH caveat: this build emits very deep object paths (Ninja ignores
+    // CMAKE_OBJECT_PATH_MAX), so a deep OUT_DIR can exceed 260 chars and fail late with
+    // `C1083: Cannot open compiler generated file: ''`. The build script can't move
+    // OUT_DIR — shorten the path (short CARGO_TARGET_DIR, drop `--target`, or check out
+    // nearer the drive root).
+    let dst = config.build();
+    let lib_dir = dst.join("lib");
+    validate_extension_libraries(&lib_dir, &cmake_build_type, &enabled_extensions);
+    println!("cargo:rustc-link-search=native={}", lib_dir.display());
+    // Emit in dependents-before-dependencies order for single-pass linkers:
+    // loader → extensions → duckdb_static (which satisfies all core symbols).
+    link_static_library(&lib_dir, &cmake_build_type, "duckdb_generated_extension_loader");
+    link_static_library(&lib_dir, &cmake_build_type, "core_functions_extension");
+    for extension in enabled_extensions {
+        link_static_library(&lib_dir, &cmake_build_type, &format!("{extension}_extension"));
+    }
+    link_static_library(&lib_dir, &cmake_build_type, "duckdb_static");
+    link_system_libs();
+    println!("cargo:lib_dir={}", lib_dir.display());
+}
+
+fn cmake_build_type() -> String {
+    for var in ["DUCKDB_CMAKE_BUILD_TYPE", "CMAKE_BUILD_TYPE"] {
+        if let Some(value) = env_var(var).filter(|v| !v.trim().is_empty()) {
+            let value = validate_cmake_build_type(&value);
+            cargo_warning(&format!("bundled-cmake build type: {value} (from {var})"));
+            return value;
+        }
+    }
+    cargo_warning("bundled-cmake build type: Release (default)");
+    "Release".to_owned()
+}
+
+fn validate_cmake_build_type(value: &str) -> String {
+    match value {
+        "Debug" | "Release" | "RelWithDebInfo" | "MinSizeRel" => value.to_owned(),
+        _ => {
+            panic!("unsupported CMake build type `{value}`; expected one of Debug, Release, RelWithDebInfo, MinSizeRel")
+        }
+    }
+}
+
+fn select_generator(out_dir: &str) -> Generator {
+    let out_dir = PathBuf::from(out_dir);
+    if let Some(generator) = env_var("CMAKE_GENERATOR").filter(|value| !value.trim().is_empty()) {
+        let needs_ninja = generator.contains("Ninja");
+        let (make_program, probe_error) = if needs_ninja {
+            find_program(&["ninja", "ninja-build"])
+        } else {
+            (None, None)
+        };
+        if needs_ninja && make_program.is_none() {
+            let suffix = probe_error
+                .map(|error| format!(" (probe error: {error})"))
+                .unwrap_or_default();
+            panic!(
+                "CMAKE_GENERATOR={generator} requires `ninja` or `ninja-build` on PATH, but neither was found{suffix}"
+            );
+        }
+        cargo_warning(&format!("bundled-cmake generator: {generator} (from CMAKE_GENERATOR)"));
+        return Generator {
+            out_dir: out_dir.join(format!("cmake-{}", sanitize_path_component(&generator))),
+            name: Some(generator),
+            make_program,
+        };
+    }
+
+    let (ninja_program, probe_error) = find_program(&["ninja", "ninja-build"]);
+    if let Some(ninja) = ninja_program {
+        cargo_warning(&format!("bundled-cmake generator: Ninja (autodetected via {ninja})"));
+        Generator {
+            out_dir: out_dir.join("cmake-ninja"),
+            name: Some("Ninja".to_string()),
+            make_program: Some(ninja),
+        }
+    } else {
+        if let Some(probe_error) = probe_error {
+            cargo_warning(&format!(
+                "failed to probe for bundled-cmake generator detection (`ninja`/`ninja-build`): {probe_error}"
+            ));
+        }
+        cargo_warning("bundled-cmake generator: default CMake generator (ninja not detected)");
+        Generator {
+            out_dir: out_dir.join("cmake-default"),
+            name: None,
+            make_program: None,
+        }
+    }
+}
+
+fn warning_suppression_flag() -> &'static str {
+    if win_target() && is_compiler("msvc") {
+        "/w"
+    } else {
+        "-w"
+    }
+}
+
+fn configure_macos_deployment_target(config: &mut cmake::Config) {
+    if env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("macos") {
+        return;
+    }
+
+    let target_arch_env =
+        env::var("CARGO_CFG_TARGET_ARCH").expect("Cargo should set CARGO_CFG_TARGET_ARCH for macOS builds");
+    let (target_arch, default_deployment_target) = match target_arch_env.as_str() {
+        "aarch64" => ("arm64", "11.0"),
+        "x86_64" => ("x86_64", "10.15"),
+        other => {
+            panic!("bundled-cmake: unsupported macOS CARGO_CFG_TARGET_ARCH `{other}`; expected `aarch64` or `x86_64`")
+        }
+    };
+
+    let deployment_target = env_var("MACOSX_DEPLOYMENT_TARGET")
+        .filter(|value| !value.trim().is_empty())
+        .unwrap_or_else(|| default_deployment_target.to_string());
+    cargo_warning(&format!(
+        "bundled-cmake macOS deployment target: {deployment_target} ({target_arch})"
+    ));
+    config.define("CMAKE_OSX_DEPLOYMENT_TARGET", &deployment_target);
+    config.define("CMAKE_OSX_ARCHITECTURES", target_arch);
+}
+
+fn find_program(candidates: &[&str]) -> (Option<String>, Option<which::Error>) {
+    let mut last_error = None;
+    for candidate in candidates {
+        match which::which(candidate) {
+            Ok(path) => return (Some(path.display().to_string()), None),
+            Err(which::Error::CannotFindBinaryPath) => {}
+            Err(err) => {
+                last_error = Some(err);
+            }
+        }
+    }
+    (None, last_error)
+}
+
+fn env_var(name: &str) -> Option<String> {
+    match env::var(name) {
+        Ok(value) => Some(value),
+        Err(VarError::NotPresent) => None,
+        Err(VarError::NotUnicode(_)) => {
+            panic!("bundled-cmake expects a valid UTF-8 value for environment variable `{name}`")
+        }
+    }
+}
+
+fn parse_env_flag(name: &str) -> Option<bool> {
+    match env_var(name).as_deref() {
+        Some("1" | "true" | "on" | "yes") => Some(true),
+        Some("0" | "false" | "off" | "no") => Some(false),
+        Some(other) => {
+            cargo_warning(&format!(
+                "Ignoring unsupported {name} value {other:?}; expected true/false or 1/0, yes/no, on/off"
+            ));
+            None
+        }
+        None => None,
+    }
+}
+
+fn env_flag(name: &str) -> bool {
+    parse_env_flag(name).unwrap_or(false)
+}
+
+fn env_flag_aliases(names: &[&str]) -> bool {
+    let mut values = Vec::new();
+    for name in names {
+        if let Some(value) = parse_env_flag(name) {
+            values.push((*name, value));
+        }
+    }
+    let Some((selected_name, selected_value)) = values.first().copied() else {
+        return false;
+    };
+    if values.iter().any(|(_, value)| *value != selected_value) {
+        let sources = values
+            .iter()
+            .map(|(name, value)| format!("{name}={}", if *value { 1 } else { 0 }))
+            .collect::<Vec<_>>()
+            .join(", ");
+        cargo_warning(&format!(
+            "Conflicting values for equivalent environment variables ({sources}); using {selected_name}"
+        ));
+    }
+    selected_value
+}
+
+fn sanitize_path_component(input: &str) -> String {
+    input
+        .chars()
+        .map(|ch| {
+            if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' {
+                ch
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}
+
+fn validate_extension_libraries(lib_dir: &Path, cmake_build_type: &str, enabled_extensions: &[&str]) {
+    // Missing extensions are already caught by link_static_library's panic;
+    // this check only guards against CMake producing extensions we did not
+    // ask for (e.g. upstream extension-config drift).
+    let actual = list_static_extension_libraries(lib_dir, cmake_build_type).unwrap_or_else(|err| {
+        panic!(
+            "failed to inspect bundled-cmake extension libraries in {}: {err}",
+            lib_dir.display()
+        )
+    });
+    let mut expected: BTreeSet<String> = enabled_extensions
+        .iter()
+        .map(|ext| format!("{ext}_extension"))
+        .collect();
+    // CMake always builds this base extension through extension_config.cmake.
+    expected.insert("core_functions_extension".to_string());
+
+    let unexpected: Vec<String> = actual.difference(&expected).cloned().collect();
+    if !unexpected.is_empty() {
+        panic!(
+            "bundled-cmake produced unexpected static extension libraries: {}",
+            unexpected.join(", ")
+        );
+    }
+}
+
+fn link_static_library(lib_dir: &Path, cmake_build_type: &str, name: &str) {
+    let Some(library_path) = resolve_static_library(lib_dir, cmake_build_type, name) else {
+        let filename = static_library_filename(name);
+        let searched = candidate_library_dirs(lib_dir, cmake_build_type)
+            .into_iter()
+            .map(|dir| dir.join(&filename).display().to_string())
+            .collect::<Vec<_>>()
+            .join(", ");
+        panic!("expected bundled-cmake to produce static library `{name}`; looked in [{searched}]");
+    };
+    if let Some(parent) = library_path.parent() {
+        if parent != lib_dir {
+            println!("cargo:rustc-link-search=native={}", parent.display());
+        }
+    }
+    println!("cargo:rustc-link-lib=static={name}");
+}
+
+fn static_library_filename(name: &str) -> String {
+    if win_target() {
+        format!("{name}.lib")
+    } else {
+        format!("lib{name}.a")
+    }
+}
+
+fn list_static_extension_libraries(lib_dir: &Path, cmake_build_type: &str) -> io::Result<BTreeSet<String>> {
+    let mut extension_libraries = BTreeSet::new();
+    for candidate_dir in candidate_library_dirs(lib_dir, cmake_build_type) {
+        for entry in fs::read_dir(&candidate_dir)? {
+            let entry = entry?;
+            let file_type = entry.file_type()?;
+            if !file_type.is_file() {
+                continue;
+            }
+            let file_name = entry.file_name();
+            let Some(file_name) = file_name.to_str() else {
+                cargo_warning(&format!(
+                    "bundled-cmake ignored non-UTF-8 library filename in {}: {}",
+                    candidate_dir.display(),
+                    entry.path().display()
+                ));
+                continue;
+            };
+            let Some(name) = normalized_static_library_name(file_name) else {
+                continue;
+            };
+            if name.ends_with("_extension") && !name.ends_with("_loadable_extension") {
+                extension_libraries.insert(name);
+            }
+        }
+    }
+    Ok(extension_libraries)
+}
+
+fn normalized_static_library_name(filename: &str) -> Option<String> {
+    if let Some(name) = filename.strip_suffix(".lib") {
+        return Some(name.to_string());
+    }
+    let name = filename.strip_prefix("lib")?.strip_suffix(".a")?;
+    Some(name.to_string())
+}
+
+fn resolve_static_library(lib_dir: &Path, cmake_build_type: &str, name: &str) -> Option<PathBuf> {
+    let filename = static_library_filename(name);
+    candidate_library_dirs(lib_dir, cmake_build_type)
+        .into_iter()
+        .map(|dir| dir.join(&filename))
+        .find(|path| path.exists())
+}
+
+fn candidate_library_dirs(lib_dir: &Path, cmake_build_type: &str) -> Vec<PathBuf> {
+    // Single-config generators (Ninja, Make) write directly into lib/.
+    // Multi-config generators (MSVC, Xcode) write into lib/<Config>/.
+    // Restricting to these two avoids picking up stale extension libraries
+    // from a previous build that used a different CMAKE_BUILD_TYPE.
+    let mut candidates = vec![lib_dir.to_path_buf()];
+    let build_type_dir = lib_dir.join(cmake_build_type);
+    if build_type_dir.is_dir() {
+        candidates.push(build_type_dir);
+    }
+    candidates
+}
+
+fn cargo_warning(message: &str) {
+    println!("cargo:warning={message}");
+}
+
+fn enabled_extensions() -> Vec<&'static str> {
+    // Match DuckDB's upstream CMake defaults for quasi-core extensions rather
+    // than trying to reproduce the cc backend's finer-grained selection.
+    // Review build_bundled_cc::extension_enabled when changing this list; the
+    // backend mechanisms and supported extension sets intentionally differ.
+    let mut extensions = vec!["parquet"];
+    if cfg!(feature = "json") {
+        extensions.push("json");
+    }
+    if cfg!(feature = "autocomplete") {
+        extensions.push("autocomplete");
+    }
+    if cfg!(feature = "icu") {
+        extensions.push("icu");
+    }
+    if cfg!(feature = "tpcds") {
+        extensions.push("tpcds");
+    }
+    if cfg!(feature = "tpch") {
+        extensions.push("tpch");
+    }
+    extensions
+}
+
+fn link_system_libs() {
+    // Keep the per-OS lists below in sync with DuckDB's current linker requirements in
+    // duckdb-sources/src/CMakeLists.txt. If upstream drifts after a submodule bump,
+    // update every branch here alongside it.
+    let target_os = env::var("CARGO_CFG_TARGET_OS").expect("Cargo should set CARGO_CFG_TARGET_OS");
+
+    match target_os.as_str() {
+        "linux" => {
+            let target_env = env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default();
+            if target_env != "gnu" {
+                panic!(
+                    "bundled-cmake on linux is currently only supported with the `gnu` target env (libstdc++); got `{target_env}`"
+                );
+            }
+            println!("cargo:rustc-link-lib=dylib=dl");
+            println!("cargo:rustc-link-lib=dylib=pthread");
+            println!("cargo:rustc-link-lib=dylib=stdc++");
+        }
+        "macos" => {
+            println!("cargo:rustc-link-lib=dylib=c++");
+        }
+        "windows" => link_windows_system_libs(),
+        other => {
+            panic!(
+                "bundled-cmake is currently supported only on Linux, macOS, and Windows; unsupported target OS `{other}`"
+            )
+        }
+    }
+}
diff --git a/rust_hft/native/libduckdb-sys/duckdb.tar.gz b/rust_hft/native/libduckdb-sys/duckdb.tar.gz
new file mode 100644
index 000000000..7ce59da44
Binary files /dev/null and b/rust_hft/native/libduckdb-sys/duckdb.tar.gz differ
diff --git a/rust_hft/native/libduckdb-sys/src/arrow_c_data.rs b/rust_hft/native/libduckdb-sys/src/arrow_c_data.rs
new file mode 100644
index 000000000..d3cee1661
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/src/arrow_c_data.rs
@@ -0,0 +1,134 @@
+//! Arrow C Data Interface layouts used by DuckDB's Arrow conversion APIs.
+//!
+//! DuckDB's public C header forward-declares these structs. The conversion
+//! APIs need concrete caller-allocated layouts, so `libduckdb-sys` defines the
+//! ABI records directly without taking a dependency on arrow-rs.
+//!
+//! Specification: <https://arrow.apache.org/docs/format/CDataInterface.html>
+
+use std::{
+    ffi::{c_char, c_void},
+    ptr,
+};
+
+/// Arrow C Data Interface array.
+#[repr(C)]
+#[derive(Debug)]
+pub struct ArrowArray {
+    pub length: i64,
+    pub null_count: i64,
+    pub offset: i64,
+    pub n_buffers: i64,
+    pub n_children: i64,
+    pub buffers: *mut *const c_void,
+    pub children: *mut *mut ArrowArray,
+    pub dictionary: *mut ArrowArray,
+    pub release: Option<unsafe extern "C" fn(*mut ArrowArray)>,
+    pub private_data: *mut c_void,
+}
+
+impl ArrowArray {
+    /// Creates a null-release placeholder for a producer to fill.
+    pub const fn empty() -> Self {
+        Self {
+            length: 0,
+            null_count: 0,
+            offset: 0,
+            n_buffers: 0,
+            n_children: 0,
+            buffers: ptr::null_mut(),
+            children: ptr::null_mut(),
+            dictionary: ptr::null_mut(),
+            release: None,
+            private_data: ptr::null_mut(),
+        }
+    }
+}
+
+/// Arrow C Data Interface schema.
+#[repr(C)]
+#[derive(Debug)]
+pub struct ArrowSchema {
+    pub format: *const c_char,
+    pub name: *const c_char,
+    pub metadata: *const c_char,
+    pub flags: i64,
+    pub n_children: i64,
+    pub children: *mut *mut ArrowSchema,
+    pub dictionary: *mut ArrowSchema,
+    pub release: Option<unsafe extern "C" fn(*mut ArrowSchema)>,
+    pub private_data: *mut c_void,
+}
+
+impl ArrowSchema {
+    /// Creates a null-release placeholder for a producer to fill.
+    pub const fn empty() -> Self {
+        Self {
+            format: ptr::null(),
+            name: ptr::null(),
+            metadata: ptr::null(),
+            flags: 0,
+            n_children: 0,
+            children: ptr::null_mut(),
+            dictionary: ptr::null_mut(),
+            release: None,
+            private_data: ptr::null_mut(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::mem::{align_of, offset_of, size_of};
+
+    use arrow::ffi::{FFI_ArrowArray, FFI_ArrowSchema};
+
+    macro_rules! assert_offsets {
+        ($left:ty, $right:ty, $($field:ident),+ $(,)?) => {
+            $(
+                assert_eq!(
+                    offset_of!($left, $field),
+                    offset_of!($right, $field),
+                    concat!("field offset differs for ", stringify!($field))
+                );
+            )+
+        };
+    }
+
+    #[test]
+    fn matches_arrow_rs_layouts() {
+        assert_eq!(size_of::<ArrowArray>(), size_of::<FFI_ArrowArray>());
+        assert_eq!(align_of::<ArrowArray>(), align_of::<FFI_ArrowArray>());
+        assert_offsets!(
+            ArrowArray,
+            FFI_ArrowArray,
+            length,
+            null_count,
+            offset,
+            n_buffers,
+            n_children,
+            buffers,
+            children,
+            dictionary,
+            release,
+            private_data,
+        );
+
+        assert_eq!(size_of::<ArrowSchema>(), size_of::<FFI_ArrowSchema>());
+        assert_eq!(align_of::<ArrowSchema>(), align_of::<FFI_ArrowSchema>());
+        assert_offsets!(
+            ArrowSchema,
+            FFI_ArrowSchema,
+            format,
+            name,
+            metadata,
+            flags,
+            n_children,
+            children,
+            dictionary,
+            release,
+            private_data,
+        );
+    }
+}
diff --git a/rust_hft/native/libduckdb-sys/src/bindgen_bundled_version.rs b/rust_hft/native/libduckdb-sys/src/bindgen_bundled_version.rs
new file mode 100644
index 000000000..d04184e77
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/src/bindgen_bundled_version.rs
@@ -0,0 +1,3579 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const DUCKDB_TYPE_DUCKDB_TYPE_INVALID: DUCKDB_TYPE = 0;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BOOLEAN: DUCKDB_TYPE = 1;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TINYINT: DUCKDB_TYPE = 2;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_SMALLINT: DUCKDB_TYPE = 3;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_INTEGER: DUCKDB_TYPE = 4;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BIGINT: DUCKDB_TYPE = 5;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UTINYINT: DUCKDB_TYPE = 6;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_USMALLINT: DUCKDB_TYPE = 7;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UINTEGER: DUCKDB_TYPE = 8;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UBIGINT: DUCKDB_TYPE = 9;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_FLOAT: DUCKDB_TYPE = 10;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_DOUBLE: DUCKDB_TYPE = 11;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP: DUCKDB_TYPE = 12;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_DATE: DUCKDB_TYPE = 13;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIME: DUCKDB_TYPE = 14;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_INTERVAL: DUCKDB_TYPE = 15;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_HUGEINT: DUCKDB_TYPE = 16;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UHUGEINT: DUCKDB_TYPE = 32;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_VARCHAR: DUCKDB_TYPE = 17;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BLOB: DUCKDB_TYPE = 18;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_DECIMAL: DUCKDB_TYPE = 19;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP_S: DUCKDB_TYPE = 20;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP_MS: DUCKDB_TYPE = 21;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP_NS: DUCKDB_TYPE = 22;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_ENUM: DUCKDB_TYPE = 23;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_LIST: DUCKDB_TYPE = 24;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_STRUCT: DUCKDB_TYPE = 25;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_MAP: DUCKDB_TYPE = 26;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_ARRAY: DUCKDB_TYPE = 33;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UUID: DUCKDB_TYPE = 27;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UNION: DUCKDB_TYPE = 28;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BIT: DUCKDB_TYPE = 29;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIME_TZ: DUCKDB_TYPE = 30;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP_TZ: DUCKDB_TYPE = 31;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_ANY: DUCKDB_TYPE = 34;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BIGNUM: DUCKDB_TYPE = 35;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_SQLNULL: DUCKDB_TYPE = 36;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_STRING_LITERAL: DUCKDB_TYPE = 37;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_INTEGER_LITERAL: DUCKDB_TYPE = 38;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIME_NS: DUCKDB_TYPE = 39;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_GEOMETRY: DUCKDB_TYPE = 40;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_VARIANT: DUCKDB_TYPE = 41;
+#[doc = "! An enum over DuckDB's internal types."]
+pub type DUCKDB_TYPE = ::std::os::raw::c_uint;
+#[doc = "! An enum over DuckDB's internal types."]
+pub use self::DUCKDB_TYPE as duckdb_type;
+pub const duckdb_state_DuckDBSuccess: duckdb_state = 0;
+pub const duckdb_state_DuckDBError: duckdb_state = 1;
+#[doc = "! An enum over the returned state of different functions."]
+pub type duckdb_state = ::std::os::raw::c_uint;
+pub const duckdb_pending_state_DUCKDB_PENDING_RESULT_READY: duckdb_pending_state = 0;
+pub const duckdb_pending_state_DUCKDB_PENDING_RESULT_NOT_READY: duckdb_pending_state = 1;
+pub const duckdb_pending_state_DUCKDB_PENDING_ERROR: duckdb_pending_state = 2;
+pub const duckdb_pending_state_DUCKDB_PENDING_NO_TASKS_AVAILABLE: duckdb_pending_state = 3;
+#[doc = "! An enum over the pending state of a pending query result."]
+pub type duckdb_pending_state = ::std::os::raw::c_uint;
+pub const duckdb_result_type_DUCKDB_RESULT_TYPE_INVALID: duckdb_result_type = 0;
+pub const duckdb_result_type_DUCKDB_RESULT_TYPE_CHANGED_ROWS: duckdb_result_type = 1;
+pub const duckdb_result_type_DUCKDB_RESULT_TYPE_NOTHING: duckdb_result_type = 2;
+pub const duckdb_result_type_DUCKDB_RESULT_TYPE_QUERY_RESULT: duckdb_result_type = 3;
+#[doc = "! An enum over DuckDB's different result types."]
+pub type duckdb_result_type = ::std::os::raw::c_uint;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_INVALID: duckdb_statement_type = 0;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_SELECT: duckdb_statement_type = 1;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_INSERT: duckdb_statement_type = 2;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_UPDATE: duckdb_statement_type = 3;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_EXPLAIN: duckdb_statement_type = 4;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_DELETE: duckdb_statement_type = 5;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_PREPARE: duckdb_statement_type = 6;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_CREATE: duckdb_statement_type = 7;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_EXECUTE: duckdb_statement_type = 8;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_ALTER: duckdb_statement_type = 9;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_TRANSACTION: duckdb_statement_type = 10;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_COPY: duckdb_statement_type = 11;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_ANALYZE: duckdb_statement_type = 12;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_VARIABLE_SET: duckdb_statement_type = 13;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_CREATE_FUNC: duckdb_statement_type = 14;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_DROP: duckdb_statement_type = 15;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_EXPORT: duckdb_statement_type = 16;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_PRAGMA: duckdb_statement_type = 17;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_VACUUM: duckdb_statement_type = 18;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_CALL: duckdb_statement_type = 19;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_SET: duckdb_statement_type = 20;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_LOAD: duckdb_statement_type = 21;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_RELATION: duckdb_statement_type = 22;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_EXTENSION: duckdb_statement_type = 23;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN: duckdb_statement_type = 24;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_ATTACH: duckdb_statement_type = 25;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_DETACH: duckdb_statement_type = 26;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_MULTI: duckdb_statement_type = 27;
+#[doc = "! An enum over DuckDB's different statement types."]
+pub type duckdb_statement_type = ::std::os::raw::c_uint;
+pub const duckdb_error_type_DUCKDB_ERROR_INVALID: duckdb_error_type = 0;
+pub const duckdb_error_type_DUCKDB_ERROR_OUT_OF_RANGE: duckdb_error_type = 1;
+pub const duckdb_error_type_DUCKDB_ERROR_CONVERSION: duckdb_error_type = 2;
+pub const duckdb_error_type_DUCKDB_ERROR_UNKNOWN_TYPE: duckdb_error_type = 3;
+pub const duckdb_error_type_DUCKDB_ERROR_DECIMAL: duckdb_error_type = 4;
+pub const duckdb_error_type_DUCKDB_ERROR_MISMATCH_TYPE: duckdb_error_type = 5;
+pub const duckdb_error_type_DUCKDB_ERROR_DIVIDE_BY_ZERO: duckdb_error_type = 6;
+pub const duckdb_error_type_DUCKDB_ERROR_OBJECT_SIZE: duckdb_error_type = 7;
+pub const duckdb_error_type_DUCKDB_ERROR_INVALID_TYPE: duckdb_error_type = 8;
+pub const duckdb_error_type_DUCKDB_ERROR_SERIALIZATION: duckdb_error_type = 9;
+pub const duckdb_error_type_DUCKDB_ERROR_TRANSACTION: duckdb_error_type = 10;
+pub const duckdb_error_type_DUCKDB_ERROR_NOT_IMPLEMENTED: duckdb_error_type = 11;
+pub const duckdb_error_type_DUCKDB_ERROR_EXPRESSION: duckdb_error_type = 12;
+pub const duckdb_error_type_DUCKDB_ERROR_CATALOG: duckdb_error_type = 13;
+pub const duckdb_error_type_DUCKDB_ERROR_PARSER: duckdb_error_type = 14;
+pub const duckdb_error_type_DUCKDB_ERROR_PLANNER: duckdb_error_type = 15;
+pub const duckdb_error_type_DUCKDB_ERROR_SCHEDULER: duckdb_error_type = 16;
+pub const duckdb_error_type_DUCKDB_ERROR_EXECUTOR: duckdb_error_type = 17;
+pub const duckdb_error_type_DUCKDB_ERROR_CONSTRAINT: duckdb_error_type = 18;
+pub const duckdb_error_type_DUCKDB_ERROR_INDEX: duckdb_error_type = 19;
+pub const duckdb_error_type_DUCKDB_ERROR_STAT: duckdb_error_type = 20;
+pub const duckdb_error_type_DUCKDB_ERROR_CONNECTION: duckdb_error_type = 21;
+pub const duckdb_error_type_DUCKDB_ERROR_SYNTAX: duckdb_error_type = 22;
+pub const duckdb_error_type_DUCKDB_ERROR_SETTINGS: duckdb_error_type = 23;
+pub const duckdb_error_type_DUCKDB_ERROR_BINDER: duckdb_error_type = 24;
+pub const duckdb_error_type_DUCKDB_ERROR_NETWORK: duckdb_error_type = 25;
+pub const duckdb_error_type_DUCKDB_ERROR_OPTIMIZER: duckdb_error_type = 26;
+pub const duckdb_error_type_DUCKDB_ERROR_NULL_POINTER: duckdb_error_type = 27;
+pub const duckdb_error_type_DUCKDB_ERROR_IO: duckdb_error_type = 28;
+pub const duckdb_error_type_DUCKDB_ERROR_INTERRUPT: duckdb_error_type = 29;
+pub const duckdb_error_type_DUCKDB_ERROR_FATAL: duckdb_error_type = 30;
+pub const duckdb_error_type_DUCKDB_ERROR_INTERNAL: duckdb_error_type = 31;
+pub const duckdb_error_type_DUCKDB_ERROR_INVALID_INPUT: duckdb_error_type = 32;
+pub const duckdb_error_type_DUCKDB_ERROR_OUT_OF_MEMORY: duckdb_error_type = 33;
+pub const duckdb_error_type_DUCKDB_ERROR_PERMISSION: duckdb_error_type = 34;
+pub const duckdb_error_type_DUCKDB_ERROR_PARAMETER_NOT_RESOLVED: duckdb_error_type = 35;
+pub const duckdb_error_type_DUCKDB_ERROR_PARAMETER_NOT_ALLOWED: duckdb_error_type = 36;
+pub const duckdb_error_type_DUCKDB_ERROR_DEPENDENCY: duckdb_error_type = 37;
+pub const duckdb_error_type_DUCKDB_ERROR_HTTP: duckdb_error_type = 38;
+pub const duckdb_error_type_DUCKDB_ERROR_MISSING_EXTENSION: duckdb_error_type = 39;
+pub const duckdb_error_type_DUCKDB_ERROR_AUTOLOAD: duckdb_error_type = 40;
+pub const duckdb_error_type_DUCKDB_ERROR_SEQUENCE: duckdb_error_type = 41;
+pub const duckdb_error_type_DUCKDB_INVALID_CONFIGURATION: duckdb_error_type = 42;
+#[doc = "! An enum over DuckDB's different error types."]
+pub type duckdb_error_type = ::std::os::raw::c_uint;
+pub const duckdb_cast_mode_DUCKDB_CAST_NORMAL: duckdb_cast_mode = 0;
+pub const duckdb_cast_mode_DUCKDB_CAST_TRY: duckdb_cast_mode = 1;
+#[doc = "! An enum over DuckDB's different cast modes."]
+pub type duckdb_cast_mode = ::std::os::raw::c_uint;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_INVALID: duckdb_file_flag = 0;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_READ: duckdb_file_flag = 1;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_WRITE: duckdb_file_flag = 2;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_CREATE: duckdb_file_flag = 3;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_CREATE_NEW: duckdb_file_flag = 4;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_APPEND: duckdb_file_flag = 5;
+pub type duckdb_file_flag = ::std::os::raw::c_uint;
+pub const duckdb_config_option_scope_DUCKDB_CONFIG_OPTION_SCOPE_INVALID: duckdb_config_option_scope = 0;
+pub const duckdb_config_option_scope_DUCKDB_CONFIG_OPTION_SCOPE_LOCAL: duckdb_config_option_scope = 1;
+pub const duckdb_config_option_scope_DUCKDB_CONFIG_OPTION_SCOPE_SESSION: duckdb_config_option_scope = 2;
+pub const duckdb_config_option_scope_DUCKDB_CONFIG_OPTION_SCOPE_GLOBAL: duckdb_config_option_scope = 3;
+#[doc = "! An enum over DuckDB's configuration option scopes.\n! This enum can be used to specify the default scope when creating a custom configuration option,\n! but it is also be used to determine the scope in which a configuration option is set when it is\n! changed or retrieved."]
+pub type duckdb_config_option_scope = ::std::os::raw::c_uint;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_INVALID: duckdb_catalog_entry_type = 0;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_TABLE: duckdb_catalog_entry_type = 1;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_SCHEMA: duckdb_catalog_entry_type = 2;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_VIEW: duckdb_catalog_entry_type = 3;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_INDEX: duckdb_catalog_entry_type = 4;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_PREPARED_STATEMENT: duckdb_catalog_entry_type = 5;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_SEQUENCE: duckdb_catalog_entry_type = 6;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_COLLATION: duckdb_catalog_entry_type = 7;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_TYPE: duckdb_catalog_entry_type = 8;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_DATABASE: duckdb_catalog_entry_type = 9;
+#[doc = "! An enum over DuckDB's catalog entry types."]
+pub type duckdb_catalog_entry_type = ::std::os::raw::c_uint;
+#[doc = "! DuckDB's index type."]
+pub type idx_t = u64;
+#[doc = "! Type definition for the data pointers of selection vectors."]
+pub type sel_t = u32;
+#[doc = "! The callback to destroy data, e.g.,\n! bind data (if any), init data (if any), extra data for replacement scans (if any), etc."]
+pub type duckdb_delete_callback_t = ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>;
+#[doc = "! The callback to copy data, e.g., bind data (if any)."]
+pub type duckdb_copy_callback_t =
+    ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void>;
+#[doc = "! Used for threading, contains a task state.\n! Must be destroyed with `duckdb_destroy_task_state`."]
+pub type duckdb_task_state = *mut ::std::os::raw::c_void;
+#[doc = "! DATE is stored as days since 1970-01-01.\n! Use the `duckdb_from_date` and `duckdb_to_date` functions to extract individual information."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_date {
+    pub days: i32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_date_struct {
+    pub year: i32,
+    pub month: i8,
+    pub day: i8,
+}
+#[doc = "! TIME is stored as microseconds since 00:00:00.\n! Use the `duckdb_from_time` and `duckdb_to_time` functions to extract individual information."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time {
+    pub micros: i64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time_struct {
+    pub hour: i8,
+    pub min: i8,
+    pub sec: i8,
+    pub micros: i32,
+}
+#[doc = "! TIME_NS is stored as nanoseconds since 00:00:00."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time_ns {
+    pub nanos: i64,
+}
+#[doc = "! TIME_TZ is stored as 40 bits for the int64_t microseconds, and 24 bits for the int32_t offset.\n! Use the `duckdb_from_time_tz` function to extract individual information."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time_tz {
+    pub bits: u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time_tz_struct {
+    pub time: duckdb_time_struct,
+    pub offset: i32,
+}
+#[doc = "! TIMESTAMP is stored as microseconds since 1970-01-01.\n! Use the `duckdb_from_timestamp` and `duckdb_to_timestamp` functions to extract individual information."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp {
+    pub micros: i64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp_struct {
+    pub date: duckdb_date_struct,
+    pub time: duckdb_time_struct,
+}
+#[doc = "! TIMESTAMP_S is stored as seconds since 1970-01-01."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp_s {
+    pub seconds: i64,
+}
+#[doc = "! TIMESTAMP_MS is stored as milliseconds since 1970-01-01."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp_ms {
+    pub millis: i64,
+}
+#[doc = "! TIMESTAMP_NS is stored as nanoseconds since 1970-01-01."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp_ns {
+    pub nanos: i64,
+}
+#[doc = "! INTERVAL is stored in months, days, and micros."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_interval {
+    pub months: i32,
+    pub days: i32,
+    pub micros: i64,
+}
+#[doc = "! HUGEINT is composed of a lower and upper component.\n! Its value is upper * 2^64 + lower.\n! For simplified usage, use `duckdb_hugeint_to_double` and `duckdb_double_to_hugeint`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_hugeint {
+    pub lower: u64,
+    pub upper: i64,
+}
+#[doc = "! UHUGEINT is composed of a lower and upper component.\n! Its value is upper * 2^64 + lower.\n! For simplified usage, use `duckdb_uhugeint_to_double` and `duckdb_double_to_uhugeint`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_uhugeint {
+    pub lower: u64,
+    pub upper: u64,
+}
+#[doc = "! DECIMAL is composed of a width and a scale.\n! Their value is stored in a HUGEINT."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_decimal {
+    pub width: u8,
+    pub scale: u8,
+    pub value: duckdb_hugeint,
+}
+#[doc = "! A type holding information about the query execution progress."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_query_progress_type {
+    pub percentage: f64,
+    pub rows_processed: u64,
+    pub total_rows_to_process: u64,
+}
+#[doc = "! The internal representation of a VARCHAR (string_t). If the VARCHAR does not\n! exceed 12 characters, then we inline it. Otherwise, we inline a four-byte prefix for faster\n! string comparisons and store a pointer to the remaining characters. This is a non-\n! owning structure, i.e., it does not have to be freed."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct duckdb_string_t {
+    pub value: duckdb_string_t__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union duckdb_string_t__bindgen_ty_1 {
+    pub pointer: duckdb_string_t__bindgen_ty_1__bindgen_ty_1,
+    pub inlined: duckdb_string_t__bindgen_ty_1__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_string_t__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_string_t__bindgen_ty_1__bindgen_ty_2 {
+    pub length: u32,
+    pub inlined: [::std::os::raw::c_char; 12usize],
+}
+#[doc = "! DuckDB's LISTs are composed of a 'parent' vector holding metadata of each list,\n! and a child vector holding the entries of the lists.\n! The `duckdb_list_entry` struct contains the internal representation of a LIST metadata entry.\n! A metadata entry contains the length of the list, and its offset in the child vector."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_list_entry {
+    pub offset: u64,
+    pub length: u64,
+}
+#[doc = "! A column consists of a pointer to its internal data. Don't operate on this type directly.\n! Instead, use functions such as `duckdb_column_data`, `duckdb_nullmask_data`,\n! `duckdb_column_type`, and `duckdb_column_name`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_column {
+    pub deprecated_data: *mut ::std::os::raw::c_void,
+    pub deprecated_nullmask: *mut bool,
+    pub deprecated_type: duckdb_type,
+    pub deprecated_name: *mut ::std::os::raw::c_char,
+    pub internal_data: *mut ::std::os::raw::c_void,
+}
+#[doc = "! 1. A standalone vector that must be destroyed, or\n! 2. A vector to a column in a data chunk that lives as long as the data chunk lives."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_vector {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! 1. A standalone vector that must be destroyed, or\n! 2. A vector to a column in a data chunk that lives as long as the data chunk lives."]
+pub type duckdb_vector = *mut _duckdb_vector;
+#[doc = "! A selection vector is a vector of indices, which usually refer to values in a vector.\n! Can be used to slice vectors, changing their length and the order of their entries.\n! Standalone selection vectors must be destroyed."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_selection_vector {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A selection vector is a vector of indices, which usually refer to values in a vector.\n! Can be used to slice vectors, changing their length and the order of their entries.\n! Standalone selection vectors must be destroyed."]
+pub type duckdb_selection_vector = *mut _duckdb_selection_vector;
+#[doc = "! Strings are composed of a `char` pointer and a size.\n! You must free `string.data` with `duckdb_free`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_string {
+    pub data: *mut ::std::os::raw::c_char,
+    pub size: idx_t,
+}
+#[doc = "! BLOBs are composed of a byte pointer and a size.\n! You must free `blob.data` with `duckdb_free`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_blob {
+    pub data: *mut ::std::os::raw::c_void,
+    pub size: idx_t,
+}
+#[doc = "! BITs are composed of a byte pointer and a size.\n! BIT byte data has 0 to 7 bits of padding.\n! The first byte contains the number of padding bits.\n! The padding bits of the second byte are set to 1, starting from the MSB.\n! You must free `data` with `duckdb_free`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_bit {
+    pub data: *mut u8,
+    pub size: idx_t,
+}
+#[doc = "! BIGNUMs are composed of a byte pointer, a size, and an `is_negative` bool.\n! The absolute value of the number is stored in `data` in big endian format.\n! You must free `data` with `duckdb_free`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_bignum {
+    pub data: *mut u8,
+    pub size: idx_t,
+    pub is_negative: bool,
+}
+#[doc = "! A query result consists of a pointer to its internal data.\n! Must be freed with 'duckdb_destroy_result'."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_result {
+    pub deprecated_column_count: idx_t,
+    pub deprecated_row_count: idx_t,
+    pub deprecated_rows_changed: idx_t,
+    pub deprecated_columns: *mut duckdb_column,
+    pub deprecated_error_message: *mut ::std::os::raw::c_char,
+    pub internal_data: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A database instance cache object. Must be destroyed with `duckdb_destroy_instance_cache`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_instance_cache {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A database instance cache object. Must be destroyed with `duckdb_destroy_instance_cache`."]
+pub type duckdb_instance_cache = *mut _duckdb_instance_cache;
+#[doc = "! A database object. Must be closed with `duckdb_close`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_database {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A database object. Must be closed with `duckdb_close`."]
+pub type duckdb_database = *mut _duckdb_database;
+#[doc = "! A connection to a duckdb database. Must be closed with `duckdb_disconnect`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_connection {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A connection to a duckdb database. Must be closed with `duckdb_disconnect`."]
+pub type duckdb_connection = *mut _duckdb_connection;
+#[doc = "! A client context of a duckdb connection. Must be destroyed with `duckdb_destroy_context`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_client_context {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A client context of a duckdb connection. Must be destroyed with `duckdb_destroy_context`."]
+pub type duckdb_client_context = *mut _duckdb_client_context;
+#[doc = "! A prepared statement is a parameterized query that allows you to bind parameters to it.\n! Must be destroyed with `duckdb_destroy_prepare`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_prepared_statement {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A prepared statement is a parameterized query that allows you to bind parameters to it.\n! Must be destroyed with `duckdb_destroy_prepare`."]
+pub type duckdb_prepared_statement = *mut _duckdb_prepared_statement;
+#[doc = "! Extracted statements. Must be destroyed with `duckdb_destroy_extracted`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_extracted_statements {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Extracted statements. Must be destroyed with `duckdb_destroy_extracted`."]
+pub type duckdb_extracted_statements = *mut _duckdb_extracted_statements;
+#[doc = "! The pending result represents an intermediate structure for a query that is not yet fully executed.\n! Must be destroyed with `duckdb_destroy_pending`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_pending_result {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The pending result represents an intermediate structure for a query that is not yet fully executed.\n! Must be destroyed with `duckdb_destroy_pending`."]
+pub type duckdb_pending_result = *mut _duckdb_pending_result;
+#[doc = "! The appender enables fast data loading into DuckDB.\n! Must be destroyed with `duckdb_appender_destroy`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_appender {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The appender enables fast data loading into DuckDB.\n! Must be destroyed with `duckdb_appender_destroy`."]
+pub type duckdb_appender = *mut _duckdb_appender;
+#[doc = "! The table description allows querying information about the table.\n! Must be destroyed with `duckdb_table_description_destroy`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_table_description {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The table description allows querying information about the table.\n! Must be destroyed with `duckdb_table_description_destroy`."]
+pub type duckdb_table_description = *mut _duckdb_table_description;
+#[doc = "! The configuration can be used to provide start-up options for a database.\n! Must be destroyed with `duckdb_destroy_config`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_config {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The configuration can be used to provide start-up options for a database.\n! Must be destroyed with `duckdb_destroy_config`."]
+pub type duckdb_config = *mut _duckdb_config;
+#[doc = "! A custom configuration option instance. Used to register custom options that can be set on a duckdb_config.\n! or by the user in SQL using `SET <option_name> = <value>`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_config_option {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A custom configuration option instance. Used to register custom options that can be set on a duckdb_config.\n! or by the user in SQL using `SET <option_name> = <value>`."]
+pub type duckdb_config_option = *mut _duckdb_config_option;
+#[doc = "! A logical type.\n! Must be destroyed with `duckdb_destroy_logical_type`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_logical_type {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A logical type.\n! Must be destroyed with `duckdb_destroy_logical_type`."]
+pub type duckdb_logical_type = *mut _duckdb_logical_type;
+#[doc = "! Holds extra information to register a custom logical type.\n! Reserved for future use."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_create_type_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds extra information to register a custom logical type.\n! Reserved for future use."]
+pub type duckdb_create_type_info = *mut _duckdb_create_type_info;
+#[doc = "! Contains a data chunk of a duckdb_result.\n! Must be destroyed with `duckdb_destroy_data_chunk`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_data_chunk {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Contains a data chunk of a duckdb_result.\n! Must be destroyed with `duckdb_destroy_data_chunk`."]
+pub type duckdb_data_chunk = *mut _duckdb_data_chunk;
+#[doc = "! A value of a logical type.\n! Must be destroyed with `duckdb_destroy_value`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_value {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A value of a logical type.\n! Must be destroyed with `duckdb_destroy_value`."]
+pub type duckdb_value = *mut _duckdb_value;
+#[doc = "! Holds a recursive tree containing profiling metrics.\n! The tree matches the query plan, and has a top-level node."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_profiling_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds a recursive tree containing profiling metrics.\n! The tree matches the query plan, and has a top-level node."]
+pub type duckdb_profiling_info = *mut _duckdb_profiling_info;
+#[doc = "! Holds error data.\n! Must be destroyed with `duckdb_destroy_error_data`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_error_data {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds error data.\n! Must be destroyed with `duckdb_destroy_error_data`."]
+pub type duckdb_error_data = *mut _duckdb_error_data;
+#[doc = "! Holds a bound expression.\n! Must be destroyed with `duckdb_destroy_expression`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_expression {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds a bound expression.\n! Must be destroyed with `duckdb_destroy_expression`."]
+pub type duckdb_expression = *mut _duckdb_expression;
+#[doc = "! Holds the state of the C API extension initialization process."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_extension_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds the state of the C API extension initialization process."]
+pub type duckdb_extension_info = *mut _duckdb_extension_info;
+#[doc = "! Additional function info.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_function_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Additional function info.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+pub type duckdb_function_info = *mut _duckdb_function_info;
+#[doc = "! The bind info of a function.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_bind_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The bind info of a function.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+pub type duckdb_bind_info = *mut _duckdb_bind_info;
+#[doc = "! Additional function initialization info.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_init_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Additional function initialization info.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+pub type duckdb_init_info = *mut _duckdb_init_info;
+#[doc = "! A scalar function. Must be destroyed with `duckdb_destroy_scalar_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_scalar_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A scalar function. Must be destroyed with `duckdb_destroy_scalar_function`."]
+pub type duckdb_scalar_function = *mut _duckdb_scalar_function;
+#[doc = "! A scalar function set. Must be destroyed with `duckdb_destroy_scalar_function_set`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_scalar_function_set {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A scalar function set. Must be destroyed with `duckdb_destroy_scalar_function_set`."]
+pub type duckdb_scalar_function_set = *mut _duckdb_scalar_function_set;
+#[doc = "! The bind function callback of the scalar function."]
+pub type duckdb_scalar_function_bind_t = ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info)>;
+#[doc = "! The thread-local initialization function of the scalar function."]
+pub type duckdb_scalar_function_init_t = ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info)>;
+#[doc = "! The function to execute the scalar function on an input chunk."]
+pub type duckdb_scalar_function_t = ::std::option::Option<
+    unsafe extern "C" fn(info: duckdb_function_info, input: duckdb_data_chunk, output: duckdb_vector),
+>;
+#[doc = "! An aggregate function. Must be destroyed with `duckdb_destroy_aggregate_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_aggregate_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! An aggregate function. Must be destroyed with `duckdb_destroy_aggregate_function`."]
+pub type duckdb_aggregate_function = *mut _duckdb_aggregate_function;
+#[doc = "! A aggregate function set. Must be destroyed with `duckdb_destroy_aggregate_function_set`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_aggregate_function_set {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A aggregate function set. Must be destroyed with `duckdb_destroy_aggregate_function_set`."]
+pub type duckdb_aggregate_function_set = *mut _duckdb_aggregate_function_set;
+#[doc = "! The state of an aggregate function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_aggregate_state {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The state of an aggregate function."]
+pub type duckdb_aggregate_state = *mut _duckdb_aggregate_state;
+#[doc = "! A function to return the aggregate state's size."]
+pub type duckdb_aggregate_state_size = ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> idx_t>;
+#[doc = "! A function to initialize an aggregate state."]
+pub type duckdb_aggregate_init_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info, state: duckdb_aggregate_state)>;
+#[doc = "! An optional function to destroy an aggregate state."]
+pub type duckdb_aggregate_destroy_t =
+    ::std::option::Option<unsafe extern "C" fn(states: *mut duckdb_aggregate_state, count: idx_t)>;
+#[doc = "! A function to update a set of aggregate states with new values."]
+pub type duckdb_aggregate_update_t = ::std::option::Option<
+    unsafe extern "C" fn(info: duckdb_function_info, input: duckdb_data_chunk, states: *mut duckdb_aggregate_state),
+>;
+#[doc = "! A function to combine aggregate states."]
+pub type duckdb_aggregate_combine_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        info: duckdb_function_info,
+        source: *mut duckdb_aggregate_state,
+        target: *mut duckdb_aggregate_state,
+        count: idx_t,
+    ),
+>;
+#[doc = "! A function to finalize aggregate states into a result vector."]
+pub type duckdb_aggregate_finalize_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        info: duckdb_function_info,
+        source: *mut duckdb_aggregate_state,
+        result: duckdb_vector,
+        count: idx_t,
+        offset: idx_t,
+    ),
+>;
+#[doc = "! A table function. Must be destroyed with `duckdb_destroy_table_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_table_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A table function. Must be destroyed with `duckdb_destroy_table_function`."]
+pub type duckdb_table_function = *mut _duckdb_table_function;
+#[doc = "! The bind function of the table function."]
+pub type duckdb_table_function_bind_t = ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info)>;
+#[doc = "! The possibly thread-local initialization function of the table function."]
+pub type duckdb_table_function_init_t = ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info)>;
+#[doc = "! The function to generate an output chunk during table function execution."]
+pub type duckdb_table_function_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info, output: duckdb_data_chunk)>;
+#[doc = "! A COPY function. Must be destroyed with `duckdb_destroy_copy_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A COPY function. Must be destroyed with `duckdb_destroy_copy_function`."]
+pub type duckdb_copy_function = *mut _duckdb_copy_function;
+#[doc = "! Info for the bind function of a COPY function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function_bind_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Info for the bind function of a COPY function."]
+pub type duckdb_copy_function_bind_info = *mut _duckdb_copy_function_bind_info;
+#[doc = "! Info for the global initialization function of a COPY function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function_global_init_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Info for the global initialization function of a COPY function."]
+pub type duckdb_copy_function_global_init_info = *mut _duckdb_copy_function_global_init_info;
+#[doc = "! Info for the sink function of a COPY function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function_sink_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Info for the sink function of a COPY function."]
+pub type duckdb_copy_function_sink_info = *mut _duckdb_copy_function_sink_info;
+#[doc = "! Info for the finalize function of a COPY function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function_finalize_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Info for the finalize function of a COPY function."]
+pub type duckdb_copy_function_finalize_info = *mut _duckdb_copy_function_finalize_info;
+#[doc = "! The bind function to use when binding a COPY ... TO function."]
+pub type duckdb_copy_function_bind_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_bind_info)>;
+#[doc = "! The initialization function to use when initializing a COPY ... TO function."]
+pub type duckdb_copy_function_global_init_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_global_init_info)>;
+#[doc = "! The function to sink an input chunk into during execution of a COPY ... TO function."]
+pub type duckdb_copy_function_sink_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_sink_info, input: duckdb_data_chunk)>;
+#[doc = "! The function to finalize the COPY ... TO function execution."]
+pub type duckdb_copy_function_finalize_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_finalize_info)>;
+#[doc = "! A cast function. Must be destroyed with `duckdb_destroy_cast_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_cast_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A cast function. Must be destroyed with `duckdb_destroy_cast_function`."]
+pub type duckdb_cast_function = *mut _duckdb_cast_function;
+#[doc = "! The function to cast from an input vector to an output vector."]
+pub type duckdb_cast_function_t = ::std::option::Option<
+    unsafe extern "C" fn(info: duckdb_function_info, count: idx_t, input: duckdb_vector, output: duckdb_vector) -> bool,
+>;
+#[doc = "! Additional replacement scan info. When setting this info, it is necessary to pass a destroy-callback function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_replacement_scan_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Additional replacement scan info. When setting this info, it is necessary to pass a destroy-callback function."]
+pub type duckdb_replacement_scan_info = *mut _duckdb_replacement_scan_info;
+#[doc = "! A replacement scan function."]
+pub type duckdb_replacement_callback_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        info: duckdb_replacement_scan_info,
+        table_name: *const ::std::os::raw::c_char,
+        data: *mut ::std::os::raw::c_void,
+    ),
+>;
+#[doc = "! Holds an arrow query result. Must be destroyed with `duckdb_destroy_arrow`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow query result. Must be destroyed with `duckdb_destroy_arrow`."]
+pub type duckdb_arrow = *mut _duckdb_arrow;
+#[doc = "! Holds an arrow array stream. Must be destroyed with `duckdb_destroy_arrow_stream`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_stream {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow array stream. Must be destroyed with `duckdb_destroy_arrow_stream`."]
+pub type duckdb_arrow_stream = *mut _duckdb_arrow_stream;
+#[doc = "! Holds an arrow schema. Remember to release the respective ArrowSchema object."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_schema {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow schema. Remember to release the respective ArrowSchema object."]
+pub type duckdb_arrow_schema = *mut _duckdb_arrow_schema;
+#[doc = "! Holds an arrow converted schema (i.e., duckdb::ArrowTableSchema).\n! In practice, this object holds the information necessary to do proper conversion between Arrow Types and DuckDB\n! Types. Check duckdb/function/table/arrow/arrow_duck_schema.hpp for more details! Must be destroyed with\n! `duckdb_destroy_arrow_converted_schema`"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_converted_schema {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow converted schema (i.e., duckdb::ArrowTableSchema).\n! In practice, this object holds the information necessary to do proper conversion between Arrow Types and DuckDB\n! Types. Check duckdb/function/table/arrow/arrow_duck_schema.hpp for more details! Must be destroyed with\n! `duckdb_destroy_arrow_converted_schema`"]
+pub type duckdb_arrow_converted_schema = *mut _duckdb_arrow_converted_schema;
+#[doc = "! Holds an arrow array. Remember to release the respective ArrowSchema object."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_array {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow array. Remember to release the respective ArrowSchema object."]
+pub type duckdb_arrow_array = *mut _duckdb_arrow_array;
+#[doc = "! The arrow options used when transforming the DuckDB schema and datachunks into Arrow schema and arrays.\n! Used in `duckdb_to_arrow_schema` and `duckdb_data_chunk_to_arrow`"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_options {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The arrow options used when transforming the DuckDB schema and datachunks into Arrow schema and arrays.\n! Used in `duckdb_to_arrow_schema` and `duckdb_data_chunk_to_arrow`"]
+pub type duckdb_arrow_options = *mut _duckdb_arrow_options;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_file_open_options {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+pub type duckdb_file_open_options = *mut _duckdb_file_open_options;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_file_system {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+pub type duckdb_file_system = *mut _duckdb_file_system;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_file_handle {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+pub type duckdb_file_handle = *mut _duckdb_file_handle;
+#[doc = "! A handle to a database catalog.\n! Must be destroyed with `duckdb_destroy_catalog`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_catalog {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A handle to a database catalog.\n! Must be destroyed with `duckdb_destroy_catalog`."]
+pub type duckdb_catalog = *mut _duckdb_catalog;
+#[doc = "! A handle to a catalog entry (e.g., table, view, index, etc.).\n! Must be destroyed with `duckdb_destroy_catalog_entry`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_catalog_entry {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A handle to a catalog entry (e.g., table, view, index, etc.).\n! Must be destroyed with `duckdb_destroy_catalog_entry`."]
+pub type duckdb_catalog_entry = *mut _duckdb_catalog_entry;
+#[doc = "! Holds a log storage object."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_log_storage {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds a log storage object."]
+pub type duckdb_log_storage = *mut _duckdb_log_storage;
+#[doc = "! This function is missing the logging context, which will be added later."]
+pub type duckdb_logger_write_log_entry_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        extra_data: *mut ::std::os::raw::c_void,
+        timestamp: *mut duckdb_timestamp,
+        level: *const ::std::os::raw::c_char,
+        log_type: *const ::std::os::raw::c_char,
+        log_message: *const ::std::os::raw::c_char,
+    ),
+>;
+#[doc = "! Passed to C API extension as a parameter to the entrypoint."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_extension_access {
+    #[doc = "! Indicate that an error has occurred."]
+    pub set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_extension_info, error: *const ::std::os::raw::c_char)>,
+    #[doc = "! Fetch the database on which to register the extension."]
+    pub get_database: ::std::option::Option<unsafe extern "C" fn(info: duckdb_extension_info) -> *mut duckdb_database>,
+    #[doc = "! Fetch the API struct pointer."]
+    pub get_api: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_extension_info,
+            version: *const ::std::os::raw::c_char,
+        ) -> *const ::std::os::raw::c_void,
+    >,
+}
+unsafe extern "C" {
+    #[doc = "Creates a new database instance cache.\nThe instance cache is necessary if a client/program (re)opens multiple databases to the same file within the same\nprocess. Must be destroyed with 'duckdb_destroy_instance_cache'.\n\n @return The database instance cache."]
+    pub fn duckdb_create_instance_cache() -> duckdb_instance_cache;
+}
+unsafe extern "C" {
+    #[doc = "Creates a new database instance in the instance cache, or retrieves an existing database instance.\nMust be closed with 'duckdb_close'.\n\n @param instance_cache The instance cache in which to create the database, or from which to take the database.\n @param path Path to the database file on disk. Both `nullptr` and `:memory:` open or retrieve an in-memory database.\n @param out_database The resulting cached database.\n @param config (Optional) configuration used to create the database.\n @param out_error If set and the function returns `DuckDBError`, this contains the error message.\nNote that the error message must be freed using `duckdb_free`.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_get_or_create_from_cache(
+        instance_cache: duckdb_instance_cache,
+        path: *const ::std::os::raw::c_char,
+        out_database: *mut duckdb_database,
+        config: duckdb_config,
+        out_error: *mut *mut ::std::os::raw::c_char,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Destroys an existing database instance cache and de-allocates its memory.\n\n @param instance_cache The instance cache to destroy."]
+    pub fn duckdb_destroy_instance_cache(instance_cache: *mut duckdb_instance_cache);
+}
+unsafe extern "C" {
+    #[doc = "Creates a new database or opens an existing database file stored at the given path.\nIf no path is given a new in-memory database is created instead.\nThe database must be closed with 'duckdb_close'.\n\n @param path Path to the database file on disk. Both `nullptr` and `:memory:` open an in-memory database.\n @param out_database The result database object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_open(path: *const ::std::os::raw::c_char, out_database: *mut duckdb_database) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Extended version of duckdb_open. Creates a new database or opens an existing database file stored at the given path.\nThe database must be closed with 'duckdb_close'.\n\n @param path Path to the database file on disk. Both `nullptr` and `:memory:` open an in-memory database.\n @param out_database The result database object.\n @param config (Optional) configuration used to start up the database.\n @param out_error If set and the function returns `DuckDBError`, this contains the error message.\nNote that the error message must be freed using `duckdb_free`.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_open_ext(
+        path: *const ::std::os::raw::c_char,
+        out_database: *mut duckdb_database,
+        config: duckdb_config,
+        out_error: *mut *mut ::std::os::raw::c_char,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Closes the specified database and de-allocates all memory allocated for that database.\nThis should be called after you are done with any database allocated through `duckdb_open` or `duckdb_open_ext`.\nNote that failing to call `duckdb_close` (in case of e.g. a program crash) will not cause data corruption.\nStill, it is recommended to always correctly close a database object after you are done with it.\n\n @param database The database object to shut down."]
+    pub fn duckdb_close(database: *mut duckdb_database);
+}
+unsafe extern "C" {
+    #[doc = "Opens a connection to a database. Connections are required to query the database, and store transactional state\nassociated with the connection.\nThe instantiated connection should be closed using 'duckdb_disconnect'.\n\n @param database The database file to connect to.\n @param out_connection The result connection object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_connect(database: duckdb_database, out_connection: *mut duckdb_connection) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Interrupt running query\n\n @param connection The connection to interrupt"]
+    pub fn duckdb_interrupt(connection: duckdb_connection);
+}
+unsafe extern "C" {
+    #[doc = "Get the progress of the running query.\n\n @param connection The connection running the query.\n @return The query progress type containing progress information."]
+    pub fn duckdb_query_progress(connection: duckdb_connection) -> duckdb_query_progress_type;
+}
+unsafe extern "C" {
+    #[doc = "Closes the specified connection and de-allocates all memory allocated for that connection.\n\n @param connection The connection to close."]
+    pub fn duckdb_disconnect(connection: *mut duckdb_connection);
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the client context of the connection.\n\n @param connection The connection.\n @param out_context The client context of the connection. Must be destroyed with `duckdb_destroy_client_context`."]
+    pub fn duckdb_connection_get_client_context(connection: duckdb_connection, out_context: *mut duckdb_client_context);
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the arrow options of the connection.\n\n @param connection The connection."]
+    pub fn duckdb_connection_get_arrow_options(
+        connection: duckdb_connection,
+        out_arrow_options: *mut duckdb_arrow_options,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Returns the connection id of the client context.\n\n @param context The client context.\n @return The connection id of the client context."]
+    pub fn duckdb_client_context_get_connection_id(context: duckdb_client_context) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the client context and deallocates its memory.\n\n @param context The client context to destroy."]
+    pub fn duckdb_destroy_client_context(context: *mut duckdb_client_context);
+}
+unsafe extern "C" {
+    #[doc = "Destroys the arrow options and deallocates its memory.\n\n @param arrow_options The arrow options to destroy."]
+    pub fn duckdb_destroy_arrow_options(arrow_options: *mut duckdb_arrow_options);
+}
+unsafe extern "C" {
+    #[doc = "Returns the version of the linked DuckDB, with a version postfix for dev versions\n\nUsually used for developing C extensions that must return this for a compatibility check."]
+    pub fn duckdb_library_version() -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Get the list of (fully qualified) table names of the query.\n\n @param connection The connection for which to get the table names.\n @param query The query for which to get the table names.\n @param qualified Returns fully qualified table names (catalog.schema.table), if set to true, else only the (not\nescaped) table names.\n @return A duckdb_value of type VARCHAR[] containing the (fully qualified) table names of the query. Must be destroyed\nwith duckdb_destroy_value."]
+    pub fn duckdb_get_table_names(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        qualified: bool,
+    ) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Initializes an empty configuration object that can be used to provide start-up options for the DuckDB instance\nthrough `duckdb_open_ext`.\nThe duckdb_config must be destroyed using 'duckdb_destroy_config'\n\nThis will always succeed unless there is a malloc failure.\n\nNote that `duckdb_destroy_config` should always be called on the resulting config, even if the function returns\n`DuckDBError`.\n\n @param out_config The result configuration object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_create_config(out_config: *mut duckdb_config) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "This returns the total amount of configuration options available for usage with `duckdb_get_config_flag`.\n\nThis should not be called in a loop as it internally loops over all the options.\n\n @return The amount of config options available."]
+    pub fn duckdb_config_count() -> usize;
+}
+unsafe extern "C" {
+    #[doc = "Obtains a human-readable name and description of a specific configuration option. This can be used to e.g.\ndisplay configuration options. This will succeed unless `index` is out of range (i.e. `>= duckdb_config_count`).\n\nThe result name or description MUST NOT be freed.\n\n @param index The index of the configuration option (between 0 and `duckdb_config_count`)\n @param out_name A name of the configuration flag.\n @param out_description A description of the configuration flag.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_get_config_flag(
+        index: usize,
+        out_name: *mut *const ::std::os::raw::c_char,
+        out_description: *mut *const ::std::os::raw::c_char,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Sets the specified option for the specified configuration. The configuration option is indicated by name.\nTo obtain a list of config options, see `duckdb_get_config_flag`.\n\nIn the source code, configuration options are defined in `config.cpp`.\n\nThis can fail if either the name is invalid, or if the value provided for the option is invalid.\n\n @param config The configuration object to set the option on.\n @param name The name of the configuration flag to set.\n @param option The value to set the configuration flag to.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_set_config(
+        config: duckdb_config,
+        name: *const ::std::os::raw::c_char,
+        option: *const ::std::os::raw::c_char,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the specified configuration object and de-allocates all memory allocated for the object.\n\n @param config The configuration object to destroy."]
+    pub fn duckdb_destroy_config(config: *mut duckdb_config);
+}
+unsafe extern "C" {
+    #[doc = "Creates duckdb_error_data.\nMust be destroyed with `duckdb_destroy_error_data`.\n\n @param type The error type.\n @param message The error message.\n @return The error data."]
+    pub fn duckdb_create_error_data(
+        type_: duckdb_error_type,
+        message: *const ::std::os::raw::c_char,
+    ) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the error data and deallocates its memory.\n\n @param error_data The error data to destroy."]
+    pub fn duckdb_destroy_error_data(error_data: *mut duckdb_error_data);
+}
+unsafe extern "C" {
+    #[doc = "Returns the duckdb_error_type of the error data.\n\n @param error_data The error data.\n @return The error type."]
+    pub fn duckdb_error_data_error_type(error_data: duckdb_error_data) -> duckdb_error_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the error message of the error data. Must not be freed.\n\n @param error_data The error data.\n @return The error message."]
+    pub fn duckdb_error_data_message(error_data: duckdb_error_data) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Returns whether the error data contains an error or not.\n\n @param error_data The error data.\n @return True, if the error data contains an exception, else false."]
+    pub fn duckdb_error_data_has_error(error_data: duckdb_error_data) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Executes a SQL query within a connection and stores the full (materialized) result in the out_result pointer.\nIf the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling\n`duckdb_result_error`.\n\nNote that after running `duckdb_query`, `duckdb_destroy_result` must be called on the result object even if the\nquery fails, otherwise the error stored within the result will not be freed correctly.\n\n @param connection The connection to perform the query in.\n @param query The SQL query to run.\n @param out_result The query result.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_query(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        out_result: *mut duckdb_result,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Closes the result and de-allocates all memory allocated for that result.\n\n @param result The result to destroy."]
+    pub fn duckdb_destroy_result(result: *mut duckdb_result);
+}
+unsafe extern "C" {
+    #[doc = "Returns the column name of the specified column. The result should not need to be freed; the column names will\nautomatically be destroyed when the result is destroyed.\n\nReturns `NULL` if the column is out of range.\n\n @param result The result object to fetch the column name from.\n @param col The column index.\n @return The column name of the specified column."]
+    pub fn duckdb_column_name(result: *mut duckdb_result, col: idx_t) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Returns the column type of the specified column.\n\nReturns `DUCKDB_TYPE_INVALID` if the column is out of range.\n\n @param result The result object to fetch the column type from.\n @param col The column index.\n @return The column type of the specified column."]
+    pub fn duckdb_column_type(result: *mut duckdb_result, col: idx_t) -> duckdb_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the statement type of the statement that was executed\n\n @param result The result object to fetch the statement type from.\n @return duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID"]
+    pub fn duckdb_result_statement_type(result: duckdb_result) -> duckdb_statement_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the logical column type of the specified column.\n\nThe return type of this call should be destroyed with `duckdb_destroy_logical_type`.\n\nReturns `NULL` if the column is out of range.\n\n @param result The result object to fetch the column type from.\n @param col The column index.\n @return The logical column type of the specified column."]
+    pub fn duckdb_column_logical_type(result: *mut duckdb_result, col: idx_t) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the arrow options associated with the given result. These options are definitions of how the arrow arrays/schema\nshould be produced.\n @param result The result object to fetch arrow options from.\n @return The arrow options associated with the given result. This must be destroyed with\n`duckdb_destroy_arrow_options`."]
+    pub fn duckdb_result_get_arrow_options(result: *mut duckdb_result) -> duckdb_arrow_options;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of columns present in a the result object.\n\n @param result The result object.\n @return The number of columns present in the result object."]
+    pub fn duckdb_column_count(result: *mut duckdb_result) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nReturns the number of rows present in the result object.\n\n @param result The result object.\n @return The number of rows present in the result object."]
+    pub fn duckdb_row_count(result: *mut duckdb_result) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of rows changed by the query stored in the result. This is relevant only for INSERT/UPDATE/DELETE\nqueries. For other queries the rows_changed will be 0.\n\n @param result The result object.\n @return The number of rows changed."]
+    pub fn duckdb_rows_changed(result: *mut duckdb_result) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATED**: Prefer using `duckdb_result_get_chunk` instead.\n\nReturns the data of a specific column of a result in columnar format.\n\nThe function returns a dense array which contains the result data. The exact type stored in the array depends on the\ncorresponding duckdb_type (as provided by `duckdb_column_type`). For the exact type by which the data should be\naccessed, see the comments in [the types section](types) or the `DUCKDB_TYPE` enum.\n\nFor example, for a column of type `DUCKDB_TYPE_INTEGER`, rows can be accessed in the following manner:\n```c\nint32_t *data = (int32_t *) duckdb_column_data(&result, 0);\nprintf(\"Data for row %d: %d\\n\", row, data[row]);\n```\n\n @param result The result object to fetch the column data from.\n @param col The column index.\n @return The column data of the specified column."]
+    pub fn duckdb_column_data(result: *mut duckdb_result, col: idx_t) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATED**: Prefer using `duckdb_result_get_chunk` instead.\n\nReturns the nullmask of a specific column of a result in columnar format. The nullmask indicates for every row\nwhether or not the corresponding row is `NULL`. If a row is `NULL`, the values present in the array provided\nby `duckdb_column_data` are undefined.\n\n```c\nint32_t *data = (int32_t *) duckdb_column_data(&result, 0);\nbool *nullmask = duckdb_nullmask_data(&result, 0);\nif (nullmask[row]) {\nprintf(\"Data for row %d: NULL\\n\", row);\n} else {\nprintf(\"Data for row %d: %d\\n\", row, data[row]);\n}\n```\n\n @param result The result object to fetch the nullmask from.\n @param col The column index.\n @return The nullmask of the specified column."]
+    pub fn duckdb_nullmask_data(result: *mut duckdb_result, col: idx_t) -> *mut bool;
+}
+unsafe extern "C" {
+    #[doc = "Returns the error message contained within the result. The error is only set if `duckdb_query` returns `DuckDBError`.\n\nThe result of this function must not be freed. It will be cleaned up when `duckdb_destroy_result` is called.\n\n @param result The result object to fetch the error from.\n @return The error of the result."]
+    pub fn duckdb_result_error(result: *mut duckdb_result) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Returns the result error type contained within the result. The error is only set if `duckdb_query` returns\n`DuckDBError`.\n\n @param result The result object to fetch the error from.\n @return The error type of the result."]
+    pub fn duckdb_result_error_type(result: *mut duckdb_result) -> duckdb_error_type;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nFetches a data chunk from the duckdb_result. This function should be called repeatedly until the result is exhausted.\n\nThe result must be destroyed with `duckdb_destroy_data_chunk`.\n\nThis function supersedes all `duckdb_value` functions, as well as the `duckdb_column_data` and `duckdb_nullmask_data`\nfunctions. It results in significantly better performance, and should be preferred in newer code-bases.\n\nIf this function is used, none of the other result functions can be used and vice versa (i.e. this function cannot be\nmixed with the legacy result functions).\n\nUse `duckdb_result_chunk_count` to figure out how many chunks there are in the result.\n\n @param result The result object to fetch the data chunk from.\n @param chunk_index The chunk index to fetch from.\n @return The resulting data chunk. Returns `NULL` if the chunk index is out of bounds."]
+    pub fn duckdb_result_get_chunk(result: duckdb_result, chunk_index: idx_t) -> duckdb_data_chunk;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nChecks if the type of the internal result is StreamQueryResult.\n\n @param result The result object to check.\n @return Whether or not the result object is of the type StreamQueryResult"]
+    pub fn duckdb_result_is_streaming(result: duckdb_result) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nReturns the number of data chunks present in the result.\n\n @param result The result object\n @return Number of data chunks present in the result."]
+    pub fn duckdb_result_chunk_count(result: duckdb_result) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the return_type of the given result, or DUCKDB_RETURN_TYPE_INVALID on error\n\n @param result The result object\n @return The return_type"]
+    pub fn duckdb_result_return_type(result: duckdb_result) -> duckdb_result_type;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The boolean value at the specified location, or false if the value cannot be converted."]
+    pub fn duckdb_value_boolean(result: *mut duckdb_result, col: idx_t, row: idx_t) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The int8_t value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_int8(result: *mut duckdb_result, col: idx_t, row: idx_t) -> i8;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The int16_t value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_int16(result: *mut duckdb_result, col: idx_t, row: idx_t) -> i16;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The int32_t value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_int32(result: *mut duckdb_result, col: idx_t, row: idx_t) -> i32;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The int64_t value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_int64(result: *mut duckdb_result, col: idx_t, row: idx_t) -> i64;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The duckdb_hugeint value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_hugeint(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_hugeint;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The duckdb_uhugeint value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_uhugeint(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_uhugeint;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The duckdb_decimal value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_decimal(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_decimal;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The uint8_t value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_uint8(result: *mut duckdb_result, col: idx_t, row: idx_t) -> u8;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The uint16_t value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_uint16(result: *mut duckdb_result, col: idx_t, row: idx_t) -> u16;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The uint32_t value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_uint32(result: *mut duckdb_result, col: idx_t, row: idx_t) -> u32;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The uint64_t value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_uint64(result: *mut duckdb_result, col: idx_t, row: idx_t) -> u64;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The float value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_float(result: *mut duckdb_result, col: idx_t, row: idx_t) -> f32;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The double value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_double(result: *mut duckdb_result, col: idx_t, row: idx_t) -> f64;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The duckdb_date value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_date(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_date;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The duckdb_time value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_time(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_time;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The duckdb_timestamp value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_timestamp(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_timestamp;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The duckdb_interval value at the specified location, or 0 if the value cannot be converted."]
+    pub fn duckdb_value_interval(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_interval;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The text value at the specified location as a null-terminated string, or nullptr if the value cannot be\nconverted. The result must be freed with `duckdb_free`."]
+    pub fn duckdb_value_varchar(result: *mut duckdb_result, col: idx_t, row: idx_t) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The string value at the specified location. Attempts to cast the result value to string."]
+    pub fn duckdb_value_string(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_string;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.\nIf the column is NOT a VARCHAR column this function will return NULL.\n\nThe result must NOT be freed."]
+    pub fn duckdb_value_varchar_internal(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.\nIf the column is NOT a VARCHAR column this function will return NULL.\n\nThe result must NOT be freed."]
+    pub fn duckdb_value_string_internal(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_string;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return The duckdb_blob value at the specified location. Returns a blob with blob.data set to nullptr if the\nvalue cannot be converted. The resulting field \"blob.data\" must be freed with `duckdb_free.`"]
+    pub fn duckdb_value_blob(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_blob;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\n @return Returns true if the value at the specified index is NULL, and false otherwise."]
+    pub fn duckdb_value_is_null(result: *mut duckdb_result, col: idx_t, row: idx_t) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Allocate `size` bytes of memory using the duckdb internal malloc function. Any memory allocated in this manner\nshould be freed using `duckdb_free`.\n\n @param size The number of bytes to allocate.\n @return A pointer to the allocated memory region."]
+    pub fn duckdb_malloc(size: usize) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Free a value returned from `duckdb_malloc`, `duckdb_value_varchar`, `duckdb_value_blob`, or\n`duckdb_value_string`.\n\n @param ptr The memory region to de-allocate."]
+    pub fn duckdb_free(ptr: *mut ::std::os::raw::c_void);
+}
+unsafe extern "C" {
+    #[doc = "The internal vector size used by DuckDB.\nThis is the amount of tuples that will fit into a data chunk created by `duckdb_create_data_chunk`.\n\n @return The vector size."]
+    pub fn duckdb_vector_size() -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Whether or not the duckdb_string_t value is inlined.\nThis means that the data of the string does not have a separate allocation."]
+    pub fn duckdb_string_is_inlined(string: duckdb_string_t) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Get the string length of a string_t\n\n @param string The string to get the length of.\n @return The length."]
+    pub fn duckdb_string_t_length(string: duckdb_string_t) -> u32;
+}
+unsafe extern "C" {
+    #[doc = "Get a pointer to the string data of a string_t\n\n @param string The string to get the pointer to.\n @return The pointer."]
+    pub fn duckdb_string_t_data(string: *mut duckdb_string_t) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Checks if a string is valid UTF-8.\n\n @param str The string to check\n @param len The length of the string (in bytes)\n @return nullptr if the string is valid UTF-8. Otherwise, a duckdb_error_data containing error information. Must be\ndestroyed with `duckdb_destroy_error_data`."]
+    pub fn duckdb_valid_utf8_check(str_: *const ::std::os::raw::c_char, len: idx_t) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Decompose a `duckdb_date` object into year, month and date (stored as `duckdb_date_struct`).\n\n @param date The date object, as obtained from a `DUCKDB_TYPE_DATE` column.\n @return The `duckdb_date_struct` with the decomposed elements."]
+    pub fn duckdb_from_date(date: duckdb_date) -> duckdb_date_struct;
+}
+unsafe extern "C" {
+    #[doc = "Re-compose a `duckdb_date` from year, month and date (`duckdb_date_struct`).\n\n @param date The year, month and date stored in a `duckdb_date_struct`.\n @return The `duckdb_date` element."]
+    pub fn duckdb_to_date(date: duckdb_date_struct) -> duckdb_date;
+}
+unsafe extern "C" {
+    #[doc = "Test a `duckdb_date` to see if it is a finite value.\n\n @param date The date object, as obtained from a `DUCKDB_TYPE_DATE` column.\n @return True if the date is finite, false if it is ±infinity."]
+    pub fn duckdb_is_finite_date(date: duckdb_date) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Decompose a `duckdb_time` object into hour, minute, second and microsecond (stored as `duckdb_time_struct`).\n\n @param time The time object, as obtained from a `DUCKDB_TYPE_TIME` column.\n @return The `duckdb_time_struct` with the decomposed elements."]
+    pub fn duckdb_from_time(time: duckdb_time) -> duckdb_time_struct;
+}
+unsafe extern "C" {
+    #[doc = "Create a `duckdb_time_tz` object from micros and a timezone offset.\n\n @param micros The microsecond component of the time.\n @param offset The timezone offset component of the time.\n @return The `duckdb_time_tz` element."]
+    pub fn duckdb_create_time_tz(micros: i64, offset: i32) -> duckdb_time_tz;
+}
+unsafe extern "C" {
+    #[doc = "Decompose a TIME_TZ objects into micros and a timezone offset.\n\nUse `duckdb_from_time` to further decompose the micros into hour, minute, second and microsecond.\n\n @param micros The time object, as obtained from a `DUCKDB_TYPE_TIME_TZ` column."]
+    pub fn duckdb_from_time_tz(micros: duckdb_time_tz) -> duckdb_time_tz_struct;
+}
+unsafe extern "C" {
+    #[doc = "Re-compose a `duckdb_time` from hour, minute, second and microsecond (`duckdb_time_struct`).\n\n @param time The hour, minute, second and microsecond in a `duckdb_time_struct`.\n @return The `duckdb_time` element."]
+    pub fn duckdb_to_time(time: duckdb_time_struct) -> duckdb_time;
+}
+unsafe extern "C" {
+    #[doc = "Decompose a `duckdb_timestamp` object into a `duckdb_timestamp_struct`.\n\n @param ts The ts object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.\n @return The `duckdb_timestamp_struct` with the decomposed elements."]
+    pub fn duckdb_from_timestamp(ts: duckdb_timestamp) -> duckdb_timestamp_struct;
+}
+unsafe extern "C" {
+    #[doc = "Re-compose a `duckdb_timestamp` from a duckdb_timestamp_struct.\n\n @param ts The de-composed elements in a `duckdb_timestamp_struct`.\n @return The `duckdb_timestamp` element."]
+    pub fn duckdb_to_timestamp(ts: duckdb_timestamp_struct) -> duckdb_timestamp;
+}
+unsafe extern "C" {
+    #[doc = "Test a `duckdb_timestamp` to see if it is a finite value.\n\n @param ts The duckdb_timestamp object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.\n @return True if the timestamp is finite, false if it is ±infinity."]
+    pub fn duckdb_is_finite_timestamp(ts: duckdb_timestamp) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Test a `duckdb_timestamp_s` to see if it is a finite value.\n\n @param ts The duckdb_timestamp_s object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_S` column.\n @return True if the timestamp is finite, false if it is ±infinity."]
+    pub fn duckdb_is_finite_timestamp_s(ts: duckdb_timestamp_s) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Test a `duckdb_timestamp_ms` to see if it is a finite value.\n\n @param ts The duckdb_timestamp_ms object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_MS` column.\n @return True if the timestamp is finite, false if it is ±infinity."]
+    pub fn duckdb_is_finite_timestamp_ms(ts: duckdb_timestamp_ms) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Test a `duckdb_timestamp_ns` to see if it is a finite value.\n\n @param ts The duckdb_timestamp_ns object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_NS` column.\n @return True if the timestamp is finite, false if it is ±infinity."]
+    pub fn duckdb_is_finite_timestamp_ns(ts: duckdb_timestamp_ns) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Converts a duckdb_hugeint object (as obtained from a `DUCKDB_TYPE_HUGEINT` column) into a double.\n\n @param val The hugeint value.\n @return The converted `double` element."]
+    pub fn duckdb_hugeint_to_double(val: duckdb_hugeint) -> f64;
+}
+unsafe extern "C" {
+    #[doc = "Converts a double value to a duckdb_hugeint object.\n\nIf the conversion fails because the double value is too big the result will be 0.\n\n @param val The double value.\n @return The converted `duckdb_hugeint` element."]
+    pub fn duckdb_double_to_hugeint(val: f64) -> duckdb_hugeint;
+}
+unsafe extern "C" {
+    #[doc = "Converts a duckdb_uhugeint object (as obtained from a `DUCKDB_TYPE_UHUGEINT` column) into a double.\n\n @param val The uhugeint value.\n @return The converted `double` element."]
+    pub fn duckdb_uhugeint_to_double(val: duckdb_uhugeint) -> f64;
+}
+unsafe extern "C" {
+    #[doc = "Converts a double value to a duckdb_uhugeint object.\n\nIf the conversion fails because the double value is too big the result will be 0.\n\n @param val The double value.\n @return The converted `duckdb_uhugeint` element."]
+    pub fn duckdb_double_to_uhugeint(val: f64) -> duckdb_uhugeint;
+}
+unsafe extern "C" {
+    #[doc = "Converts a double value to a duckdb_decimal object.\n\nIf the conversion fails because the double value is too big, or the width/scale are invalid the result will be 0.\n\n @param val The double value.\n @return The converted `duckdb_decimal` element."]
+    pub fn duckdb_double_to_decimal(val: f64, width: u8, scale: u8) -> duckdb_decimal;
+}
+unsafe extern "C" {
+    #[doc = "Converts a duckdb_decimal object (as obtained from a `DUCKDB_TYPE_DECIMAL` column) into a double.\n\n @param val The decimal value.\n @return The converted `double` element."]
+    pub fn duckdb_decimal_to_double(val: duckdb_decimal) -> f64;
+}
+unsafe extern "C" {
+    #[doc = "Create a prepared statement object from a query.\n\nNote that after calling `duckdb_prepare`, the prepared statement should always be destroyed using\n`duckdb_destroy_prepare`, even if the prepare fails.\n\nIf the prepare fails, `duckdb_prepare_error` can be called to obtain the reason why the prepare failed.\n\n @param connection The connection object\n @param query The SQL query to prepare\n @param out_prepared_statement The resulting prepared statement object\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_prepare(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        out_prepared_statement: *mut duckdb_prepared_statement,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Closes the prepared statement and de-allocates all memory allocated for the statement.\n\n @param prepared_statement The prepared statement to destroy."]
+    pub fn duckdb_destroy_prepare(prepared_statement: *mut duckdb_prepared_statement);
+}
+unsafe extern "C" {
+    #[doc = "Returns the error message associated with the given prepared statement.\nIf the prepared statement has no error message, this returns `nullptr` instead.\n\nThe error message should not be freed. It will be de-allocated when `duckdb_destroy_prepare` is called.\n\n @param prepared_statement The prepared statement to obtain the error from.\n @return The error message, or `nullptr` if there is none."]
+    pub fn duckdb_prepare_error(prepared_statement: duckdb_prepared_statement) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of parameters that can be provided to the given prepared statement.\n\nReturns 0 if the query was not successfully prepared.\n\n @param prepared_statement The prepared statement to obtain the number of parameters for."]
+    pub fn duckdb_nparams(prepared_statement: duckdb_prepared_statement) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the name used to identify the parameter\nThe returned string should be freed using `duckdb_free`.\n\nReturns NULL if the index is out of range for the provided prepared statement.\n\n @param prepared_statement The prepared statement for which to get the parameter name from."]
+    pub fn duckdb_parameter_name(
+        prepared_statement: duckdb_prepared_statement,
+        index: idx_t,
+    ) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Returns the parameter type for the parameter at the given index.\n\nReturns `DUCKDB_TYPE_INVALID` if the parameter index is out of range or the statement was not successfully prepared.\n\n @param prepared_statement The prepared statement.\n @param param_idx The parameter index.\n @return The parameter type"]
+    pub fn duckdb_param_type(prepared_statement: duckdb_prepared_statement, param_idx: idx_t) -> duckdb_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the logical type for the parameter at the given index.\n\nReturns `nullptr` if the parameter index is out of range or the statement was not successfully prepared.\n\nThe return type of this call should be destroyed with `duckdb_destroy_logical_type`.\n\n @param prepared_statement The prepared statement.\n @param param_idx The parameter index.\n @return The logical type of the parameter"]
+    pub fn duckdb_param_logical_type(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Clear the params bind to the prepared statement."]
+    pub fn duckdb_clear_bindings(prepared_statement: duckdb_prepared_statement) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Returns the statement type of the statement to be executed\n\n @param statement The prepared statement.\n @return duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID"]
+    pub fn duckdb_prepared_statement_type(statement: duckdb_prepared_statement) -> duckdb_statement_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of columns present in a the result of the prepared statement. If any of the column types are invalid,\nthe result will be 1.\n\n @param prepared_statement The prepared statement.\n @return The number of columns present in the result of the prepared statement."]
+    pub fn duckdb_prepared_statement_column_count(prepared_statement: duckdb_prepared_statement) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the name of the specified column of the result of the prepared_statement.\nThe returned string should be freed using `duckdb_free`.\n\nReturns `nullptr` if the column is out of range.\n\n @param prepared_statement The prepared statement.\n @param col_idx The column index.\n @return The column name of the specified column."]
+    pub fn duckdb_prepared_statement_column_name(
+        prepared_statement: duckdb_prepared_statement,
+        col_idx: idx_t,
+    ) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Returns the column type of the specified column of the result of the prepared_statement.\n\nReturns `DUCKDB_TYPE_INVALID` if the column is out of range.\nThe return type of this call should be destroyed with `duckdb_destroy_logical_type`.\n\n @param prepared_statement The prepared statement to fetch the column type from.\n @param col_idx The column index.\n @return The logical type of the specified column."]
+    pub fn duckdb_prepared_statement_column_logical_type(
+        prepared_statement: duckdb_prepared_statement,
+        col_idx: idx_t,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the column type of the specified column of the result of the prepared_statement.\n\nReturns `DUCKDB_TYPE_INVALID` if the column is out of range.\n\n @param prepared_statement The prepared statement to fetch the column type from.\n @param col_idx The column index.\n @return The type of the specified column."]
+    pub fn duckdb_prepared_statement_column_type(
+        prepared_statement: duckdb_prepared_statement,
+        col_idx: idx_t,
+    ) -> duckdb_type;
+}
+unsafe extern "C" {
+    #[doc = "Binds a value to the prepared statement at the specified index.\n\nSupersedes all type-specific bind functions (e.g., `duckdb_bind_varchar`, `duckdb_bind_int64`, etc.)."]
+    pub fn duckdb_bind_value(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_value,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Retrieve the index of the parameter for the prepared statement, identified by name"]
+    pub fn duckdb_bind_parameter_index(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx_out: *mut idx_t,
+        name: *const ::std::os::raw::c_char,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a bool value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_boolean(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: bool,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds an int8_t value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_int8(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: i8) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds an int16_t value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_int16(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: i16)
+    -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds an int32_t value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_int32(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: i32)
+    -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds an int64_t value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_int64(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: i64)
+    -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a duckdb_hugeint value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_hugeint(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_hugeint,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a duckdb_uhugeint value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_uhugeint(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_uhugeint,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a duckdb_decimal value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_decimal(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_decimal,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a uint8_t value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_uint8(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: u8) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a uint16_t value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_uint16(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: u16,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a uint32_t value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_uint32(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: u32,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a uint64_t value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_uint64(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: u64,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a float value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_float(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: f32)
+    -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a double value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_double(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: f64,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a duckdb_date value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_date(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_date,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a duckdb_time value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_time(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_time,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a duckdb_timestamp value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_timestamp(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_timestamp,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a duckdb_timestamp value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_timestamp_tz(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_timestamp,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a duckdb_interval value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_interval(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_interval,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a null-terminated varchar value to the prepared statement at the specified index.\n\nSuperseded by `duckdb_bind_value`."]
+    pub fn duckdb_bind_varchar(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: *const ::std::os::raw::c_char,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a varchar value to the prepared statement at the specified index.\n\nSuperseded by `duckdb_bind_value`."]
+    pub fn duckdb_bind_varchar_length(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: *const ::std::os::raw::c_char,
+        length: idx_t,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a blob value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_blob(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        data: *const ::std::os::raw::c_void,
+        length: idx_t,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Binds a NULL value to the prepared statement at the specified index."]
+    pub fn duckdb_bind_null(prepared_statement: duckdb_prepared_statement, param_idx: idx_t) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Executes the prepared statement with the given bound parameters, and returns a materialized query result.\n\nThis method can be called multiple times for each prepared statement, and the parameters can be modified\nbetween calls to this function.\n\nNote that the result must be freed with `duckdb_destroy_result`.\n\n @param prepared_statement The prepared statement to execute.\n @param out_result The query result.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_execute_prepared(
+        prepared_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_result,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nExecutes the prepared statement with the given bound parameters, and returns an optionally-streaming query result.\nTo determine if the resulting query was in fact streamed, use `duckdb_result_is_streaming`\n\nThis method can be called multiple times for each prepared statement, and the parameters can be modified\nbetween calls to this function.\n\nNote that the result must be freed with `duckdb_destroy_result`.\n\n @param prepared_statement The prepared statement to execute.\n @param out_result The query result.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_execute_prepared_streaming(
+        prepared_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_result,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Extract all statements from a query.\nNote that after calling `duckdb_extract_statements`, the extracted statements should always be destroyed using\n`duckdb_destroy_extracted`, even if no statements were extracted.\n\nIf the extract fails, `duckdb_extract_statements_error` can be called to obtain the reason why the extract failed.\n\n @param connection The connection object\n @param query The SQL query to extract\n @param out_extracted_statements The resulting extracted statements object\n @return The number of extracted statements or 0 on failure."]
+    pub fn duckdb_extract_statements(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        out_extracted_statements: *mut duckdb_extracted_statements,
+    ) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Prepare an extracted statement.\nNote that after calling `duckdb_prepare_extracted_statement`, the prepared statement should always be destroyed using\n`duckdb_destroy_prepare`, even if the prepare fails.\n\nIf the prepare fails, `duckdb_prepare_error` can be called to obtain the reason why the prepare failed.\n\n @param connection The connection object\n @param extracted_statements The extracted statements object\n @param index The index of the extracted statement to prepare\n @param out_prepared_statement The resulting prepared statement object\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_prepare_extracted_statement(
+        connection: duckdb_connection,
+        extracted_statements: duckdb_extracted_statements,
+        index: idx_t,
+        out_prepared_statement: *mut duckdb_prepared_statement,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Returns the error message contained within the extracted statements.\nThe result of this function must not be freed. It will be cleaned up when `duckdb_destroy_extracted` is called.\n\n @param extracted_statements The extracted statements to fetch the error from.\n @return The error of the extracted statements."]
+    pub fn duckdb_extract_statements_error(
+        extracted_statements: duckdb_extracted_statements,
+    ) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "De-allocates all memory allocated for the extracted statements.\n @param extracted_statements The extracted statements to destroy."]
+    pub fn duckdb_destroy_extracted(extracted_statements: *mut duckdb_extracted_statements);
+}
+unsafe extern "C" {
+    #[doc = "Executes the prepared statement with the given bound parameters, and returns a pending result.\nThe pending result represents an intermediate structure for a query that is not yet fully executed.\nThe pending result can be used to incrementally execute a query, returning control to the client between tasks.\n\nNote that after calling `duckdb_pending_prepared`, the pending result should always be destroyed using\n`duckdb_destroy_pending`, even if this function returns DuckDBError.\n\n @param prepared_statement The prepared statement to execute.\n @param out_result The pending query result.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_pending_prepared(
+        prepared_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_pending_result,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nExecutes the prepared statement with the given bound parameters, and returns a pending result.\nThis pending result will create a streaming duckdb_result when executed.\nThe pending result represents an intermediate structure for a query that is not yet fully executed.\n\nNote that after calling `duckdb_pending_prepared_streaming`, the pending result should always be destroyed using\n`duckdb_destroy_pending`, even if this function returns DuckDBError.\n\n @param prepared_statement The prepared statement to execute.\n @param out_result The pending query result.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_pending_prepared_streaming(
+        prepared_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_pending_result,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Closes the pending result and de-allocates all memory allocated for the result.\n\n @param pending_result The pending result to destroy."]
+    pub fn duckdb_destroy_pending(pending_result: *mut duckdb_pending_result);
+}
+unsafe extern "C" {
+    #[doc = "Returns the error message contained within the pending result.\n\nThe result of this function must not be freed. It will be cleaned up when `duckdb_destroy_pending` is called.\n\n @param pending_result The pending result to fetch the error from.\n @return The error of the pending result."]
+    pub fn duckdb_pending_error(pending_result: duckdb_pending_result) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Executes a single task within the query, returning whether or not the query is ready.\n\nIf this returns DUCKDB_PENDING_RESULT_READY, the duckdb_execute_pending function can be called to obtain the result.\nIf this returns DUCKDB_PENDING_RESULT_NOT_READY, the duckdb_pending_execute_task function should be called again.\nIf this returns DUCKDB_PENDING_ERROR, an error occurred during execution.\n\nThe error message can be obtained by calling duckdb_pending_error on the pending_result.\n\n @param pending_result The pending result to execute a task within.\n @return The state of the pending result after the execution."]
+    pub fn duckdb_pending_execute_task(pending_result: duckdb_pending_result) -> duckdb_pending_state;
+}
+unsafe extern "C" {
+    #[doc = "If this returns DUCKDB_PENDING_RESULT_READY, the duckdb_execute_pending function can be called to obtain the result.\nIf this returns DUCKDB_PENDING_RESULT_NOT_READY, the duckdb_pending_execute_check_state function should be called again.\nIf this returns DUCKDB_PENDING_ERROR, an error occurred during execution.\n\nThe error message can be obtained by calling duckdb_pending_error on the pending_result.\n\n @param pending_result The pending result.\n @return The state of the pending result."]
+    pub fn duckdb_pending_execute_check_state(pending_result: duckdb_pending_result) -> duckdb_pending_state;
+}
+unsafe extern "C" {
+    #[doc = "Fully execute a pending query result, returning the final query result.\n\nIf duckdb_pending_execute_task has been called until DUCKDB_PENDING_RESULT_READY was returned, this will return fast.\nOtherwise, all remaining tasks must be executed first.\n\nNote that the result must be freed with `duckdb_destroy_result`.\n\n @param pending_result The pending result to execute.\n @param out_result The result object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_execute_pending(
+        pending_result: duckdb_pending_result,
+        out_result: *mut duckdb_result,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Returns whether a duckdb_pending_state is finished executing. For example if `pending_state` is\nDUCKDB_PENDING_RESULT_READY, this function will return true.\n\n @param pending_state The pending state on which to decide whether to finish execution.\n @return Boolean indicating pending execution should be considered finished."]
+    pub fn duckdb_pending_execution_is_finished(pending_state: duckdb_pending_state) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the value and de-allocates all memory allocated for that type.\n\n @param value The value to destroy."]
+    pub fn duckdb_destroy_value(value: *mut duckdb_value);
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a null-terminated string. Returns nullptr if the string is not valid UTF-8 or other invalid input.\n\nSuperseded by `duckdb_create_varchar_length`.\n\n @param text The null-terminated string\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_varchar(text: *const ::std::os::raw::c_char) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a string. Returns nullptr if the string is not valid UTF-8 or other invalid input.\n\n @param text The text\n @param length The length of the text\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_varchar_length(text: *const ::std::os::raw::c_char, length: idx_t) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a boolean\n\n @param input The boolean value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_bool(input: bool) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from an int8_t (a tinyint)\n\n @param input The tinyint value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_int8(input: i8) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a uint8_t (a utinyint)\n\n @param input The utinyint value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_uint8(input: u8) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from an int16_t (a smallint)\n\n @param input The smallint value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_int16(input: i16) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a uint16_t (a usmallint)\n\n @param input The usmallint value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_uint16(input: u16) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from an int32_t (an integer)\n\n @param input The integer value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_int32(input: i32) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a uint32_t (a uinteger)\n\n @param input The uinteger value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_uint32(input: u32) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a uint64_t (a ubigint)\n\n @param input The ubigint value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_uint64(input: u64) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from an int64\n\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_int64(val: i64) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a hugeint\n\n @param input The hugeint value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_hugeint(input: duckdb_hugeint) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a uhugeint\n\n @param input The uhugeint value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_uhugeint(input: duckdb_uhugeint) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a BIGNUM value from a duckdb_bignum\n\n @param input The duckdb_bignum value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_bignum(input: duckdb_bignum) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a DECIMAL value from a duckdb_decimal\n\nThe width must be between 1 and 38, and the scale must not exceed the width.\n\n @param input The duckdb_decimal value\n @return The value, or `nullptr` if the width or scale are out of range. This must be destroyed with\n`duckdb_destroy_value`."]
+    pub fn duckdb_create_decimal(input: duckdb_decimal) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a float\n\n @param input The float value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_float(input: f32) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a double\n\n @param input The double value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_double(input: f64) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a date\n\n @param input The date value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_date(input: duckdb_date) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a time\n\n @param input The time value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_time(input: duckdb_time) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a time_ns\n\n @param input The time value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_time_ns(input: duckdb_time_ns) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a time_tz.\nNot to be confused with `duckdb_create_time_tz`, which creates a duckdb_time_tz_t.\n\n @param value The time_tz value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_time_tz_value(value: duckdb_time_tz) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a TIMESTAMP value from a duckdb_timestamp\n\n @param input The duckdb_timestamp value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_timestamp(input: duckdb_timestamp) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a TIMESTAMP_TZ value from a duckdb_timestamp\n\n @param input The duckdb_timestamp value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_timestamp_tz(input: duckdb_timestamp) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a TIMESTAMP_S value from a duckdb_timestamp_s\n\n @param input The duckdb_timestamp_s value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_timestamp_s(input: duckdb_timestamp_s) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a TIMESTAMP_MS value from a duckdb_timestamp_ms\n\n @param input The duckdb_timestamp_ms value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_timestamp_ms(input: duckdb_timestamp_ms) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a TIMESTAMP_NS value from a duckdb_timestamp_ns\n\n @param input The duckdb_timestamp_ns value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_timestamp_ns(input: duckdb_timestamp_ns) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from an interval\n\n @param input The interval value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_interval(input: duckdb_interval) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value from a blob\n\n @param data The blob data\n @param length The length of the blob data\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_blob(data: *const u8, length: idx_t) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a BIT value from a duckdb_bit\n\n @param input The duckdb_bit value\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_bit(input: duckdb_bit) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a UUID value from a uhugeint\n\n @param input The duckdb_uhugeint containing the UUID\n @return The value. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_uuid(input: duckdb_uhugeint) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns the boolean value of the given value.\n\n @param val A duckdb_value containing a boolean\n @return A boolean, or false if the value cannot be converted"]
+    pub fn duckdb_get_bool(val: duckdb_value) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Returns the int8_t value of the given value.\n\n @param val A duckdb_value containing a tinyint\n @return A int8_t, or MinValue<int8> if the value cannot be converted"]
+    pub fn duckdb_get_int8(val: duckdb_value) -> i8;
+}
+unsafe extern "C" {
+    #[doc = "Returns the uint8_t value of the given value.\n\n @param val A duckdb_value containing a utinyint\n @return A uint8_t, or MinValue<uint8> if the value cannot be converted"]
+    pub fn duckdb_get_uint8(val: duckdb_value) -> u8;
+}
+unsafe extern "C" {
+    #[doc = "Returns the int16_t value of the given value.\n\n @param val A duckdb_value containing a smallint\n @return A int16_t, or MinValue<int16> if the value cannot be converted"]
+    pub fn duckdb_get_int16(val: duckdb_value) -> i16;
+}
+unsafe extern "C" {
+    #[doc = "Returns the uint16_t value of the given value.\n\n @param val A duckdb_value containing a usmallint\n @return A uint16_t, or MinValue<uint16> if the value cannot be converted"]
+    pub fn duckdb_get_uint16(val: duckdb_value) -> u16;
+}
+unsafe extern "C" {
+    #[doc = "Returns the int32_t value of the given value.\n\n @param val A duckdb_value containing an integer\n @return A int32_t, or MinValue<int32> if the value cannot be converted"]
+    pub fn duckdb_get_int32(val: duckdb_value) -> i32;
+}
+unsafe extern "C" {
+    #[doc = "Returns the uint32_t value of the given value.\n\n @param val A duckdb_value containing a uinteger\n @return A uint32_t, or MinValue<uint32> if the value cannot be converted"]
+    pub fn duckdb_get_uint32(val: duckdb_value) -> u32;
+}
+unsafe extern "C" {
+    #[doc = "Returns the int64_t value of the given value.\n\n @param val A duckdb_value containing a bigint\n @return A int64_t, or MinValue<int64> if the value cannot be converted"]
+    pub fn duckdb_get_int64(val: duckdb_value) -> i64;
+}
+unsafe extern "C" {
+    #[doc = "Returns the uint64_t value of the given value.\n\n @param val A duckdb_value containing a ubigint\n @return A uint64_t, or MinValue<uint64> if the value cannot be converted"]
+    pub fn duckdb_get_uint64(val: duckdb_value) -> u64;
+}
+unsafe extern "C" {
+    #[doc = "Returns the hugeint value of the given value.\n\n @param val A duckdb_value containing a hugeint\n @return A duckdb_hugeint, or MinValue<hugeint> if the value cannot be converted"]
+    pub fn duckdb_get_hugeint(val: duckdb_value) -> duckdb_hugeint;
+}
+unsafe extern "C" {
+    #[doc = "Returns the uhugeint value of the given value.\n\n @param val A duckdb_value containing a uhugeint\n @return A duckdb_uhugeint, or MinValue<uhugeint> if the value cannot be converted"]
+    pub fn duckdb_get_uhugeint(val: duckdb_value) -> duckdb_uhugeint;
+}
+unsafe extern "C" {
+    #[doc = "Returns the duckdb_bignum value of the given value.\nThe `data` field must be destroyed with `duckdb_free`.\n\n @param val A duckdb_value containing a BIGNUM\n @return A duckdb_bignum. The `data` field must be destroyed with `duckdb_free`."]
+    pub fn duckdb_get_bignum(val: duckdb_value) -> duckdb_bignum;
+}
+unsafe extern "C" {
+    #[doc = "Returns the duckdb_decimal value of the given value.\n\n @param val A duckdb_value containing a DECIMAL\n @return A duckdb_decimal, or MinValue<decimal> if the value cannot be converted"]
+    pub fn duckdb_get_decimal(val: duckdb_value) -> duckdb_decimal;
+}
+unsafe extern "C" {
+    #[doc = "Returns the float value of the given value.\n\n @param val A duckdb_value containing a float\n @return A float, or NAN if the value cannot be converted"]
+    pub fn duckdb_get_float(val: duckdb_value) -> f32;
+}
+unsafe extern "C" {
+    #[doc = "Returns the double value of the given value.\n\n @param val A duckdb_value containing a double\n @return A double, or NAN if the value cannot be converted"]
+    pub fn duckdb_get_double(val: duckdb_value) -> f64;
+}
+unsafe extern "C" {
+    #[doc = "Returns the date value of the given value.\n\n @param val A duckdb_value containing a date\n @return A duckdb_date, or MinValue<date> if the value cannot be converted"]
+    pub fn duckdb_get_date(val: duckdb_value) -> duckdb_date;
+}
+unsafe extern "C" {
+    #[doc = "Returns the time value of the given value.\n\n @param val A duckdb_value containing a time\n @return A duckdb_time, or MinValue<time> if the value cannot be converted"]
+    pub fn duckdb_get_time(val: duckdb_value) -> duckdb_time;
+}
+unsafe extern "C" {
+    #[doc = "Returns the time_ns value of the given value.\n\n @param val A duckdb_value containing a time_ns\n @return A duckdb_time_ns, or MinValue<time_ns> if the value cannot be converted"]
+    pub fn duckdb_get_time_ns(val: duckdb_value) -> duckdb_time_ns;
+}
+unsafe extern "C" {
+    #[doc = "Returns the time_tz value of the given value.\n\n @param val A duckdb_value containing a time_tz\n @return A duckdb_time_tz, or MinValue<time_tz> if the value cannot be converted"]
+    pub fn duckdb_get_time_tz(val: duckdb_value) -> duckdb_time_tz;
+}
+unsafe extern "C" {
+    #[doc = "Returns the TIMESTAMP value of the given value.\n\n @param val A duckdb_value containing a TIMESTAMP\n @return A duckdb_timestamp, or MinValue<timestamp> if the value cannot be converted"]
+    pub fn duckdb_get_timestamp(val: duckdb_value) -> duckdb_timestamp;
+}
+unsafe extern "C" {
+    #[doc = "Returns the TIMESTAMP_TZ value of the given value.\n\n @param val A duckdb_value containing a TIMESTAMP_TZ\n @return A duckdb_timestamp, or MinValue<timestamp_tz> if the value cannot be converted"]
+    pub fn duckdb_get_timestamp_tz(val: duckdb_value) -> duckdb_timestamp;
+}
+unsafe extern "C" {
+    #[doc = "Returns the duckdb_timestamp_s value of the given value.\n\n @param val A duckdb_value containing a TIMESTAMP_S\n @return A duckdb_timestamp_s, or MinValue<timestamp_s> if the value cannot be converted"]
+    pub fn duckdb_get_timestamp_s(val: duckdb_value) -> duckdb_timestamp_s;
+}
+unsafe extern "C" {
+    #[doc = "Returns the duckdb_timestamp_ms value of the given value.\n\n @param val A duckdb_value containing a TIMESTAMP_MS\n @return A duckdb_timestamp_ms, or MinValue<timestamp_ms> if the value cannot be converted"]
+    pub fn duckdb_get_timestamp_ms(val: duckdb_value) -> duckdb_timestamp_ms;
+}
+unsafe extern "C" {
+    #[doc = "Returns the duckdb_timestamp_ns value of the given value.\n\n @param val A duckdb_value containing a TIMESTAMP_NS\n @return A duckdb_timestamp_ns, or MinValue<timestamp_ns> if the value cannot be converted"]
+    pub fn duckdb_get_timestamp_ns(val: duckdb_value) -> duckdb_timestamp_ns;
+}
+unsafe extern "C" {
+    #[doc = "Returns the interval value of the given value.\n\n @param val A duckdb_value containing a interval\n @return A duckdb_interval, or MinValue<interval> if the value cannot be converted"]
+    pub fn duckdb_get_interval(val: duckdb_value) -> duckdb_interval;
+}
+unsafe extern "C" {
+    #[doc = "Returns the type of the given value. The type is valid as long as the value is not destroyed.\nThe type itself must not be destroyed.\n\n @param val A duckdb_value\n @return A duckdb_logical_type."]
+    pub fn duckdb_get_value_type(val: duckdb_value) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the blob value of the given value.\n\n @param val A duckdb_value containing a blob\n @return A duckdb_blob"]
+    pub fn duckdb_get_blob(val: duckdb_value) -> duckdb_blob;
+}
+unsafe extern "C" {
+    #[doc = "Returns the duckdb_bit value of the given value.\nThe `data` field must be destroyed with `duckdb_free`.\n\n @param val A duckdb_value containing a BIT\n @return A duckdb_bit"]
+    pub fn duckdb_get_bit(val: duckdb_value) -> duckdb_bit;
+}
+unsafe extern "C" {
+    #[doc = "Returns a duckdb_uhugeint representing the UUID value of the given value.\n\n @param val A duckdb_value containing a UUID\n @return A duckdb_uhugeint representing the UUID value"]
+    pub fn duckdb_get_uuid(val: duckdb_value) -> duckdb_uhugeint;
+}
+unsafe extern "C" {
+    #[doc = "Obtains a string representation of the given value.\nThe result must be destroyed with `duckdb_free`.\n\n @param value The value\n @return The string value. This must be destroyed with `duckdb_free`."]
+    pub fn duckdb_get_varchar(value: duckdb_value) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Creates a struct value from a type and an array of values. Must be destroyed with `duckdb_destroy_value`.\n\n @param type The type of the struct\n @param values The values for the struct fields\n @return The struct value, or nullptr, if any child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`."]
+    pub fn duckdb_create_struct_value(type_: duckdb_logical_type, values: *mut duckdb_value) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a list value from a child (element) type and an array of values of length `value_count`.\nMust be destroyed with `duckdb_destroy_value`.\n\n @param type The type of the list\n @param values The values for the list\n @param value_count The number of values in the list\n @return The list value, or nullptr, if the child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`."]
+    pub fn duckdb_create_list_value(
+        type_: duckdb_logical_type,
+        values: *mut duckdb_value,
+        value_count: idx_t,
+    ) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates an array value from a child (element) type and an array of values of length `value_count`.\nMust be destroyed with `duckdb_destroy_value`.\n\n @param type The type of the array\n @param values The values for the array\n @param value_count The number of values in the array\n @return The array value, or nullptr, if the child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`."]
+    pub fn duckdb_create_array_value(
+        type_: duckdb_logical_type,
+        values: *mut duckdb_value,
+        value_count: idx_t,
+    ) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a map value from a map type and two arrays, one for the keys and one for the values, each of length\n`entry_count`. Must be destroyed with `duckdb_destroy_value`.\n\n @param map_type The map type\n @param keys The keys of the map\n @param values The values of the map\n @param entry_count The number of entrys (key-value pairs) in the map\n @return The map value, or nullptr, if the parameters are invalid."]
+    pub fn duckdb_create_map_value(
+        map_type: duckdb_logical_type,
+        keys: *mut duckdb_value,
+        values: *mut duckdb_value,
+        entry_count: idx_t,
+    ) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a union value from a union type, a tag index, and a value.\nMust be destroyed with `duckdb_destroy_value`.\n\n @param union_type The union type\n @param tag_index The index of the tag of the union\n @param value The value of the union for that tag\n @return The union value, or nullptr, if the parameters are invalid."]
+    pub fn duckdb_create_union_value(
+        union_type: duckdb_logical_type,
+        tag_index: idx_t,
+        value: duckdb_value,
+    ) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of elements in a MAP value.\n\n @param value The MAP value.\n @return The number of elements in the map."]
+    pub fn duckdb_get_map_size(value: duckdb_value) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the MAP key at index as a duckdb_value.\n\n @param value The MAP value.\n @param index The index of the key.\n @return The key as a duckdb_value."]
+    pub fn duckdb_get_map_key(value: duckdb_value, index: idx_t) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns the MAP value at index as a duckdb_value.\n\n @param value The MAP value.\n @param index The index of the value.\n @return The value as a duckdb_value."]
+    pub fn duckdb_get_map_value(value: duckdb_value, index: idx_t) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns whether the value's type is SQLNULL or not.\n\n @param value The value to check.\n @return True, if the value's type is SQLNULL, otherwise false."]
+    pub fn duckdb_is_null_value(value: duckdb_value) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Creates a value of type SQLNULL.\n\n @return The duckdb_value representing SQLNULL. This must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_create_null_value() -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of elements in a LIST value.\n\n @param value The LIST value.\n @return The number of elements in the list."]
+    pub fn duckdb_get_list_size(value: duckdb_value) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the LIST child at index as a duckdb_value.\n\n @param value The LIST value.\n @param index The index of the child.\n @return The child as a duckdb_value."]
+    pub fn duckdb_get_list_child(value: duckdb_value, index: idx_t) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates an enum value from a type and a value. Must be destroyed with `duckdb_destroy_value`.\n\n @param type The type of the enum\n @param value The value for the enum\n @return The enum value, or nullptr."]
+    pub fn duckdb_create_enum_value(type_: duckdb_logical_type, value: u64) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns the enum value of the given value.\n\n @param value A duckdb_value containing an enum\n @return A uint64_t, or MinValue<uint64> if the value cannot be converted"]
+    pub fn duckdb_get_enum_value(value: duckdb_value) -> u64;
+}
+unsafe extern "C" {
+    #[doc = "Returns the STRUCT child at index as a duckdb_value.\n\n @param value The STRUCT value.\n @param index The index of the child.\n @return The child as a duckdb_value."]
+    pub fn duckdb_get_struct_child(value: duckdb_value, index: idx_t) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns the SQL string representation of the given value.\n\n @param value A duckdb_value.\n @return The SQL string representation as a null-terminated string. The result must be freed with `duckdb_free`."]
+    pub fn duckdb_value_to_string(value: duckdb_value) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Creates a `duckdb_logical_type` from a primitive type.\nThe resulting logical type must be destroyed with `duckdb_destroy_logical_type`.\n\nReturns an invalid logical type, if type is: `DUCKDB_TYPE_INVALID`, `DUCKDB_TYPE_DECIMAL`, `DUCKDB_TYPE_ENUM`,\n`DUCKDB_TYPE_LIST`, `DUCKDB_TYPE_STRUCT`, `DUCKDB_TYPE_MAP`, `DUCKDB_TYPE_ARRAY`, or `DUCKDB_TYPE_UNION`.\n\n @param type The primitive type to create.\n @return The logical type."]
+    pub fn duckdb_create_logical_type(type_: duckdb_type) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the alias of a duckdb_logical_type, if set, else `nullptr`.\nThe result must be destroyed with `duckdb_free`.\n\n @param type The logical type\n @return The alias or `nullptr`"]
+    pub fn duckdb_logical_type_get_alias(type_: duckdb_logical_type) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Sets the alias of a duckdb_logical_type.\n\n @param type The logical type\n @param alias The alias to set"]
+    pub fn duckdb_logical_type_set_alias(type_: duckdb_logical_type, alias: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Creates a LIST type from its child type.\nThe return type must be destroyed with `duckdb_destroy_logical_type`.\n\n @param type The child type of the list\n @return The logical type."]
+    pub fn duckdb_create_list_type(type_: duckdb_logical_type) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Creates an ARRAY type from its child type.\nThe return type must be destroyed with `duckdb_destroy_logical_type`.\n\n @param type The child type of the array.\n @param array_size The number of elements in the array.\n @return The logical type."]
+    pub fn duckdb_create_array_type(type_: duckdb_logical_type, array_size: idx_t) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Creates a MAP type from its key type and value type.\nThe return type must be destroyed with `duckdb_destroy_logical_type`.\n\n @param key_type The map's key type.\n @param value_type The map's value type.\n @return The logical type."]
+    pub fn duckdb_create_map_type(
+        key_type: duckdb_logical_type,
+        value_type: duckdb_logical_type,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Creates a UNION type from the passed arrays.\nThe return type must be destroyed with `duckdb_destroy_logical_type`.\n\n @param member_types The array of union member types.\n @param member_names The union member names.\n @param member_count The number of union members.\n @return The logical type."]
+    pub fn duckdb_create_union_type(
+        member_types: *mut duckdb_logical_type,
+        member_names: *mut *const ::std::os::raw::c_char,
+        member_count: idx_t,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Creates a STRUCT type based on the member types and names.\nThe resulting type must be destroyed with `duckdb_destroy_logical_type`.\n\n @param member_types The array of types of the struct members.\n @param member_names The array of names of the struct members.\n @param member_count The number of members of the struct.\n @return The logical type."]
+    pub fn duckdb_create_struct_type(
+        member_types: *mut duckdb_logical_type,
+        member_names: *mut *const ::std::os::raw::c_char,
+        member_count: idx_t,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Creates an ENUM type from the passed member name array.\nThe resulting type should be destroyed with `duckdb_destroy_logical_type`.\n\n @param member_names The array of names that the enum should consist of.\n @param member_count The number of elements that were specified in the array.\n @return The logical type."]
+    pub fn duckdb_create_enum_type(
+        member_names: *mut *const ::std::os::raw::c_char,
+        member_count: idx_t,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Creates a DECIMAL type with the specified width and scale.\nThe resulting type should be destroyed with `duckdb_destroy_logical_type`.\n\n @param width The width of the decimal type. Must be between 1 and 38.\n @param scale The scale of the decimal type. Must not exceed the width.\n @return The logical type, or `nullptr` if the width or scale are out of range."]
+    pub fn duckdb_create_decimal_type(width: u8, scale: u8) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the enum `duckdb_type` of a `duckdb_logical_type`.\n\n @param type The logical type.\n @return The `duckdb_type` id."]
+    pub fn duckdb_get_type_id(type_: duckdb_logical_type) -> duckdb_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the width of a decimal type.\n\n @param type The logical type object\n @return The width of the decimal type"]
+    pub fn duckdb_decimal_width(type_: duckdb_logical_type) -> u8;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the scale of a decimal type.\n\n @param type The logical type object\n @return The scale of the decimal type"]
+    pub fn duckdb_decimal_scale(type_: duckdb_logical_type) -> u8;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the internal storage type of a decimal type.\n\n @param type The logical type object\n @return The internal type of the decimal type"]
+    pub fn duckdb_decimal_internal_type(type_: duckdb_logical_type) -> duckdb_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the internal storage type of an enum type.\n\n @param type The logical type object\n @return The internal type of the enum type"]
+    pub fn duckdb_enum_internal_type(type_: duckdb_logical_type) -> duckdb_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the dictionary size of the enum type.\n\n @param type The logical type object\n @return The dictionary size of the enum type"]
+    pub fn duckdb_enum_dictionary_size(type_: duckdb_logical_type) -> u32;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the dictionary value at the specified position from the enum.\n\nThe result must be freed with `duckdb_free`.\n\n @param type The logical type object\n @param index The index in the dictionary\n @return The string value of the enum type. Must be freed with `duckdb_free`."]
+    pub fn duckdb_enum_dictionary_value(type_: duckdb_logical_type, index: idx_t) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the child type of the given LIST type. Also accepts MAP types.\nThe result must be freed with `duckdb_destroy_logical_type`.\n\n @param type The logical type, either LIST or MAP.\n @return The child type of the LIST or MAP type."]
+    pub fn duckdb_list_type_child_type(type_: duckdb_logical_type) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the child type of the given ARRAY type.\n\nThe result must be freed with `duckdb_destroy_logical_type`.\n\n @param type The logical type. Must be ARRAY.\n @return The child type of the ARRAY type."]
+    pub fn duckdb_array_type_child_type(type_: duckdb_logical_type) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the array size of the given array type.\n\n @param type The logical type object\n @return The fixed number of elements the values of this array type can store."]
+    pub fn duckdb_array_type_array_size(type_: duckdb_logical_type) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the key type of the given map type.\n\nThe result must be freed with `duckdb_destroy_logical_type`.\n\n @param type The logical type object\n @return The key type of the map type. Must be destroyed with `duckdb_destroy_logical_type`."]
+    pub fn duckdb_map_type_key_type(type_: duckdb_logical_type) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the value type of the given map type.\n\nThe result must be freed with `duckdb_destroy_logical_type`.\n\n @param type The logical type object\n @return The value type of the map type. Must be destroyed with `duckdb_destroy_logical_type`."]
+    pub fn duckdb_map_type_value_type(type_: duckdb_logical_type) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of children of a struct type.\n\n @param type The logical type object\n @return The number of children of a struct type."]
+    pub fn duckdb_struct_type_child_count(type_: duckdb_logical_type) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the name of the struct child.\n\nThe result must be freed with `duckdb_free`.\n\n @param type The logical type object\n @param index The child index\n @return The name of the struct type. Must be freed with `duckdb_free`."]
+    pub fn duckdb_struct_type_child_name(type_: duckdb_logical_type, index: idx_t) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the child type of the given struct type at the specified index.\n\nThe result must be freed with `duckdb_destroy_logical_type`.\n\n @param type The logical type object\n @param index The child index\n @return The child type of the struct type. Must be destroyed with `duckdb_destroy_logical_type`."]
+    pub fn duckdb_struct_type_child_type(type_: duckdb_logical_type, index: idx_t) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of members that the union type has.\n\n @param type The logical type (union) object\n @return The number of members of a union type."]
+    pub fn duckdb_union_type_member_count(type_: duckdb_logical_type) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the name of the union member.\n\nThe result must be freed with `duckdb_free`.\n\n @param type The logical type object\n @param index The child index\n @return The name of the union member. Must be freed with `duckdb_free`."]
+    pub fn duckdb_union_type_member_name(type_: duckdb_logical_type, index: idx_t) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the child type of the given union member at the specified index.\n\nThe result must be freed with `duckdb_destroy_logical_type`.\n\n @param type The logical type object\n @param index The child index\n @return The child type of the union member. Must be destroyed with `duckdb_destroy_logical_type`."]
+    pub fn duckdb_union_type_member_type(type_: duckdb_logical_type, index: idx_t) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the logical type and de-allocates all memory allocated for that type.\n\n @param type The logical type to destroy."]
+    pub fn duckdb_destroy_logical_type(type_: *mut duckdb_logical_type);
+}
+unsafe extern "C" {
+    #[doc = "Registers a custom type within the given connection.\nThe type must have an alias\n\n @param con The connection to use\n @param type The custom type to register\n @return Whether or not the registration was successful."]
+    pub fn duckdb_register_logical_type(
+        con: duckdb_connection,
+        type_: duckdb_logical_type,
+        info: duckdb_create_type_info,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Creates an empty data chunk with the specified column types.\nThe result must be destroyed with `duckdb_destroy_data_chunk`.\n\n @param types An array of column types. Column types can not contain ANY and INVALID types.\n @param column_count The number of columns.\n @return The data chunk."]
+    pub fn duckdb_create_data_chunk(types: *mut duckdb_logical_type, column_count: idx_t) -> duckdb_data_chunk;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the data chunk and de-allocates all memory allocated for that chunk.\n\n @param chunk The data chunk to destroy."]
+    pub fn duckdb_destroy_data_chunk(chunk: *mut duckdb_data_chunk);
+}
+unsafe extern "C" {
+    #[doc = "Resets a data chunk, clearing the validity masks and setting the cardinality of the data chunk to 0.\nAfter calling this method, you must call `duckdb_vector_get_validity` and `duckdb_vector_get_data` to obtain current\ndata and validity pointers\n\n @param chunk The data chunk to reset."]
+    pub fn duckdb_data_chunk_reset(chunk: duckdb_data_chunk);
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the number of columns in a data chunk.\n\n @param chunk The data chunk to get the data from\n @return The number of columns in the data chunk"]
+    pub fn duckdb_data_chunk_get_column_count(chunk: duckdb_data_chunk) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the vector at the specified column index in the data chunk.\n\nThe pointer to the vector is valid for as long as the chunk is alive.\nIt does NOT need to be destroyed.\n\n @param chunk The data chunk to get the data from\n @return The vector"]
+    pub fn duckdb_data_chunk_get_vector(chunk: duckdb_data_chunk, col_idx: idx_t) -> duckdb_vector;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the current number of tuples in a data chunk.\n\n @param chunk The data chunk to get the data from\n @return The number of tuples in the data chunk"]
+    pub fn duckdb_data_chunk_get_size(chunk: duckdb_data_chunk) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Sets the current number of tuples in a data chunk.\n\n @param chunk The data chunk to set the size in\n @param size The number of tuples in the data chunk"]
+    pub fn duckdb_data_chunk_set_size(chunk: duckdb_data_chunk, size: idx_t);
+}
+unsafe extern "C" {
+    #[doc = "Creates a flat vector. Must be destroyed with `duckdb_destroy_vector`.\n\n @param type The logical type of the vector.\n @param capacity The capacity of the vector.\n @return The vector."]
+    pub fn duckdb_create_vector(type_: duckdb_logical_type, capacity: idx_t) -> duckdb_vector;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the vector and de-allocates its memory.\n\n @param vector A pointer to the vector."]
+    pub fn duckdb_destroy_vector(vector: *mut duckdb_vector);
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the column type of the specified vector.\n\nThe result must be destroyed with `duckdb_destroy_logical_type`.\n\n @param vector The vector get the data from\n @return The type of the vector"]
+    pub fn duckdb_vector_get_column_type(vector: duckdb_vector) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the data pointer of the vector.\n\nThe data pointer can be used to read or write values from the vector.\nHow to read or write values depends on the type of the vector.\n\n @param vector The vector to get the data from\n @return The data pointer"]
+    pub fn duckdb_vector_get_data(vector: duckdb_vector) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the validity mask pointer of the specified vector.\n\nIf all values are valid, this function MIGHT return NULL!\n\nThe validity mask is a bitset that signifies null-ness within the data chunk.\nIt is a series of uint64_t values, where each uint64_t value contains validity for 64 tuples.\nThe bit is set to 1 if the value is valid (i.e. not NULL) or 0 if the value is invalid (i.e. NULL).\n\nValidity of a specific value can be obtained like this:\n\nidx_t entry_idx = row_idx / 64;\nidx_t idx_in_entry = row_idx % 64;\nbool is_valid = validity_mask[entry_idx] & (1 << idx_in_entry);\n\nAlternatively, the (slower) duckdb_validity_row_is_valid function can be used.\n\n @param vector The vector to get the data from\n @return The pointer to the validity mask, or NULL if no validity mask is present"]
+    pub fn duckdb_vector_get_validity(vector: duckdb_vector) -> *mut u64;
+}
+unsafe extern "C" {
+    #[doc = "Ensures the validity mask is writable by allocating it.\n\nAfter this function is called, `duckdb_vector_get_validity` will ALWAYS return non-NULL.\nThis allows NULL values to be written to the vector, regardless of whether a validity mask was present before.\n\n @param vector The vector to alter"]
+    pub fn duckdb_vector_ensure_validity_writable(vector: duckdb_vector);
+}
+unsafe extern "C" {
+    #[doc = "Assigns a string element in the vector at the specified location. For VARCHAR vectors, the input is validated as UTF-8;\nif invalid, a NULL value is assigned at that index.\n\nSuperseded by `duckdb_unsafe_vector_assign_string_element_len`, optionally combined with `duckdb_valid_utf8_check`.\n\n @param vector The vector to alter\n @param index The row position in the vector to assign the string to\n @param str The null-terminated string"]
+    pub fn duckdb_vector_assign_string_element(
+        vector: duckdb_vector,
+        index: idx_t,
+        str_: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Assigns a string element in the vector at the specified location. For VARCHAR vectors, the input is validated as UTF-8;\nif invalid, a NULL value is assigned at that index. For BLOB vectors, no validation is performed.\n\nSuperseded by `duckdb_unsafe_vector_assign_string_element_len`, optionally combined with `duckdb_valid_utf8_check`.\n\n @param vector The vector to alter\n @param index The row position in the vector to assign the string to\n @param str The string\n @param str_len The length of the string (in bytes)"]
+    pub fn duckdb_vector_assign_string_element_len(
+        vector: duckdb_vector,
+        index: idx_t,
+        str_: *const ::std::os::raw::c_char,
+        str_len: idx_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Assigns a string element in the vector at the specified location without UTF-8 validation. The caller is responsible for\nensuring the input is valid UTF-8. Use `duckdb_valid_utf8_check` to validate strings before calling this function if\nneeded. If the input is known to be valid UTF-8, this function can be called directly for better performance, avoiding\nthe overhead of redundant validation.\n\n @param vector The vector to alter\n @param index The row position in the vector to assign the string to\n @param str The string\n @param str_len The length of the string (in bytes)"]
+    pub fn duckdb_unsafe_vector_assign_string_element_len(
+        vector: duckdb_vector,
+        index: idx_t,
+        str_: *const ::std::os::raw::c_char,
+        str_len: idx_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the child vector of a list vector.\n\nThe resulting vector is valid as long as the parent vector is valid.\n\n @param vector The vector\n @return The child vector"]
+    pub fn duckdb_list_vector_get_child(vector: duckdb_vector) -> duckdb_vector;
+}
+unsafe extern "C" {
+    #[doc = "Returns the size of the child vector of the list.\n\n @param vector The vector\n @return The size of the child list"]
+    pub fn duckdb_list_vector_get_size(vector: duckdb_vector) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Sets the size of the underlying child-vector of a list vector.\nNote that this does NOT reserve the memory in the child buffer,\nand that it is possible to set a size exceeding the capacity.\nTo set the capacity, use `duckdb_list_vector_reserve`.\n\n @param vector The list vector.\n @param size The size of the child list.\n @return The duckdb state. Returns DuckDBError, if the vector is nullptr."]
+    pub fn duckdb_list_vector_set_size(vector: duckdb_vector, size: idx_t) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Sets the capacity of the underlying child-vector of a list vector.\nWe increment to the next power of two, based on the required capacity.\nThus, the capacity might not match the size of the list (capacity >= size),\nwhich is set via `duckdb_list_vector_set_size`.\n\n @param vector The list vector.\n @param required_capacity The child buffer capacity to reserve.\n @return The duckdb state. Returns DuckDBError, if the vector is nullptr."]
+    pub fn duckdb_list_vector_reserve(vector: duckdb_vector, required_capacity: idx_t) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the child vector of a struct vector.\nThe resulting vector is valid as long as the parent vector is valid.\n\n @param vector The vector\n @param index The child index\n @return The child vector"]
+    pub fn duckdb_struct_vector_get_child(vector: duckdb_vector, index: idx_t) -> duckdb_vector;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the child vector of an array vector.\nThe resulting vector is valid as long as the parent vector is valid.\nThe resulting vector has the size of the parent vector multiplied by the array size.\n\n @param vector The vector\n @return The child vector"]
+    pub fn duckdb_array_vector_get_child(vector: duckdb_vector) -> duckdb_vector;
+}
+unsafe extern "C" {
+    #[doc = "Slice a vector with a selection vector.\nThe length of the selection vector must be less than or equal to the length of the vector.\nTurns the vector into a dictionary vector.\n\n @param vector The vector to slice.\n @param sel The selection vector.\n @param len The length of the selection vector."]
+    pub fn duckdb_slice_vector(vector: duckdb_vector, sel: duckdb_selection_vector, len: idx_t);
+}
+unsafe extern "C" {
+    #[doc = "Copy the src vector to the dst with a selection vector that identifies which indices to copy.\n\n @param src The vector to copy from.\n @param dst The vector to copy to.\n @param sel The selection vector. The length of the selection vector should not be more than the length of the src\nvector\n @param src_count The number of entries from selection vector to copy. Think of this as the effective length of the\nselection vector starting from index 0\n @param src_offset The offset in the selection vector to copy from (important: actual number of items copied =\nsrc_count - src_offset).\n @param dst_offset The offset in the dst vector to start copying to."]
+    pub fn duckdb_vector_copy_sel(
+        src: duckdb_vector,
+        dst: duckdb_vector,
+        sel: duckdb_selection_vector,
+        src_count: idx_t,
+        src_offset: idx_t,
+        dst_offset: idx_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Copies the value from `value` to `vector`.\n\n @param vector The receiving vector.\n @param value The value to copy into the vector."]
+    pub fn duckdb_vector_reference_value(vector: duckdb_vector, value: duckdb_value);
+}
+unsafe extern "C" {
+    #[doc = "Changes `to_vector` to reference `from_vector. After, the vectors share ownership of the data.\n\n @param to_vector The receiving vector.\n @param from_vector The vector to reference."]
+    pub fn duckdb_vector_reference_vector(to_vector: duckdb_vector, from_vector: duckdb_vector);
+}
+unsafe extern "C" {
+    #[doc = "Returns whether or not a row is valid (i.e. not NULL) in the given validity mask.\n\n @param validity The validity mask, as obtained through `duckdb_vector_get_validity`\n @param row The row index\n @return true if the row is valid, false otherwise"]
+    pub fn duckdb_validity_row_is_valid(validity: *mut u64, row: idx_t) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "In a validity mask, sets a specific row to either valid or invalid.\n\nNote that `duckdb_vector_ensure_validity_writable` should be called before calling `duckdb_vector_get_validity`,\nto ensure that there is a validity mask to write to.\n\n @param validity The validity mask, as obtained through `duckdb_vector_get_validity`.\n @param row The row index\n @param valid Whether or not to set the row to valid, or invalid"]
+    pub fn duckdb_validity_set_row_validity(validity: *mut u64, row: idx_t, valid: bool);
+}
+unsafe extern "C" {
+    #[doc = "In a validity mask, sets a specific row to invalid.\n\nEquivalent to `duckdb_validity_set_row_validity` with valid set to false.\n\n @param validity The validity mask\n @param row The row index"]
+    pub fn duckdb_validity_set_row_invalid(validity: *mut u64, row: idx_t);
+}
+unsafe extern "C" {
+    #[doc = "In a validity mask, sets a specific row to valid.\n\nEquivalent to `duckdb_validity_set_row_validity` with valid set to true.\n\n @param validity The validity mask\n @param row The row index"]
+    pub fn duckdb_validity_set_row_valid(validity: *mut u64, row: idx_t);
+}
+unsafe extern "C" {
+    #[doc = "Creates a new empty scalar function.\n\nThe return value must be destroyed with `duckdb_destroy_scalar_function`.\n\n @return The scalar function object."]
+    pub fn duckdb_create_scalar_function() -> duckdb_scalar_function;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given scalar function object.\n\n @param scalar_function The scalar function to destroy"]
+    pub fn duckdb_destroy_scalar_function(scalar_function: *mut duckdb_scalar_function);
+}
+unsafe extern "C" {
+    #[doc = "Sets the name of the given scalar function.\n\n @param scalar_function The scalar function\n @param name The name of the scalar function"]
+    pub fn duckdb_scalar_function_set_name(
+        scalar_function: duckdb_scalar_function,
+        name: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the parameters of the given scalar function to varargs. Does not require adding parameters with\nduckdb_scalar_function_add_parameter.\n\n @param scalar_function The scalar function.\n @param type The type of the arguments.\n @return The parameter type. Cannot contain INVALID."]
+    pub fn duckdb_scalar_function_set_varargs(scalar_function: duckdb_scalar_function, type_: duckdb_logical_type);
+}
+unsafe extern "C" {
+    #[doc = "Sets the scalar function's null-handling behavior to special.\n\n @param scalar_function The scalar function."]
+    pub fn duckdb_scalar_function_set_special_handling(scalar_function: duckdb_scalar_function);
+}
+unsafe extern "C" {
+    #[doc = "Sets the Function Stability of the scalar function to VOLATILE, indicating the function should be re-run for every row.\nThis limits optimization that can be performed for the function.\n\n @param scalar_function The scalar function."]
+    pub fn duckdb_scalar_function_set_volatile(scalar_function: duckdb_scalar_function);
+}
+unsafe extern "C" {
+    #[doc = "Adds a parameter to the scalar function.\n\n @param scalar_function The scalar function.\n @param type The parameter type. Cannot contain INVALID."]
+    pub fn duckdb_scalar_function_add_parameter(scalar_function: duckdb_scalar_function, type_: duckdb_logical_type);
+}
+unsafe extern "C" {
+    #[doc = "Sets the return type of the scalar function.\n\n @param scalar_function The scalar function\n @param type Cannot contain INVALID or ANY."]
+    pub fn duckdb_scalar_function_set_return_type(scalar_function: duckdb_scalar_function, type_: duckdb_logical_type);
+}
+unsafe extern "C" {
+    #[doc = "Assigns extra information to the scalar function that can be fetched during binding, etc.\n\n @param scalar_function The scalar function\n @param extra_info The extra information\n @param destroy The callback that will be called to destroy the extra information (if any)"]
+    pub fn duckdb_scalar_function_set_extra_info(
+        scalar_function: duckdb_scalar_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the (optional) bind function of the scalar function.\n\n @param scalar_function The scalar function.\n @param bind The bind function."]
+    pub fn duckdb_scalar_function_set_bind(
+        scalar_function: duckdb_scalar_function,
+        bind: duckdb_scalar_function_bind_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the user-provided bind data in the bind object of the scalar function.\nThe bind data object can be retrieved again during execution.\nIn most case, you also need to set the copy-callback of your bind data via duckdb_scalar_function_set_bind_data_copy.\n\n @param info The bind info of the scalar function.\n @param bind_data The bind data object.\n @param destroy The callback to destroy the bind data (if any)."]
+    pub fn duckdb_scalar_function_set_bind_data(
+        info: duckdb_bind_info,
+        bind_data: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the copy-callback for the user-provided bind data in the bind object of the scalar function.\n\n @param info The bind info of the scalar function.\n @param copy The callback to copy the bind data (if any)."]
+    pub fn duckdb_scalar_function_set_bind_data_copy(info: duckdb_bind_info, copy: duckdb_copy_callback_t);
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while calling bind on a scalar function.\n\n @param info The bind info object.\n @param error The error message."]
+    pub fn duckdb_scalar_function_bind_set_error(info: duckdb_bind_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Sets the main function of the scalar function.\n\n @param scalar_function The scalar function\n @param function The function"]
+    pub fn duckdb_scalar_function_set_function(
+        scalar_function: duckdb_scalar_function,
+        function: duckdb_scalar_function_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Register the scalar function object within the given connection.\n\nThe function requires at least a name, a function and a return type.\n\nIf the function is incomplete or a function with this name already exists DuckDBError is returned.\n\n @param con The connection to register it in.\n @param scalar_function The function pointer\n @return Whether or not the registration was successful."]
+    pub fn duckdb_register_scalar_function(
+        con: duckdb_connection,
+        scalar_function: duckdb_scalar_function,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info of the function as set in `duckdb_scalar_function_set_extra_info`.\n\n @param info The info object.\n @return The extra info."]
+    pub fn duckdb_scalar_function_get_extra_info(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info of the function as set in the bind info.\n\n @param info The info object.\n @return The extra info."]
+    pub fn duckdb_scalar_function_bind_get_extra_info(info: duckdb_bind_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Gets the scalar function's bind data set by `duckdb_scalar_function_set_bind_data`.\nNote that the bind data is read-only.\n\n @param info The function info.\n @return The bind data object."]
+    pub fn duckdb_scalar_function_get_bind_data(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the client context of the bind info of a scalar function.\n\n @param info The bind info object of the scalar function.\n @param out_context The client context of the bind info. Must be destroyed with `duckdb_destroy_client_context`."]
+    pub fn duckdb_scalar_function_get_client_context(info: duckdb_bind_info, out_context: *mut duckdb_client_context);
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while executing the scalar function.\n\n @param info The info object.\n @param error The error message"]
+    pub fn duckdb_scalar_function_set_error(info: duckdb_function_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Creates a new empty scalar function set.\n\nThe return value must be destroyed with `duckdb_destroy_scalar_function_set`.\n\n @return The scalar function set object."]
+    pub fn duckdb_create_scalar_function_set(name: *const ::std::os::raw::c_char) -> duckdb_scalar_function_set;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given scalar function set object."]
+    pub fn duckdb_destroy_scalar_function_set(scalar_function_set: *mut duckdb_scalar_function_set);
+}
+unsafe extern "C" {
+    #[doc = "Adds the scalar function as a new overload to the scalar function set.\n\nReturns DuckDBError if the function could not be added, for example if the overload already exists.\n\n @param set The scalar function set\n @param function The function to add"]
+    pub fn duckdb_add_scalar_function_to_set(
+        set: duckdb_scalar_function_set,
+        function: duckdb_scalar_function,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Register the scalar function set within the given connection.\n\nThe set requires at least a single valid overload.\n\nIf the set is incomplete or a function with this name already exists DuckDBError is returned.\n\n @param con The connection to register it in.\n @param set The function set to register\n @return Whether or not the registration was successful."]
+    pub fn duckdb_register_scalar_function_set(con: duckdb_connection, set: duckdb_scalar_function_set)
+    -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of input arguments of the scalar function.\n\n @param info The bind info.\n @return The number of input arguments."]
+    pub fn duckdb_scalar_function_bind_get_argument_count(info: duckdb_bind_info) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the input argument at index of the scalar function.\n\n @param info The bind info.\n @param index The argument index.\n @return The input argument at index. Must be destroyed with `duckdb_destroy_expression`."]
+    pub fn duckdb_scalar_function_bind_get_argument(info: duckdb_bind_info, index: idx_t) -> duckdb_expression;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the state pointer of the function info.\n\n @param info The function info object.\n @return The state pointer."]
+    pub fn duckdb_scalar_function_get_state(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Sets the (optional) state init function of the scalar function.\nThis is called once for each worker thread that begins executing the function\n @param scalar_function The scalar function.\n @param init The init function."]
+    pub fn duckdb_scalar_function_set_init(
+        scalar_function: duckdb_scalar_function,
+        init: duckdb_scalar_function_init_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while calling init on a scalar function.\n\n @param info The init info object.\n @param error The error message."]
+    pub fn duckdb_scalar_function_init_set_error(info: duckdb_init_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Sets the state pointer in the init info of the scalar function.\n\n @param info The init info object.\n @param state The state pointer.\n @param destroy The callback to destroy the state (if any)."]
+    pub fn duckdb_scalar_function_init_set_state(
+        info: duckdb_init_info,
+        state: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the client context of the init info of a scalar function.\n\n @param info The init info object of the scalar function.\n @param out_context The client context of the init info. Must be destroyed with `duckdb_destroy_client_context`."]
+    pub fn duckdb_scalar_function_init_get_client_context(
+        info: duckdb_init_info,
+        out_context: *mut duckdb_client_context,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Gets the scalar function's bind data set by `duckdb_scalar_function_set_bind_data`.\nNote that the bind data is read-only.\n\n @param info The init info object.\n @return The bind data object."]
+    pub fn duckdb_scalar_function_init_get_bind_data(info: duckdb_init_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info of the function as set in the init info.\n\n @param info The init info object.\n @return The extra info."]
+    pub fn duckdb_scalar_function_init_get_extra_info(info: duckdb_init_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Creates a new selection vector of size `size`.\nMust be destroyed with `duckdb_destroy_selection_vector`.\n\n @param size The size of the selection vector.\n @return The selection vector."]
+    pub fn duckdb_create_selection_vector(size: idx_t) -> duckdb_selection_vector;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the selection vector and de-allocates its memory.\n\n @param sel The selection vector."]
+    pub fn duckdb_destroy_selection_vector(sel: duckdb_selection_vector);
+}
+unsafe extern "C" {
+    #[doc = "Access the data pointer of a selection vector.\n\n @param sel The selection vector.\n @return The data pointer."]
+    pub fn duckdb_selection_vector_get_data_ptr(sel: duckdb_selection_vector) -> *mut sel_t;
+}
+unsafe extern "C" {
+    #[doc = "Creates a new empty aggregate function.\n\nThe return value should be destroyed with `duckdb_destroy_aggregate_function`.\n\n @return The aggregate function object."]
+    pub fn duckdb_create_aggregate_function() -> duckdb_aggregate_function;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given aggregate function object."]
+    pub fn duckdb_destroy_aggregate_function(aggregate_function: *mut duckdb_aggregate_function);
+}
+unsafe extern "C" {
+    #[doc = "Sets the name of the given aggregate function.\n\n @param aggregate_function The aggregate function\n @param name The name of the aggregate function"]
+    pub fn duckdb_aggregate_function_set_name(
+        aggregate_function: duckdb_aggregate_function,
+        name: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Adds a parameter to the aggregate function.\n\n @param aggregate_function The aggregate function.\n @param type The parameter type. Cannot contain INVALID."]
+    pub fn duckdb_aggregate_function_add_parameter(
+        aggregate_function: duckdb_aggregate_function,
+        type_: duckdb_logical_type,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the return type of the aggregate function.\n\n @param aggregate_function The aggregate function.\n @param type The return type. Cannot contain INVALID or ANY."]
+    pub fn duckdb_aggregate_function_set_return_type(
+        aggregate_function: duckdb_aggregate_function,
+        type_: duckdb_logical_type,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the main functions of the aggregate function.\n\n @param aggregate_function The aggregate function\n @param state_size state size\n @param state_init state init function\n @param update update states\n @param combine combine states\n @param finalize finalize states"]
+    pub fn duckdb_aggregate_function_set_functions(
+        aggregate_function: duckdb_aggregate_function,
+        state_size: duckdb_aggregate_state_size,
+        state_init: duckdb_aggregate_init_t,
+        update: duckdb_aggregate_update_t,
+        combine: duckdb_aggregate_combine_t,
+        finalize: duckdb_aggregate_finalize_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the state destructor callback of the aggregate function (optional)\n\n @param aggregate_function The aggregate function\n @param destroy state destroy callback"]
+    pub fn duckdb_aggregate_function_set_destructor(
+        aggregate_function: duckdb_aggregate_function,
+        destroy: duckdb_aggregate_destroy_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Register the aggregate function object within the given connection.\n\nThe function requires at least a name, functions and a return type.\n\nIf the function is incomplete or a function with this name already exists DuckDBError is returned.\n\n @param con The connection to register it in.\n @return Whether or not the registration was successful."]
+    pub fn duckdb_register_aggregate_function(
+        con: duckdb_connection,
+        aggregate_function: duckdb_aggregate_function,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Sets the NULL handling of the aggregate function to SPECIAL_HANDLING.\n\n @param aggregate_function The aggregate function"]
+    pub fn duckdb_aggregate_function_set_special_handling(aggregate_function: duckdb_aggregate_function);
+}
+unsafe extern "C" {
+    #[doc = "Assigns extra information to the scalar function that can be fetched during binding, etc.\n\n @param aggregate_function The aggregate function\n @param extra_info The extra information\n @param destroy The callback that will be called to destroy the extra information (if any)"]
+    pub fn duckdb_aggregate_function_set_extra_info(
+        aggregate_function: duckdb_aggregate_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info of the function as set in `duckdb_aggregate_function_set_extra_info`.\n\n @param info The info object\n @return The extra info"]
+    pub fn duckdb_aggregate_function_get_extra_info(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while executing the aggregate function.\n\n @param info The info object\n @param error The error message"]
+    pub fn duckdb_aggregate_function_set_error(info: duckdb_function_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Creates a new empty aggregate function set.\n\nThe return value should be destroyed with `duckdb_destroy_aggregate_function_set`.\n\n @return The aggregate function set object."]
+    pub fn duckdb_create_aggregate_function_set(name: *const ::std::os::raw::c_char) -> duckdb_aggregate_function_set;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given aggregate function set object."]
+    pub fn duckdb_destroy_aggregate_function_set(aggregate_function_set: *mut duckdb_aggregate_function_set);
+}
+unsafe extern "C" {
+    #[doc = "Adds the aggregate function as a new overload to the aggregate function set.\n\nReturns DuckDBError if the function could not be added, for example if the overload already exists.\n\n @param set The aggregate function set\n @param function The function to add"]
+    pub fn duckdb_add_aggregate_function_to_set(
+        set: duckdb_aggregate_function_set,
+        function: duckdb_aggregate_function,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Register the aggregate function set within the given connection.\n\nThe set requires at least a single valid overload.\n\nIf the set is incomplete or a function with this name already exists DuckDBError is returned.\n\n @param con The connection to register it in.\n @param set The function set to register\n @return Whether or not the registration was successful."]
+    pub fn duckdb_register_aggregate_function_set(
+        con: duckdb_connection,
+        set: duckdb_aggregate_function_set,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Creates a new empty table function.\n\nThe return value should be destroyed with `duckdb_destroy_table_function`.\n\n @return The table function object."]
+    pub fn duckdb_create_table_function() -> duckdb_table_function;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given table function object.\n\n @param table_function The table function to destroy"]
+    pub fn duckdb_destroy_table_function(table_function: *mut duckdb_table_function);
+}
+unsafe extern "C" {
+    #[doc = "Sets the name of the given table function.\n\n @param table_function The table function\n @param name The name of the table function"]
+    pub fn duckdb_table_function_set_name(table_function: duckdb_table_function, name: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Adds a parameter to the table function.\n\n @param table_function The table function.\n @param type The parameter type. Cannot contain INVALID."]
+    pub fn duckdb_table_function_add_parameter(table_function: duckdb_table_function, type_: duckdb_logical_type);
+}
+unsafe extern "C" {
+    #[doc = "Adds a named parameter to the table function.\n\n @param table_function The table function.\n @param name The parameter name.\n @param type The parameter type. Cannot contain INVALID."]
+    pub fn duckdb_table_function_add_named_parameter(
+        table_function: duckdb_table_function,
+        name: *const ::std::os::raw::c_char,
+        type_: duckdb_logical_type,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Assigns extra information to the table function that can be fetched during binding, etc.\n\n @param table_function The table function\n @param extra_info The extra information\n @param destroy The callback that will be called to destroy the extra information (if any)"]
+    pub fn duckdb_table_function_set_extra_info(
+        table_function: duckdb_table_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the bind function of the table function.\n\n @param table_function The table function\n @param bind The bind function"]
+    pub fn duckdb_table_function_set_bind(table_function: duckdb_table_function, bind: duckdb_table_function_bind_t);
+}
+unsafe extern "C" {
+    #[doc = "Sets the init function of the table function.\n\n @param table_function The table function\n @param init The init function"]
+    pub fn duckdb_table_function_set_init(table_function: duckdb_table_function, init: duckdb_table_function_init_t);
+}
+unsafe extern "C" {
+    #[doc = "Sets the thread-local init function of the table function.\n\n @param table_function The table function\n @param init The init function"]
+    pub fn duckdb_table_function_set_local_init(
+        table_function: duckdb_table_function,
+        init: duckdb_table_function_init_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the main function of the table function.\n\n @param table_function The table function\n @param function The function"]
+    pub fn duckdb_table_function_set_function(table_function: duckdb_table_function, function: duckdb_table_function_t);
+}
+unsafe extern "C" {
+    #[doc = "Sets whether or not the given table function supports projection pushdown.\n\nIf this is set to true, the system will provide a list of all required columns in the `init` stage through\nthe `duckdb_init_get_column_count` and `duckdb_init_get_column_index` functions.\nIf this is set to false (the default), the system will expect all columns to be projected.\n\n @param table_function The table function\n @param pushdown True if the table function supports projection pushdown, false otherwise."]
+    pub fn duckdb_table_function_supports_projection_pushdown(table_function: duckdb_table_function, pushdown: bool);
+}
+unsafe extern "C" {
+    #[doc = "Register the table function object within the given connection.\n\nThe function requires at least a name, a bind function, an init function and a main function.\n\nIf the function is incomplete or a function with this name already exists DuckDBError is returned.\n\n @param con The connection to register it in.\n @param function The function pointer\n @return Whether or not the registration was successful."]
+    pub fn duckdb_register_table_function(con: duckdb_connection, function: duckdb_table_function) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.\n\n @param info The info object\n @return The extra info"]
+    pub fn duckdb_bind_get_extra_info(info: duckdb_bind_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the client context of the bind info of a table function.\n\n @param info The bind info object of the table function.\n @param out_context The client context of the bind info. Must be destroyed with `duckdb_destroy_client_context`."]
+    pub fn duckdb_table_function_get_client_context(info: duckdb_bind_info, out_context: *mut duckdb_client_context);
+}
+unsafe extern "C" {
+    #[doc = "Adds a result column to the output of the table function.\n\n @param info The table function's bind info.\n @param name The column name.\n @param type The logical column type."]
+    pub fn duckdb_bind_add_result_column(
+        info: duckdb_bind_info,
+        name: *const ::std::os::raw::c_char,
+        type_: duckdb_logical_type,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the number of regular (non-named) parameters to the function.\n\n @param info The info object\n @return The number of parameters"]
+    pub fn duckdb_bind_get_parameter_count(info: duckdb_bind_info) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the parameter at the given index.\n\nThe result must be destroyed with `duckdb_destroy_value`.\n\n @param info The info object\n @param index The index of the parameter to get\n @return The value of the parameter. Must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_bind_get_parameter(info: duckdb_bind_info, index: idx_t) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves a named parameter with the given name.\n\nThe result must be destroyed with `duckdb_destroy_value`.\n\n @param info The info object\n @param name The name of the parameter\n @return The value of the parameter. Must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_bind_get_named_parameter(info: duckdb_bind_info, name: *const ::std::os::raw::c_char)
+    -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Sets the user-provided bind data in the bind object of the table function.\nThis object can be retrieved again during execution.\n\n @param info The bind info of the table function.\n @param bind_data The bind data object.\n @param destroy The callback to destroy the bind data (if any)."]
+    pub fn duckdb_bind_set_bind_data(
+        info: duckdb_bind_info,
+        bind_data: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the cardinality estimate for the table function, used for optimization.\n\n @param info The bind data object.\n @param is_exact Whether or not the cardinality estimate is exact, or an approximation"]
+    pub fn duckdb_bind_set_cardinality(info: duckdb_bind_info, cardinality: idx_t, is_exact: bool);
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while calling bind on a table function.\n\n @param info The info object\n @param error The error message"]
+    pub fn duckdb_bind_set_error(info: duckdb_bind_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.\n\n @param info The info object\n @return The extra info"]
+    pub fn duckdb_init_get_extra_info(info: duckdb_init_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Gets the bind data set by `duckdb_bind_set_bind_data` during the bind.\n\nNote that the bind data should be considered as read-only.\nFor tracking state, use the init data instead.\n\n @param info The info object\n @return The bind data object"]
+    pub fn duckdb_init_get_bind_data(info: duckdb_init_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Sets the user-provided init data in the init object. This object can be retrieved again during execution.\n\n @param info The info object\n @param init_data The init data object.\n @param destroy The callback that will be called to destroy the init data (if any)"]
+    pub fn duckdb_init_set_init_data(
+        info: duckdb_init_info,
+        init_data: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of projected columns.\n\nThis function must be used if projection pushdown is enabled to figure out which columns to emit.\n\n @param info The info object\n @return The number of projected columns."]
+    pub fn duckdb_init_get_column_count(info: duckdb_init_info) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the column index of the projected column at the specified position.\n\nThis function must be used if projection pushdown is enabled to figure out which columns to emit.\n\n @param info The info object\n @param column_index The index at which to get the projected column index, from 0..duckdb_init_get_column_count(info)\n @return The column index of the projected column."]
+    pub fn duckdb_init_get_column_index(info: duckdb_init_info, column_index: idx_t) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Sets how many threads can process this table function in parallel (default: 1)\n\n @param info The info object\n @param max_threads The maximum amount of threads that can process this table function"]
+    pub fn duckdb_init_set_max_threads(info: duckdb_init_info, max_threads: idx_t);
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while calling init.\n\n @param info The info object\n @param error The error message"]
+    pub fn duckdb_init_set_error(info: duckdb_init_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.\n\n @param info The info object\n @return The extra info"]
+    pub fn duckdb_function_get_extra_info(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Gets the table function's bind data set by `duckdb_bind_set_bind_data`.\n\nNote that the bind data is read-only.\nFor tracking state, use the init data instead.\n\n @param info The function info object.\n @return The bind data object."]
+    pub fn duckdb_function_get_bind_data(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Gets the init data set by `duckdb_init_set_init_data` during the init.\n\n @param info The info object\n @return The init data object"]
+    pub fn duckdb_function_get_init_data(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Gets the thread-local init data set by `duckdb_init_set_init_data` during the local_init.\n\n @param info The info object\n @return The init data object"]
+    pub fn duckdb_function_get_local_init_data(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while executing the function.\n\n @param info The info object\n @param error The error message"]
+    pub fn duckdb_function_set_error(info: duckdb_function_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Add a replacement scan definition to the specified database.\n\n @param db The database object to add the replacement scan to\n @param replacement The replacement scan callback\n @param extra_data Extra data that is passed back into the specified callback\n @param delete_callback The delete callback to call on the extra data, if any"]
+    pub fn duckdb_add_replacement_scan(
+        db: duckdb_database,
+        replacement: duckdb_replacement_callback_t,
+        extra_data: *mut ::std::os::raw::c_void,
+        delete_callback: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the replacement function name. If this function is called in the replacement callback,\nthe replacement scan is performed. If it is not called, the replacement callback is not performed.\n\n @param info The info object\n @param function_name The function name to substitute."]
+    pub fn duckdb_replacement_scan_set_function_name(
+        info: duckdb_replacement_scan_info,
+        function_name: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Adds a parameter to the replacement scan function.\n\n @param info The info object\n @param parameter The parameter to add."]
+    pub fn duckdb_replacement_scan_add_parameter(info: duckdb_replacement_scan_info, parameter: duckdb_value);
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while executing the replacement scan.\n\n @param info The info object\n @param error The error message"]
+    pub fn duckdb_replacement_scan_set_error(info: duckdb_replacement_scan_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Returns the root node of the profiling information. Returns nullptr, if profiling is not enabled.\n\n @param connection A connection object.\n @return A profiling information object."]
+    pub fn duckdb_get_profiling_info(connection: duckdb_connection) -> duckdb_profiling_info;
+}
+unsafe extern "C" {
+    #[doc = "Returns the value of the metric of the current profiling info node. Returns nullptr, if the metric does\nnot exist or is not enabled. Currently, the value holds a string, and you can retrieve the string\nby calling the corresponding function: char *duckdb_get_varchar(duckdb_value value).\n\n @param info A profiling information object.\n @param key The name of the requested metric.\n @return The value of the metric. Must be freed with `duckdb_destroy_value`"]
+    pub fn duckdb_profiling_info_get_value(
+        info: duckdb_profiling_info,
+        key: *const ::std::os::raw::c_char,
+    ) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns the key-value metric map of this profiling node as a MAP duckdb_value.\nThe individual elements are accessible via the duckdb_value MAP functions.\n\n @param info A profiling information object.\n @return The key-value metric map as a MAP duckdb_value."]
+    pub fn duckdb_profiling_info_get_metrics(info: duckdb_profiling_info) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of children in the current profiling info node.\n\n @param info A profiling information object.\n @return The number of children in the current node."]
+    pub fn duckdb_profiling_info_get_child_count(info: duckdb_profiling_info) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the child node at the specified index.\n\n @param info A profiling information object.\n @param index The index of the child node.\n @return The child node at the specified index."]
+    pub fn duckdb_profiling_info_get_child(info: duckdb_profiling_info, index: idx_t) -> duckdb_profiling_info;
+}
+unsafe extern "C" {
+    #[doc = "Creates an appender object.\n\nNote that the object must be destroyed with `duckdb_appender_destroy`.\n\n @param connection The connection context to create the appender in.\n @param schema The schema of the table to append to, or `nullptr` for the default schema.\n @param table The table name to append to.\n @param out_appender The resulting appender object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_create(
+        connection: duckdb_connection,
+        schema: *const ::std::os::raw::c_char,
+        table: *const ::std::os::raw::c_char,
+        out_appender: *mut duckdb_appender,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Creates an appender object.\n\nNote that the object must be destroyed with `duckdb_appender_destroy`.\n\n @param connection The connection context to create the appender in.\n @param catalog The catalog of the table to append to, or `nullptr` for the default catalog.\n @param schema The schema of the table to append to, or `nullptr` for the default schema.\n @param table The table name to append to.\n @param out_appender The resulting appender object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_create_ext(
+        connection: duckdb_connection,
+        catalog: *const ::std::os::raw::c_char,
+        schema: *const ::std::os::raw::c_char,
+        table: *const ::std::os::raw::c_char,
+        out_appender: *mut duckdb_appender,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Creates an appender object that executes the given query with any data appended to it.\n\nNote that the object must be destroyed with `duckdb_appender_destroy`.\n\n @param connection The connection context to create the appender in.\n @param query The query to execute, can be an INSERT, DELETE, UPDATE or MERGE INTO statement.\n @param column_count The number of columns to append.\n @param types The types of the columns to append.\n @param table_name (optionally) the table name used to refer to the appended data, defaults to \"appended_data\".\n @param column_names (optionally) the list of column names, defaults to \"col1\", \"col2\", ...\n @param out_appender The resulting appender object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_create_query(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        column_count: idx_t,
+        types: *mut duckdb_logical_type,
+        table_name: *const ::std::os::raw::c_char,
+        column_names: *mut *const ::std::os::raw::c_char,
+        out_appender: *mut duckdb_appender,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Returns the number of columns that belong to the appender.\nIf there is no active column list, then this equals the table's physical columns.\n\n @param appender The appender to get the column count from.\n @return The number of columns in the data chunks."]
+    pub fn duckdb_appender_column_count(appender: duckdb_appender) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Returns the type of the column at the specified index. This is either a type in the active column list, or the same type\nas a column in the receiving table.\n\nNote: The resulting type must be destroyed with `duckdb_destroy_logical_type`.\n\n @param appender The appender to get the column type from.\n @param col_idx The index of the column to get the type of.\n @return The `duckdb_logical_type` of the column."]
+    pub fn duckdb_appender_column_type(appender: duckdb_appender, col_idx: idx_t) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\nUse duckdb_appender_error_data instead.\n\nReturns the error message associated with the appender.\nIf the appender has no error message, this returns `nullptr` instead.\n\nThe error message should not be freed. It will be de-allocated when `duckdb_appender_destroy` is called.\n\n @param appender The appender to get the error from.\n @return The error message, or `nullptr` if there is none."]
+    pub fn duckdb_appender_error(appender: duckdb_appender) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Returns the error data associated with the appender.\nMust be destroyed with duckdb_destroy_error_data.\n\n @param appender The appender to get the error data from.\n @return The error data."]
+    pub fn duckdb_appender_error_data(appender: duckdb_appender) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Flush the appender to the table, forcing the cache of the appender to be cleared. If flushing the data triggers a\nconstraint violation or any other error, then all data is invalidated, and this function returns DuckDBError.\nIt is not possible to append more values. Call duckdb_appender_error_data to obtain the error data followed by\nduckdb_appender_destroy to destroy the invalidated appender.\n\n @param appender The appender to flush.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_flush(appender: duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Clears all buffered data from the appender without flushing it to the table. This discards any data that has been\nappended but not yet written. The appender can continue to be used after clearing.\n\n @param appender The appender to clear.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_clear(appender: duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Closes the appender by flushing all intermediate states and closing it for further appends. If flushing the data\ntriggers a constraint violation or any other error, then all data is invalidated, and this function returns DuckDBError.\nCall duckdb_appender_error_data to obtain the error data followed by duckdb_appender_destroy to destroy the invalidated\nappender.\n\n @param appender The appender to flush and close.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_close(appender: duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Closes the appender by flushing all intermediate states to the table and destroying it. By destroying it, this function\nde-allocates all memory associated with the appender. If flushing the data triggers a constraint violation,\nthen all data is invalidated, and this function returns DuckDBError. Due to the destruction of the appender, it is no\nlonger possible to obtain the specific error message with duckdb_appender_error. Therefore, call duckdb_appender_close\nbefore destroying the appender, if you need insights into the specific error.\n\n @param appender The appender to flush, close and destroy.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_destroy(appender: *mut duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Appends a column to the active column list of the appender. Immediately flushes all previous data.\n\nThe active column list specifies all columns that are expected when flushing the data. Any non-active columns are filled\nwith their default values, or NULL.\n\n @param appender The appender to add the column to.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_add_column(appender: duckdb_appender, name: *const ::std::os::raw::c_char) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Removes all columns from the active column list of the appender, resetting the appender to treat all columns as active.\nImmediately flushes all previous data.\n\n @param appender The appender to clear the columns from.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_clear_columns(appender: duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "A nop function, provided for backwards compatibility reasons. Does nothing. Only `duckdb_appender_end_row` is required."]
+    pub fn duckdb_appender_begin_row(appender: duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Finish the current row of appends. After end_row is called, the next row can be appended.\n\n @param appender The appender.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_appender_end_row(appender: duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a DEFAULT value (NULL if DEFAULT not available for column) to the appender."]
+    pub fn duckdb_append_default(appender: duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a DEFAULT value, at the specified row and column, (NULL if DEFAULT not available for column) to the chunk created\nfrom the specified appender. The default value of the column must be a constant value. Non-deterministic expressions\nlike nextval('seq') or random() are not supported.\n\n @param appender The appender to get the default value from.\n @param chunk The data chunk to append the default value to.\n @param col The chunk column index to append the default value to.\n @param row The chunk row index to append the default value to.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_append_default_to_chunk(
+        appender: duckdb_appender,
+        chunk: duckdb_data_chunk,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a bool value to the appender."]
+    pub fn duckdb_append_bool(appender: duckdb_appender, value: bool) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append an int8_t value to the appender."]
+    pub fn duckdb_append_int8(appender: duckdb_appender, value: i8) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append an int16_t value to the appender."]
+    pub fn duckdb_append_int16(appender: duckdb_appender, value: i16) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append an int32_t value to the appender."]
+    pub fn duckdb_append_int32(appender: duckdb_appender, value: i32) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append an int64_t value to the appender."]
+    pub fn duckdb_append_int64(appender: duckdb_appender, value: i64) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a duckdb_hugeint value to the appender."]
+    pub fn duckdb_append_hugeint(appender: duckdb_appender, value: duckdb_hugeint) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a uint8_t value to the appender."]
+    pub fn duckdb_append_uint8(appender: duckdb_appender, value: u8) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a uint16_t value to the appender."]
+    pub fn duckdb_append_uint16(appender: duckdb_appender, value: u16) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a uint32_t value to the appender."]
+    pub fn duckdb_append_uint32(appender: duckdb_appender, value: u32) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a uint64_t value to the appender."]
+    pub fn duckdb_append_uint64(appender: duckdb_appender, value: u64) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a duckdb_uhugeint value to the appender."]
+    pub fn duckdb_append_uhugeint(appender: duckdb_appender, value: duckdb_uhugeint) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a float value to the appender."]
+    pub fn duckdb_append_float(appender: duckdb_appender, value: f32) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a double value to the appender."]
+    pub fn duckdb_append_double(appender: duckdb_appender, value: f64) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a duckdb_date value to the appender."]
+    pub fn duckdb_append_date(appender: duckdb_appender, value: duckdb_date) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a duckdb_time value to the appender."]
+    pub fn duckdb_append_time(appender: duckdb_appender, value: duckdb_time) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a duckdb_timestamp value to the appender."]
+    pub fn duckdb_append_timestamp(appender: duckdb_appender, value: duckdb_timestamp) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a duckdb_interval value to the appender."]
+    pub fn duckdb_append_interval(appender: duckdb_appender, value: duckdb_interval) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a varchar value to the appender."]
+    pub fn duckdb_append_varchar(appender: duckdb_appender, val: *const ::std::os::raw::c_char) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a varchar value to the appender."]
+    pub fn duckdb_append_varchar_length(
+        appender: duckdb_appender,
+        val: *const ::std::os::raw::c_char,
+        length: idx_t,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a blob value to the appender."]
+    pub fn duckdb_append_blob(
+        appender: duckdb_appender,
+        data: *const ::std::os::raw::c_void,
+        length: idx_t,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a NULL value to the appender (of any type)."]
+    pub fn duckdb_append_null(appender: duckdb_appender) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Append a duckdb_value to the appender."]
+    pub fn duckdb_append_value(appender: duckdb_appender, value: duckdb_value) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Appends a pre-filled data chunk to the specified appender.\nAttempts casting, if the data chunk types do not match the active appender types.\n\n @param appender The appender to append to.\n @param chunk The data chunk to append.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_append_data_chunk(appender: duckdb_appender, chunk: duckdb_data_chunk) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Creates a table description object. Note that `duckdb_table_description_destroy` should always be called on the\nresulting table_description, even if the function returns `DuckDBError`.\n\n @param connection The connection context.\n @param schema The schema of the table, or `nullptr` for the default schema.\n @param table The table name.\n @param out The resulting table description object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_table_description_create(
+        connection: duckdb_connection,
+        schema: *const ::std::os::raw::c_char,
+        table: *const ::std::os::raw::c_char,
+        out: *mut duckdb_table_description,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Creates a table description object. Note that `duckdb_table_description_destroy` must be called on the resulting\ntable_description, even if the function returns `DuckDBError`.\n\n @param connection The connection context.\n @param catalog The catalog (database) name of the table, or `nullptr` for the default catalog.\n @param schema The schema of the table, or `nullptr` for the default schema.\n @param table The table name.\n @param out The resulting table description object.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_table_description_create_ext(
+        connection: duckdb_connection,
+        catalog: *const ::std::os::raw::c_char,
+        schema: *const ::std::os::raw::c_char,
+        table: *const ::std::os::raw::c_char,
+        out: *mut duckdb_table_description,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Destroy the TableDescription object.\n\n @param table_description The table_description to destroy."]
+    pub fn duckdb_table_description_destroy(table_description: *mut duckdb_table_description);
+}
+unsafe extern "C" {
+    #[doc = "Returns the error message associated with the given table_description.\nIf the table_description has no error message, this returns `nullptr` instead.\nThe error message should not be freed. It will be de-allocated when `duckdb_table_description_destroy` is called.\n\n @param table_description The table_description to get the error from.\n @return The error message, or `nullptr` if there is none."]
+    pub fn duckdb_table_description_error(table_description: duckdb_table_description)
+    -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Check if the column at 'index' index of the table has a DEFAULT expression.\n\n @param table_description The table_description to query.\n @param index The index of the column to query.\n @param out The out-parameter used to store the result.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_column_has_default(
+        table_description: duckdb_table_description,
+        index: idx_t,
+        out: *mut bool,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Return the number of columns of the described table.\n\n @param table_description The table_description to query.\n @return The column count."]
+    pub fn duckdb_table_description_get_column_count(table_description: duckdb_table_description) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Obtain the column name at 'index'.\nThe out result must be destroyed with `duckdb_free`.\n\n @param table_description The table_description to query.\n @param index The index of the column to query.\n @return The column name."]
+    pub fn duckdb_table_description_get_column_name(
+        table_description: duckdb_table_description,
+        index: idx_t,
+    ) -> *mut ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Obtain the column type at 'index'.\nThe return value must be destroyed with `duckdb_destroy_logical_type`.\n\n @param table_description The table_description to query.\n @param index The index of the column to query.\n @return The column type."]
+    pub fn duckdb_table_description_get_column_type(
+        table_description: duckdb_table_description,
+        index: idx_t,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Transforms a DuckDB Schema into an Arrow Schema\n\n @param arrow_options The Arrow settings used to produce arrow.\n @param types The DuckDB logical types for each column in the schema.\n @param names The names for each column in the schema.\n @param column_count The number of columns that exist in the schema.\n @param out_schema The resulting arrow schema. Must be destroyed with `out_schema->release(out_schema)`.\n @return The error data. Must be destroyed with `duckdb_destroy_error_data`."]
+    pub fn duckdb_to_arrow_schema(
+        arrow_options: duckdb_arrow_options,
+        types: *mut duckdb_logical_type,
+        names: *mut *const ::std::os::raw::c_char,
+        column_count: idx_t,
+        out_schema: *mut ArrowSchema,
+    ) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Transforms a DuckDB data chunk into an Arrow array.\n\n @param arrow_options The Arrow settings used to produce arrow.\n @param chunk The DuckDB data chunk to convert.\n @param out_arrow_array The output Arrow structure that will hold the converted data. Must be released with\n`out_arrow_array->release(out_arrow_array)`\n @return The error data. Must be destroyed with `duckdb_destroy_error_data`."]
+    pub fn duckdb_data_chunk_to_arrow(
+        arrow_options: duckdb_arrow_options,
+        chunk: duckdb_data_chunk,
+        out_arrow_array: *mut ArrowArray,
+    ) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Transforms an Arrow Schema into a DuckDB Schema.\n\n @param connection The connection to get the transformation settings from.\n @param schema The input Arrow schema. Must be released with `schema->release(schema)`.\n @param out_types The Arrow converted schema with extra information about the arrow types. Must be destroyed with\n`duckdb_destroy_arrow_converted_schema`.\n @return The error data. Must be destroyed with `duckdb_destroy_error_data`."]
+    pub fn duckdb_schema_from_arrow(
+        connection: duckdb_connection,
+        schema: *mut ArrowSchema,
+        out_types: *mut duckdb_arrow_converted_schema,
+    ) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Transforms an Arrow array into a DuckDB data chunk. The data chunk will retain ownership of the underlying Arrow data.\n\n @param connection The connection to get the transformation settings from.\n @param arrow_array The input Arrow array. Data ownership is passed on to DuckDB's DataChunk, the underlying object\ndoes not need to be released and won't have ownership of the data.\n @param converted_schema The Arrow converted schema with extra information about the arrow types.\n @param out_chunk The resulting DuckDB data chunk. Must be destroyed by duckdb_destroy_data_chunk.\n @return The error data. Must be destroyed with `duckdb_destroy_error_data`."]
+    pub fn duckdb_data_chunk_from_arrow(
+        connection: duckdb_connection,
+        arrow_array: *mut ArrowArray,
+        converted_schema: duckdb_arrow_converted_schema,
+        out_chunk: *mut duckdb_data_chunk,
+    ) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the arrow converted schema and de-allocates all memory allocated for that arrow converted schema.\n\n @param arrow_converted_schema The arrow converted schema to destroy."]
+    pub fn duckdb_destroy_arrow_converted_schema(arrow_converted_schema: *mut duckdb_arrow_converted_schema);
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nExecutes a SQL query within a connection and stores the full (materialized) result in an arrow structure.\nIf the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling\n`duckdb_query_arrow_error`.\n\nNote that after running `duckdb_query_arrow`, `duckdb_destroy_arrow` must be called on the result object even if the\nquery fails, otherwise the error stored within the result will not be freed correctly.\n\n @param connection The connection to perform the query in.\n @param query The SQL query to run.\n @param out_result The query result.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_query_arrow(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        out_result: *mut duckdb_arrow,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nFetch the internal arrow schema from the arrow result. Remember to call release on the respective\nArrowSchema object.\n\n @param result The result to fetch the schema from.\n @param out_schema The output schema.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_query_arrow_schema(result: duckdb_arrow, out_schema: *mut duckdb_arrow_schema) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nFetch the internal arrow schema from the prepared statement. Remember to call release on the respective\nArrowSchema object.\n\n @param prepared The prepared statement to fetch the schema from.\n @param out_schema The output schema.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_prepared_arrow_schema(
+        prepared: duckdb_prepared_statement,
+        out_schema: *mut duckdb_arrow_schema,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nConvert a data chunk into an arrow struct array. Remember to call release on the respective\nArrowArray object.\n\n @param result The result object the data chunk have been fetched from.\n @param chunk The data chunk to convert.\n @param out_array The output array."]
+    pub fn duckdb_result_arrow_array(
+        result: duckdb_result,
+        chunk: duckdb_data_chunk,
+        out_array: *mut duckdb_arrow_array,
+    );
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nFetch an internal arrow struct array from the arrow result. Remember to call release on the respective\nArrowArray object.\n\nThis function can be called multiple time to get next chunks, which will free the previous out_array.\nSo consume the out_array before calling this function again.\n\n @param result The result to fetch the array from.\n @param out_array The output array.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_query_arrow_array(result: duckdb_arrow, out_array: *mut duckdb_arrow_array) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nReturns the number of columns present in the arrow result object.\n\n @param result The result object.\n @return The number of columns present in the result object."]
+    pub fn duckdb_arrow_column_count(result: duckdb_arrow) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nReturns the number of rows present in the arrow result object.\n\n @param result The result object.\n @return The number of rows present in the result object."]
+    pub fn duckdb_arrow_row_count(result: duckdb_arrow) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nReturns the number of rows changed by the query stored in the arrow result. This is relevant only for\nINSERT/UPDATE/DELETE queries. For other queries the rows_changed will be 0.\n\n @param result The result object.\n @return The number of rows changed."]
+    pub fn duckdb_arrow_rows_changed(result: duckdb_arrow) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nReturns the error message contained within the result. The error is only set if `duckdb_query_arrow` returns\n`DuckDBError`.\n\nThe error message should not be freed. It will be de-allocated when `duckdb_destroy_arrow` is called.\n\n @param result The result object to fetch the error from.\n @return The error of the result."]
+    pub fn duckdb_query_arrow_error(result: duckdb_arrow) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nCloses the result and de-allocates all memory allocated for the arrow result.\n\n @param result The result to destroy."]
+    pub fn duckdb_destroy_arrow(result: *mut duckdb_arrow);
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nReleases the arrow array stream and de-allocates its memory.\n\n @param stream_p The arrow array stream to destroy."]
+    pub fn duckdb_destroy_arrow_stream(stream_p: *mut duckdb_arrow_stream);
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nExecutes the prepared statement with the given bound parameters, and returns an arrow query result.\nNote that after running `duckdb_execute_prepared_arrow`, `duckdb_destroy_arrow` must be called on the result object.\n\n @param prepared_statement The prepared statement to execute.\n @param out_result The query result.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_execute_prepared_arrow(
+        prepared_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_arrow,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nScans the Arrow stream and creates a view with the given name.\n\n @param connection The connection on which to execute the scan.\n @param table_name Name of the temporary view to create.\n @param arrow Arrow stream wrapper.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_arrow_scan(
+        connection: duckdb_connection,
+        table_name: *const ::std::os::raw::c_char,
+        arrow: duckdb_arrow_stream,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nScans the Arrow array and creates a view with the given name.\nNote that after running `duckdb_arrow_array_scan`, `duckdb_destroy_arrow_stream` must be called on the out stream.\n\n @param connection The connection on which to execute the scan.\n @param table_name Name of the temporary view to create.\n @param arrow_schema Arrow schema wrapper.\n @param arrow_array Arrow array wrapper.\n @param out_stream Output array stream that wraps around the passed schema, for releasing/deleting once done.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure."]
+    pub fn duckdb_arrow_array_scan(
+        connection: duckdb_connection,
+        table_name: *const ::std::os::raw::c_char,
+        arrow_schema: duckdb_arrow_schema,
+        arrow_array: duckdb_arrow_array,
+        out_stream: *mut duckdb_arrow_stream,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Execute DuckDB tasks on this thread.\n\nWill return after `max_tasks` have been executed, or if there are no more tasks present.\n\n @param database The database object to execute tasks for\n @param max_tasks The maximum amount of tasks to execute"]
+    pub fn duckdb_execute_tasks(database: duckdb_database, max_tasks: idx_t);
+}
+unsafe extern "C" {
+    #[doc = "Creates a task state that can be used with duckdb_execute_tasks_state to execute tasks until\n`duckdb_finish_execution` is called on the state.\n\n`duckdb_destroy_state` must be called on the result.\n\n @param database The database object to create the task state for\n @return The task state that can be used with duckdb_execute_tasks_state."]
+    pub fn duckdb_create_task_state(database: duckdb_database) -> duckdb_task_state;
+}
+unsafe extern "C" {
+    #[doc = "Execute DuckDB tasks on this thread.\n\nThe thread will keep on executing tasks forever, until duckdb_finish_execution is called on the state.\nMultiple threads can share the same duckdb_task_state.\n\n @param state The task state of the executor"]
+    pub fn duckdb_execute_tasks_state(state: duckdb_task_state);
+}
+unsafe extern "C" {
+    #[doc = "Execute DuckDB tasks on this thread.\n\nThe thread will keep on executing tasks until either duckdb_finish_execution is called on the state,\nmax_tasks tasks have been executed or there are no more tasks to be executed.\n\nMultiple threads can share the same duckdb_task_state.\n\n @param state The task state of the executor\n @param max_tasks The maximum amount of tasks to execute\n @return The amount of tasks that have actually been executed"]
+    pub fn duckdb_execute_n_tasks_state(state: duckdb_task_state, max_tasks: idx_t) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Finish execution on a specific task.\n\n @param state The task state to finish execution"]
+    pub fn duckdb_finish_execution(state: duckdb_task_state);
+}
+unsafe extern "C" {
+    #[doc = "Check if the provided duckdb_task_state has finished execution\n\n @param state The task state to inspect\n @return Whether or not duckdb_finish_execution has been called on the task state"]
+    pub fn duckdb_task_state_is_finished(state: duckdb_task_state) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the task state returned from duckdb_create_task_state.\n\nNote that this should not be called while there is an active duckdb_execute_tasks_state running\non the task state.\n\n @param state The task state to clean up"]
+    pub fn duckdb_destroy_task_state(state: duckdb_task_state);
+}
+unsafe extern "C" {
+    #[doc = "Returns true if the execution of the current query is finished.\n\n @param con The connection on which to check"]
+    pub fn duckdb_execution_is_finished(con: duckdb_connection) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "DEPRECATION NOTICE**: This method is scheduled for removal in a future release.\n\nFetches a data chunk from the (streaming) duckdb_result. This function should be called repeatedly until the result is\nexhausted.\n\nThe result must be destroyed with `duckdb_destroy_data_chunk`.\n\nThis function can only be used on duckdb_results created with 'duckdb_pending_prepared_streaming'\n\nIf this function is used, none of the other result functions can be used and vice versa (i.e. this function cannot be\nmixed with the legacy result functions or the materialized result functions).\n\nIt is not known beforehand how many chunks will be returned by this result.\n\n @param result The result object to fetch the data chunk from.\n @return The resulting data chunk. Returns `NULL` if the result has an error."]
+    pub fn duckdb_stream_fetch_chunk(result: duckdb_result) -> duckdb_data_chunk;
+}
+unsafe extern "C" {
+    #[doc = "Fetches a data chunk from a duckdb_result. This function should be called repeatedly until the result is exhausted.\n\nThe result must be destroyed with `duckdb_destroy_data_chunk`.\n\nIt is not known beforehand how many chunks will be returned by this result.\n\n @param result The result object to fetch the data chunk from.\n @return The resulting data chunk. Returns `NULL` if the result has an error."]
+    pub fn duckdb_fetch_chunk(result: duckdb_result) -> duckdb_data_chunk;
+}
+unsafe extern "C" {
+    #[doc = "Creates a new cast function object.\n\n @return The cast function object."]
+    pub fn duckdb_create_cast_function() -> duckdb_cast_function;
+}
+unsafe extern "C" {
+    #[doc = "Sets the source type of the cast function.\n\n @param cast_function The cast function object.\n @param source_type The source type to set."]
+    pub fn duckdb_cast_function_set_source_type(cast_function: duckdb_cast_function, source_type: duckdb_logical_type);
+}
+unsafe extern "C" {
+    #[doc = "Sets the target type of the cast function.\n\n @param cast_function The cast function object.\n @param target_type The target type to set."]
+    pub fn duckdb_cast_function_set_target_type(cast_function: duckdb_cast_function, target_type: duckdb_logical_type);
+}
+unsafe extern "C" {
+    #[doc = "Sets the \"cost\" of implicitly casting the source type to the target type using this function.\n\n @param cast_function The cast function object.\n @param cost The cost to set."]
+    pub fn duckdb_cast_function_set_implicit_cast_cost(cast_function: duckdb_cast_function, cost: i64);
+}
+unsafe extern "C" {
+    #[doc = "Sets the actual cast function to use.\n\n @param cast_function The cast function object.\n @param function The function to set."]
+    pub fn duckdb_cast_function_set_function(cast_function: duckdb_cast_function, function: duckdb_cast_function_t);
+}
+unsafe extern "C" {
+    #[doc = "Assigns extra information to the cast function that can be fetched during execution, etc.\n\n @param extra_info The extra information\n @param destroy The callback that will be called to destroy the extra information (if any)"]
+    pub fn duckdb_cast_function_set_extra_info(
+        cast_function: duckdb_cast_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info of the function as set in `duckdb_cast_function_set_extra_info`.\n\n @param info The info object.\n @return The extra info."]
+    pub fn duckdb_cast_function_get_extra_info(info: duckdb_function_info) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Get the cast execution mode from the given function info.\n\n @param info The info object.\n @return The cast mode."]
+    pub fn duckdb_cast_function_get_cast_mode(info: duckdb_function_info) -> duckdb_cast_mode;
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while executing the cast function.\n\n @param info The info object.\n @param error The error message."]
+    pub fn duckdb_cast_function_set_error(info: duckdb_function_info, error: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Report that an error has occurred while executing the cast function, setting the corresponding output row to NULL.\n\n @param info The info object.\n @param error The error message.\n @param row The index of the row within the output vector to set to NULL.\n @param output The output vector."]
+    pub fn duckdb_cast_function_set_row_error(
+        info: duckdb_function_info,
+        error: *const ::std::os::raw::c_char,
+        row: idx_t,
+        output: duckdb_vector,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Registers a cast function within the given connection.\n\n @param con The connection to use.\n @param cast_function The cast function to register.\n @return Whether or not the registration was successful."]
+    pub fn duckdb_register_cast_function(con: duckdb_connection, cast_function: duckdb_cast_function) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the cast function object.\n\n @param cast_function The cast function object."]
+    pub fn duckdb_destroy_cast_function(cast_function: *mut duckdb_cast_function);
+}
+unsafe extern "C" {
+    #[doc = "Destroys the expression and de-allocates its memory.\n\n @param expr A pointer to the expression."]
+    pub fn duckdb_destroy_expression(expr: *mut duckdb_expression);
+}
+unsafe extern "C" {
+    #[doc = "Returns the return type of an expression.\n\n @param expr The expression.\n @return The return type. Must be destroyed with `duckdb_destroy_logical_type`."]
+    pub fn duckdb_expression_return_type(expr: duckdb_expression) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Returns whether the expression is foldable into a value or not.\n\n @param expr The expression.\n @return True, if the expression is foldable, else false."]
+    pub fn duckdb_expression_is_foldable(expr: duckdb_expression) -> bool;
+}
+unsafe extern "C" {
+    #[doc = "Folds an expression creating a folded value.\n\n @param context The client context.\n @param expr The expression. Must be foldable.\n @param out_value The folded value, if folding was successful. Must be destroyed with `duckdb_destroy_value`.\n @return The error data. Must be destroyed with `duckdb_destroy_error_data`."]
+    pub fn duckdb_expression_fold(
+        context: duckdb_client_context,
+        expr: duckdb_expression,
+        out_value: *mut duckdb_value,
+    ) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Get a file system instance associated with the given client context.\n\n @param context The client context.\n @return The resulting file system instance. Must be destroyed with `duckdb_destroy_file_system`."]
+    pub fn duckdb_client_context_get_file_system(context: duckdb_client_context) -> duckdb_file_system;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given file system instance.\n @param file_system The file system instance to destroy."]
+    pub fn duckdb_destroy_file_system(file_system: *mut duckdb_file_system);
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the last error that occurred on the given file system instance.\n\n @param file_system The file system instance.\n @return The error data."]
+    pub fn duckdb_file_system_error_data(file_system: duckdb_file_system) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Opens a file at the given path with the specified options.\n\n @param file_system The file system instance.\n @param path The path to the file.\n @param options The file open options specifying how to open the file.\n @param out_file The resulting file handle instance, or `nullptr` if the open failed. Must be destroyed with\n`duckdb_destroy_file_handle`.\n @return Whether the operation was successful. If not, the error data can be retrieved using\n`duckdb_file_system_error_data`."]
+    pub fn duckdb_file_system_open(
+        file_system: duckdb_file_system,
+        path: *const ::std::os::raw::c_char,
+        options: duckdb_file_open_options,
+        out_file: *mut duckdb_file_handle,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Creates a new file open options instance with blank settings.\n\n @return The new file open options instance. Must be destroyed with `duckdb_destroy_file_open_options`."]
+    pub fn duckdb_create_file_open_options() -> duckdb_file_open_options;
+}
+unsafe extern "C" {
+    #[doc = "Sets a specific flag in the file open options.\n\n @param options The file open options instance.\n @param flag The flag to set (e.g., read, write).\n @param value If the flag is enabled or disabled.\n @return `DuckDBSuccess` on success or `DuckDBError` if the flag is unrecognized or unsupported by this version of\nDuckDB."]
+    pub fn duckdb_file_open_options_set_flag(
+        options: duckdb_file_open_options,
+        flag: duckdb_file_flag,
+        value: bool,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given file open options instance.\n @param options The file open options instance to destroy."]
+    pub fn duckdb_destroy_file_open_options(options: *mut duckdb_file_open_options);
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given file handle and deallocates all associated resources.\nThis will also close the file if it is still open.\n\n @param file_handle The file handle to destroy."]
+    pub fn duckdb_destroy_file_handle(file_handle: *mut duckdb_file_handle);
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the last error that occurred on the given file handle.\n\n @param file_handle The file handle.\n @return The error data. Must be destroyed with `duckdb_destroy_error_data`"]
+    pub fn duckdb_file_handle_error_data(file_handle: duckdb_file_handle) -> duckdb_error_data;
+}
+unsafe extern "C" {
+    #[doc = "Reads data from the file into the buffer.\n\n @param file_handle The file handle to read from.\n @param buffer The buffer to read data into.\n @param size The number of bytes to read.\n @return The number of bytes actually read, or negative on error."]
+    pub fn duckdb_file_handle_read(
+        file_handle: duckdb_file_handle,
+        buffer: *mut ::std::os::raw::c_void,
+        size: i64,
+    ) -> i64;
+}
+unsafe extern "C" {
+    #[doc = "Writes data from the buffer to the file.\n\n @param file_handle The file handle to write to.\n @param buffer The buffer containing data to write.\n @param size The number of bytes to write.\n @return The number of bytes actually written, or negative on error."]
+    pub fn duckdb_file_handle_write(
+        file_handle: duckdb_file_handle,
+        buffer: *const ::std::os::raw::c_void,
+        size: i64,
+    ) -> i64;
+}
+unsafe extern "C" {
+    #[doc = "Tells the current position in the file.\n\n @param file_handle The file handle to tell the position of.\n @return The current position in the file, or negative on error."]
+    pub fn duckdb_file_handle_tell(file_handle: duckdb_file_handle) -> i64;
+}
+unsafe extern "C" {
+    #[doc = "Gets the size of the file.\n\n @param file_handle The file handle to get the size of.\n @return The size of the file in bytes, or negative on error."]
+    pub fn duckdb_file_handle_size(file_handle: duckdb_file_handle) -> i64;
+}
+unsafe extern "C" {
+    #[doc = "Seeks to a specific position in the file.\n\n @param file_handle The file handle to seek in.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure. If unsuccessful, the error data can be retrieved using\n`duckdb_file_handle_error_data`."]
+    pub fn duckdb_file_handle_seek(file_handle: duckdb_file_handle, position: i64) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Synchronizes the file's state with the underlying storage.\n\n @param file_handle The file handle to synchronize.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure. If unsuccessful, the error data can be retrieved using\n`duckdb_file_handle_error_data`."]
+    pub fn duckdb_file_handle_sync(file_handle: duckdb_file_handle) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Closes the given file handle.\n\n @param file_handle The file handle to close.\n @return `DuckDBSuccess` on success or `DuckDBError` on failure. If unsuccessful, the error data can be retrieved using\n`duckdb_file_handle_error_data`."]
+    pub fn duckdb_file_handle_close(file_handle: duckdb_file_handle) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Creates a configuration option instance.\n\n @return The resulting configuration option instance. Must be destroyed with `duckdb_destroy_config_option`."]
+    pub fn duckdb_create_config_option() -> duckdb_config_option;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given configuration option instance.\n @param option The configuration option instance to destroy."]
+    pub fn duckdb_destroy_config_option(option: *mut duckdb_config_option);
+}
+unsafe extern "C" {
+    #[doc = "Sets the name of the configuration option.\n\n @param option The configuration option instance.\n @param name The name to set."]
+    pub fn duckdb_config_option_set_name(option: duckdb_config_option, name: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Sets the type of the configuration option.\n\n @param option The configuration option instance.\n @param type The type to set."]
+    pub fn duckdb_config_option_set_type(option: duckdb_config_option, type_: duckdb_logical_type);
+}
+unsafe extern "C" {
+    #[doc = "Sets the default value of the configuration option.\nIf the type of this option has already been set with `duckdb_config_option_set_type`, the value is cast to the type.\nOtherwise, the type is inferred from the value.\n\n @param option The configuration option instance.\n @param default_value The default value to set."]
+    pub fn duckdb_config_option_set_default_value(option: duckdb_config_option, default_value: duckdb_value);
+}
+unsafe extern "C" {
+    #[doc = "Sets the default scope of the configuration option.\nIf not set, this defaults to `DUCKDB_CONFIG_OPTION_SCOPE_SESSION`.\n\n @param option The configuration option instance.\n @param default_scope The default scope to set."]
+    pub fn duckdb_config_option_set_default_scope(
+        option: duckdb_config_option,
+        default_scope: duckdb_config_option_scope,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the description of the configuration option.\n\n @param option The configuration option instance.\n @param description The description to set."]
+    pub fn duckdb_config_option_set_description(
+        option: duckdb_config_option,
+        description: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Registers the given configuration option on the specified connection.\n\n @param connection The connection to register the option on.\n @param option The configuration option instance to register.\n @return A duckdb_state indicating success or failure."]
+    pub fn duckdb_register_config_option(connection: duckdb_connection, option: duckdb_config_option) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the value of a configuration option by name from the given client context.\n\n @param context The client context.\n @param name The name of the configuration option to retrieve.\n @param out_scope Output parameter to optionally store the scope that the configuration option was retrieved from.\nIf this is `nullptr`, the scope is not returned.\nIf the requested option does not exist the scope is set to `DUCKDB_CONFIG_OPTION_SCOPE_INVALID`.\n @return The value of the configuration option. Returns `nullptr` if the option does not exist."]
+    pub fn duckdb_client_context_get_config_option(
+        context: duckdb_client_context,
+        name: *const ::std::os::raw::c_char,
+        out_scope: *mut duckdb_config_option_scope,
+    ) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Creates a new empty copy function.\n\nThe return value must be destroyed with `duckdb_destroy_copy_function`.\n\n @return The copy function object."]
+    pub fn duckdb_create_copy_function() -> duckdb_copy_function;
+}
+unsafe extern "C" {
+    #[doc = "Sets the name of the copy function.\n\n @param copy_function The copy function\n @param name The name to set"]
+    pub fn duckdb_copy_function_set_name(copy_function: duckdb_copy_function, name: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Sets the extra info pointer of the copy function, which can be used to store arbitrary data.\n\n @param copy_function The copy function\n @param extra_info The extra info pointer\n @param destructor  A destructor function to call to destroy the extra info"]
+    pub fn duckdb_copy_function_set_extra_info(
+        copy_function: duckdb_copy_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destructor: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Registers the given copy function on the database connection under the specified name.\n\n @param connection The database connection\n @param copy_function The copy function to register"]
+    pub fn duckdb_register_copy_function(
+        connection: duckdb_connection,
+        copy_function: duckdb_copy_function,
+    ) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given copy function object.\n @param copy_function The copy function to destroy."]
+    pub fn duckdb_destroy_copy_function(copy_function: *mut duckdb_copy_function);
+}
+unsafe extern "C" {
+    #[doc = "Sets the bind function of the copy function, to use when binding `COPY ... TO`.\n\n @param bind The bind function"]
+    pub fn duckdb_copy_function_set_bind(copy_function: duckdb_copy_function, bind: duckdb_copy_function_bind_t);
+}
+unsafe extern "C" {
+    #[doc = "Report that an error occurred during the binding-phase of a `COPY ... TO` function.\n\n @param info The bind info provided to the bind function\n @param error The error message"]
+    pub fn duckdb_copy_function_bind_set_error(
+        info: duckdb_copy_function_bind_info,
+        error: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info pointer of the copy function.\n\n @param info The bind info provided to the bind function\n @return The extra info pointer."]
+    pub fn duckdb_copy_function_bind_get_extra_info(
+        info: duckdb_copy_function_bind_info,
+    ) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the client context of the current connection binding the `COPY ... TO` function.\n\nMust be destroyed with `duckdb_destroy_client_context`\n\n @param info The bind info provided to the bind function\n @return The client context."]
+    pub fn duckdb_copy_function_bind_get_client_context(info: duckdb_copy_function_bind_info) -> duckdb_client_context;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the number of columns that will be provided to the `COPY ... TO` function.\n\n @param info The bind info provided to the bind function\n @return The number of columns."]
+    pub fn duckdb_copy_function_bind_get_column_count(info: duckdb_copy_function_bind_info) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the type of a column that will be provided to the `COPY ... TO` function.\n\n @param info The bind info provided to the bind function\n @param col_idx The index of the column to retrieve the type for\n @return The type of the column. Must be destroyed with `duckdb_destroy_logical_type`."]
+    pub fn duckdb_copy_function_bind_get_column_type(
+        info: duckdb_copy_function_bind_info,
+        col_idx: idx_t,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves all values for the given options provided to the `COPY ... TO` function.\n\n @param info The bind info provided to the bind function\n @return A STRUCT value containing all options as fields. Must be destroyed with `duckdb_destroy_value`."]
+    pub fn duckdb_copy_function_bind_get_options(info: duckdb_copy_function_bind_info) -> duckdb_value;
+}
+unsafe extern "C" {
+    #[doc = "Sets the bind data of the copy function, to be provided to the init, sink and finalize functions.\n\n @param info The bind info provided to the bind function\n @param bind_data The bind data pointer\n @param destructor  A destructor function to call to destroy the bind data"]
+    pub fn duckdb_copy_function_bind_set_bind_data(
+        info: duckdb_copy_function_bind_info,
+        bind_data: *mut ::std::os::raw::c_void,
+        destructor: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the initialization function of the copy function, called right before executing `COPY ... TO`.\n\n @param init The init function"]
+    pub fn duckdb_copy_function_set_global_init(
+        copy_function: duckdb_copy_function,
+        init: duckdb_copy_function_global_init_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Report that an error occurred during the initialization-phase of a `COPY ... TO` function.\n\n @param info The init info provided to the init function\n @param error The error message"]
+    pub fn duckdb_copy_function_global_init_set_error(
+        info: duckdb_copy_function_global_init_info,
+        error: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info pointer of the copy function.\n\n @param info The init info provided to the init function\n @return The extra info pointer."]
+    pub fn duckdb_copy_function_global_init_get_extra_info(
+        info: duckdb_copy_function_global_init_info,
+    ) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the client context of the current connection initializing the `COPY ... TO` function.\n\nMust be destroyed with `duckdb_destroy_client_context`\n\n @param info The init info provided to the init function\n @return The client context."]
+    pub fn duckdb_copy_function_global_init_get_client_context(
+        info: duckdb_copy_function_global_init_info,
+    ) -> duckdb_client_context;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the bind data provided during the binding-phase of a `COPY ... TO` function.\n\n @param info The init info provided to the init function\n @return The bind data pointer."]
+    pub fn duckdb_copy_function_global_init_get_bind_data(
+        info: duckdb_copy_function_global_init_info,
+    ) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the file path provided to the `COPY ... TO` function.\n\nLives for the duration of the initialization callback, must not be destroyed.\n\n @param info The init info provided to the init function\n @return The file path."]
+    pub fn duckdb_copy_function_global_init_get_file_path(
+        info: duckdb_copy_function_global_init_info,
+    ) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Sets the global state of the copy function, to be provided to all subsequent local init, sink and finalize functions.\n\n @param info The init info provided to the init function\n @param global_state The global state pointer\n @param destructor  A destructor function to call to destroy the global state"]
+    pub fn duckdb_copy_function_global_init_set_global_state(
+        info: duckdb_copy_function_global_init_info,
+        global_state: *mut ::std::os::raw::c_void,
+        destructor: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the sink function of the copy function, called during `COPY ... TO`.\n\n @param function The sink function"]
+    pub fn duckdb_copy_function_set_sink(copy_function: duckdb_copy_function, function: duckdb_copy_function_sink_t);
+}
+unsafe extern "C" {
+    #[doc = "Report that an error occurred during the sink-phase of a `COPY ... TO` function.\n\n @param info The sink info provided to the sink function\n @param error The error message"]
+    pub fn duckdb_copy_function_sink_set_error(
+        info: duckdb_copy_function_sink_info,
+        error: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info pointer of the copy function.\n\n @param info The sink info provided to the sink function\n @return The extra info pointer."]
+    pub fn duckdb_copy_function_sink_get_extra_info(
+        info: duckdb_copy_function_sink_info,
+    ) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the client context of the current connection during the sink-phase of the `COPY ... TO` function.\n\nMust be destroyed with `duckdb_destroy_client_context`\n\n @param info The sink info provided to the sink function\n @return The client context."]
+    pub fn duckdb_copy_function_sink_get_client_context(info: duckdb_copy_function_sink_info) -> duckdb_client_context;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the bind data provided during the binding-phase of a `COPY ... TO` function.\n\n @param info The sink info provided to the sink function\n @return The bind data pointer."]
+    pub fn duckdb_copy_function_sink_get_bind_data(info: duckdb_copy_function_sink_info)
+    -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the global state provided during the init-phase of a `COPY ... TO` function.\n\n @param info The sink info provided to the sink function\n @return The global state pointer."]
+    pub fn duckdb_copy_function_sink_get_global_state(
+        info: duckdb_copy_function_sink_info,
+    ) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Sets the finalize function of the copy function, called at the end of `COPY ... TO`.\n\n @param finalize The finalize function"]
+    pub fn duckdb_copy_function_set_finalize(
+        copy_function: duckdb_copy_function,
+        finalize: duckdb_copy_function_finalize_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Report that an error occurred during the finalize-phase of a `COPY ... TO` function\n\n @param info The finalize info provided to the finalize function\n @param error The error message"]
+    pub fn duckdb_copy_function_finalize_set_error(
+        info: duckdb_copy_function_finalize_info,
+        error: *const ::std::os::raw::c_char,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the extra info pointer of the copy function.\n\n @param info The finalize info provided to the finalize function\n @return The extra info pointer."]
+    pub fn duckdb_copy_function_finalize_get_extra_info(
+        info: duckdb_copy_function_finalize_info,
+    ) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the client context of the current connection during the finalize-phase of the `COPY ... TO` function.\n\nMust be destroyed with `duckdb_destroy_client_context`\n\n @param info The finalize info provided to the finalize function\n @return The client context."]
+    pub fn duckdb_copy_function_finalize_get_client_context(
+        info: duckdb_copy_function_finalize_info,
+    ) -> duckdb_client_context;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the bind data provided during the binding-phase of a `COPY ... TO` function.\n\n @param info The finalize info provided to the finalize function\n @return The bind data pointer."]
+    pub fn duckdb_copy_function_finalize_get_bind_data(
+        info: duckdb_copy_function_finalize_info,
+    ) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the global state provided during the init-phase of a `COPY ... TO` function.\n\n @param info The finalize info provided to the finalize function\n @return The global state pointer."]
+    pub fn duckdb_copy_function_finalize_get_global_state(
+        info: duckdb_copy_function_finalize_info,
+    ) -> *mut ::std::os::raw::c_void;
+}
+unsafe extern "C" {
+    #[doc = "Sets the table function to use when executing a `COPY ... FROM (...)` statement with this copy function.\n\nThe table function must have a `duckdb_table_function_bind_t`, `duckdb_table_function_init_t` and\n`duckdb_table_function_t` set.\n\nThe table function must take a single VARCHAR parameter (the file path).\n\nOptions passed to the `COPY ... FROM (...)` statement are forwarded as named parameters to the table function.\n\nSince `COPY ... FROM` copies into an already existing table, the table function should not define its own result columns\nusing `duckdb_bind_add_result_column` when binding . Instead use `duckdb_table_function_bind_get_result_column_count`\nand related functions in the bind callback of the table function to retrieve the schema of the target table of the `COPY\n... FROM` statement.\n\n @param copy_function The copy function\n @param table_function The table function to use for `COPY ... FROM`"]
+    pub fn duckdb_copy_function_set_copy_from_function(
+        copy_function: duckdb_copy_function,
+        table_function: duckdb_table_function,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the number of result columns of a table function.\n\nIf the table function is used in a `COPY ... FROM` statement, this can be used to retrieve the number of columns in the\ntarget table at the start of the bind callback.\n\n @param info The bind info provided to the bind function\n @return The number of result columns."]
+    pub fn duckdb_table_function_bind_get_result_column_count(info: duckdb_bind_info) -> idx_t;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the name of a result column of a table function.\n\nIf the table function is used in a `COPY ... FROM` statement, this can be used to retrieve the names of the columns in\nthe target table at the start of the bind callback.\n\nThe result is valid for the duration of the bind callback or until the next call to `duckdb_bind_add_result_column`, so\nit must not be destroyed.\n\n @param info The bind info provided to the bind function\n @param col_idx The index of the result column to retrieve the name for\n @return The name of the result column."]
+    pub fn duckdb_table_function_bind_get_result_column_name(
+        info: duckdb_bind_info,
+        col_idx: idx_t,
+    ) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Retrieves the type of a result column of a table function.\n\nIf the table function is used in a `COPY ... FROM` statement, this can be used to retrieve the types of the columns in\nthe target table at the start of the bind callback.\n\nThe result must be destroyed with `duckdb_destroy_logical_type`.\n\n @param info The bind info provided to the bind function\n @param col_idx The index of the result column to retrieve the type for\n @return The type of the result column."]
+    pub fn duckdb_table_function_bind_get_result_column_type(
+        info: duckdb_bind_info,
+        col_idx: idx_t,
+    ) -> duckdb_logical_type;
+}
+unsafe extern "C" {
+    #[doc = "Retrieve a database catalog instance by name.\nThis function can only be called from within the context of an active transaction, e.g. during execution of a registered\nfunction callback. Otherwise returns `nullptr`.\n @param context The client context.\n @param catalog_name The name of the catalog.\n @return The resulting catalog instance, or `nullptr` if called from outside an active transaction or if a catalog with\nthe specified name does not exist. Must be destroyed with `duckdb_destroy_catalog`"]
+    pub fn duckdb_client_context_get_catalog(
+        context: duckdb_client_context,
+        catalog_name: *const ::std::os::raw::c_char,
+    ) -> duckdb_catalog;
+}
+unsafe extern "C" {
+    #[doc = "Retrieve the \"type name\" of the given catalog.\nE.g. for a DuckDB database, this returns 'duckdb'.\nThe returned string is owned by the catalog and remains valid until the catalog is destroyed.\n\n @param catalog The catalog.\n @return The type name of the catalog."]
+    pub fn duckdb_catalog_get_type_name(catalog: duckdb_catalog) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Retrieve a catalog entry from the given catalog by type, schema name and entry name.\nThe returned catalog entry remains valid for the duration of the current transaction.\n\n @param catalog The catalog.\n @param context The client context.\n @param entry_type The type of the catalog entry to retrieve.\n @param schema_name The schema name of the catalog entry.\n @param entry_name The name of the catalog entry.\n @return The resulting catalog entry, or `nullptr` if no such entry exists. Must be destroyed with\n`duckdb_destroy_catalog_entry`. Remains valid for the duration of the current transaction."]
+    pub fn duckdb_catalog_get_entry(
+        catalog: duckdb_catalog,
+        context: duckdb_client_context,
+        entry_type: duckdb_catalog_entry_type,
+        schema_name: *const ::std::os::raw::c_char,
+        entry_name: *const ::std::os::raw::c_char,
+    ) -> duckdb_catalog_entry;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given catalog instance.\n\nNote that this does not actually \"drop\" the contents of the catalog; it merely frees the C API handle.\n\n @param catalog The catalog instance to destroy."]
+    pub fn duckdb_destroy_catalog(catalog: *mut duckdb_catalog);
+}
+unsafe extern "C" {
+    #[doc = "Get the type of the given catalog entry.\n\n @param entry The catalog entry.\n @return The type of the catalog entry."]
+    pub fn duckdb_catalog_entry_get_type(entry: duckdb_catalog_entry) -> duckdb_catalog_entry_type;
+}
+unsafe extern "C" {
+    #[doc = "Get the name of the given catalog entry.\n\n @param entry The catalog entry.\n @return The name of the catalog entry. The returned string is owned by the catalog entry and remains valid until the\ncatalog entry is destroyed."]
+    pub fn duckdb_catalog_entry_get_name(entry: duckdb_catalog_entry) -> *const ::std::os::raw::c_char;
+}
+unsafe extern "C" {
+    #[doc = "Destroys the given catalog entry instance.\n\nNote that this does not actually \"drop\" the catalog entry from the database catalog; it merely frees the C API handle.\n\n @param entry The catalog entry instance to destroy."]
+    pub fn duckdb_destroy_catalog_entry(entry: *mut duckdb_catalog_entry);
+}
+unsafe extern "C" {
+    #[doc = "Creates a new log storage object.\n\n @return A log storage object. Must be destroyed with `duckdb_destroy_log_storage`."]
+    pub fn duckdb_create_log_storage() -> duckdb_log_storage;
+}
+unsafe extern "C" {
+    #[doc = "Destroys a log storage object.\n\n @param log_storage The log storage object to destroy."]
+    pub fn duckdb_destroy_log_storage(log_storage: *mut duckdb_log_storage);
+}
+unsafe extern "C" {
+    #[doc = "Sets the callback function for writing log entries.\n\n @param log_storage The log storage object.\n @param function The function to call."]
+    pub fn duckdb_log_storage_set_write_log_entry(
+        log_storage: duckdb_log_storage,
+        function: duckdb_logger_write_log_entry_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the extra data of the custom log storage.\n\n @param log_storage The log storage object.\n @param extra_data The extra data that is passed back into the callbacks.\n @param delete_callback The delete callback to call on the extra data, if any."]
+    pub fn duckdb_log_storage_set_extra_data(
+        log_storage: duckdb_log_storage,
+        extra_data: *mut ::std::os::raw::c_void,
+        delete_callback: duckdb_delete_callback_t,
+    );
+}
+unsafe extern "C" {
+    #[doc = "Sets the name of the log storage.\n\n @param log_storage The log storage object.\n @param name The name of the log storage."]
+    pub fn duckdb_log_storage_set_name(log_storage: duckdb_log_storage, name: *const ::std::os::raw::c_char);
+}
+unsafe extern "C" {
+    #[doc = "Registers a custom log storage for the logger.\n\n @param database A database object.\n @param log_storage The log storage object.\n @return Whether the registration was successful."]
+    pub fn duckdb_register_log_storage(database: duckdb_database, log_storage: duckdb_log_storage) -> duckdb_state;
+}
+unsafe extern "C" {
+    #[doc = "Gets the CRS (Coordinate Reference System) of a GEOMETRY type.\nResult must be freed with `duckdb_free`.\n\n @param type The GEOMETRY type.\n @return The CRS of the GEOMETRY type, or NULL if the type is not a GEOMETRY type."]
+    pub fn duckdb_geometry_type_get_crs(type_: duckdb_logical_type) -> *mut ::std::os::raw::c_char;
+}
diff --git a/rust_hft/native/libduckdb-sys/src/bindgen_bundled_version_loadable.rs b/rust_hft/native/libduckdb-sys/src/bindgen_bundled_version_loadable.rs
new file mode 100644
index 000000000..cdcecb94e
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/src/bindgen_bundled_version_loadable.rs
@@ -0,0 +1,14117 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const DUCKDB_TYPE_DUCKDB_TYPE_INVALID: DUCKDB_TYPE = 0;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BOOLEAN: DUCKDB_TYPE = 1;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TINYINT: DUCKDB_TYPE = 2;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_SMALLINT: DUCKDB_TYPE = 3;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_INTEGER: DUCKDB_TYPE = 4;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BIGINT: DUCKDB_TYPE = 5;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UTINYINT: DUCKDB_TYPE = 6;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_USMALLINT: DUCKDB_TYPE = 7;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UINTEGER: DUCKDB_TYPE = 8;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UBIGINT: DUCKDB_TYPE = 9;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_FLOAT: DUCKDB_TYPE = 10;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_DOUBLE: DUCKDB_TYPE = 11;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP: DUCKDB_TYPE = 12;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_DATE: DUCKDB_TYPE = 13;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIME: DUCKDB_TYPE = 14;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_INTERVAL: DUCKDB_TYPE = 15;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_HUGEINT: DUCKDB_TYPE = 16;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UHUGEINT: DUCKDB_TYPE = 32;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_VARCHAR: DUCKDB_TYPE = 17;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BLOB: DUCKDB_TYPE = 18;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_DECIMAL: DUCKDB_TYPE = 19;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP_S: DUCKDB_TYPE = 20;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP_MS: DUCKDB_TYPE = 21;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP_NS: DUCKDB_TYPE = 22;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_ENUM: DUCKDB_TYPE = 23;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_LIST: DUCKDB_TYPE = 24;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_STRUCT: DUCKDB_TYPE = 25;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_MAP: DUCKDB_TYPE = 26;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_ARRAY: DUCKDB_TYPE = 33;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UUID: DUCKDB_TYPE = 27;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_UNION: DUCKDB_TYPE = 28;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BIT: DUCKDB_TYPE = 29;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIME_TZ: DUCKDB_TYPE = 30;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIMESTAMP_TZ: DUCKDB_TYPE = 31;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_ANY: DUCKDB_TYPE = 34;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_BIGNUM: DUCKDB_TYPE = 35;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_SQLNULL: DUCKDB_TYPE = 36;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_STRING_LITERAL: DUCKDB_TYPE = 37;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_INTEGER_LITERAL: DUCKDB_TYPE = 38;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_TIME_NS: DUCKDB_TYPE = 39;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_GEOMETRY: DUCKDB_TYPE = 40;
+pub const DUCKDB_TYPE_DUCKDB_TYPE_VARIANT: DUCKDB_TYPE = 41;
+#[doc = "! An enum over DuckDB's internal types."]
+pub type DUCKDB_TYPE = ::std::os::raw::c_uint;
+#[doc = "! An enum over DuckDB's internal types."]
+pub use self::DUCKDB_TYPE as duckdb_type;
+pub const duckdb_state_DuckDBSuccess: duckdb_state = 0;
+pub const duckdb_state_DuckDBError: duckdb_state = 1;
+#[doc = "! An enum over the returned state of different functions."]
+pub type duckdb_state = ::std::os::raw::c_uint;
+pub const duckdb_pending_state_DUCKDB_PENDING_RESULT_READY: duckdb_pending_state = 0;
+pub const duckdb_pending_state_DUCKDB_PENDING_RESULT_NOT_READY: duckdb_pending_state = 1;
+pub const duckdb_pending_state_DUCKDB_PENDING_ERROR: duckdb_pending_state = 2;
+pub const duckdb_pending_state_DUCKDB_PENDING_NO_TASKS_AVAILABLE: duckdb_pending_state = 3;
+#[doc = "! An enum over the pending state of a pending query result."]
+pub type duckdb_pending_state = ::std::os::raw::c_uint;
+pub const duckdb_result_type_DUCKDB_RESULT_TYPE_INVALID: duckdb_result_type = 0;
+pub const duckdb_result_type_DUCKDB_RESULT_TYPE_CHANGED_ROWS: duckdb_result_type = 1;
+pub const duckdb_result_type_DUCKDB_RESULT_TYPE_NOTHING: duckdb_result_type = 2;
+pub const duckdb_result_type_DUCKDB_RESULT_TYPE_QUERY_RESULT: duckdb_result_type = 3;
+#[doc = "! An enum over DuckDB's different result types."]
+pub type duckdb_result_type = ::std::os::raw::c_uint;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_INVALID: duckdb_statement_type = 0;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_SELECT: duckdb_statement_type = 1;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_INSERT: duckdb_statement_type = 2;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_UPDATE: duckdb_statement_type = 3;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_EXPLAIN: duckdb_statement_type = 4;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_DELETE: duckdb_statement_type = 5;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_PREPARE: duckdb_statement_type = 6;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_CREATE: duckdb_statement_type = 7;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_EXECUTE: duckdb_statement_type = 8;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_ALTER: duckdb_statement_type = 9;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_TRANSACTION: duckdb_statement_type = 10;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_COPY: duckdb_statement_type = 11;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_ANALYZE: duckdb_statement_type = 12;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_VARIABLE_SET: duckdb_statement_type = 13;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_CREATE_FUNC: duckdb_statement_type = 14;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_DROP: duckdb_statement_type = 15;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_EXPORT: duckdb_statement_type = 16;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_PRAGMA: duckdb_statement_type = 17;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_VACUUM: duckdb_statement_type = 18;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_CALL: duckdb_statement_type = 19;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_SET: duckdb_statement_type = 20;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_LOAD: duckdb_statement_type = 21;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_RELATION: duckdb_statement_type = 22;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_EXTENSION: duckdb_statement_type = 23;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_LOGICAL_PLAN: duckdb_statement_type = 24;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_ATTACH: duckdb_statement_type = 25;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_DETACH: duckdb_statement_type = 26;
+pub const duckdb_statement_type_DUCKDB_STATEMENT_TYPE_MULTI: duckdb_statement_type = 27;
+#[doc = "! An enum over DuckDB's different statement types."]
+pub type duckdb_statement_type = ::std::os::raw::c_uint;
+pub const duckdb_error_type_DUCKDB_ERROR_INVALID: duckdb_error_type = 0;
+pub const duckdb_error_type_DUCKDB_ERROR_OUT_OF_RANGE: duckdb_error_type = 1;
+pub const duckdb_error_type_DUCKDB_ERROR_CONVERSION: duckdb_error_type = 2;
+pub const duckdb_error_type_DUCKDB_ERROR_UNKNOWN_TYPE: duckdb_error_type = 3;
+pub const duckdb_error_type_DUCKDB_ERROR_DECIMAL: duckdb_error_type = 4;
+pub const duckdb_error_type_DUCKDB_ERROR_MISMATCH_TYPE: duckdb_error_type = 5;
+pub const duckdb_error_type_DUCKDB_ERROR_DIVIDE_BY_ZERO: duckdb_error_type = 6;
+pub const duckdb_error_type_DUCKDB_ERROR_OBJECT_SIZE: duckdb_error_type = 7;
+pub const duckdb_error_type_DUCKDB_ERROR_INVALID_TYPE: duckdb_error_type = 8;
+pub const duckdb_error_type_DUCKDB_ERROR_SERIALIZATION: duckdb_error_type = 9;
+pub const duckdb_error_type_DUCKDB_ERROR_TRANSACTION: duckdb_error_type = 10;
+pub const duckdb_error_type_DUCKDB_ERROR_NOT_IMPLEMENTED: duckdb_error_type = 11;
+pub const duckdb_error_type_DUCKDB_ERROR_EXPRESSION: duckdb_error_type = 12;
+pub const duckdb_error_type_DUCKDB_ERROR_CATALOG: duckdb_error_type = 13;
+pub const duckdb_error_type_DUCKDB_ERROR_PARSER: duckdb_error_type = 14;
+pub const duckdb_error_type_DUCKDB_ERROR_PLANNER: duckdb_error_type = 15;
+pub const duckdb_error_type_DUCKDB_ERROR_SCHEDULER: duckdb_error_type = 16;
+pub const duckdb_error_type_DUCKDB_ERROR_EXECUTOR: duckdb_error_type = 17;
+pub const duckdb_error_type_DUCKDB_ERROR_CONSTRAINT: duckdb_error_type = 18;
+pub const duckdb_error_type_DUCKDB_ERROR_INDEX: duckdb_error_type = 19;
+pub const duckdb_error_type_DUCKDB_ERROR_STAT: duckdb_error_type = 20;
+pub const duckdb_error_type_DUCKDB_ERROR_CONNECTION: duckdb_error_type = 21;
+pub const duckdb_error_type_DUCKDB_ERROR_SYNTAX: duckdb_error_type = 22;
+pub const duckdb_error_type_DUCKDB_ERROR_SETTINGS: duckdb_error_type = 23;
+pub const duckdb_error_type_DUCKDB_ERROR_BINDER: duckdb_error_type = 24;
+pub const duckdb_error_type_DUCKDB_ERROR_NETWORK: duckdb_error_type = 25;
+pub const duckdb_error_type_DUCKDB_ERROR_OPTIMIZER: duckdb_error_type = 26;
+pub const duckdb_error_type_DUCKDB_ERROR_NULL_POINTER: duckdb_error_type = 27;
+pub const duckdb_error_type_DUCKDB_ERROR_IO: duckdb_error_type = 28;
+pub const duckdb_error_type_DUCKDB_ERROR_INTERRUPT: duckdb_error_type = 29;
+pub const duckdb_error_type_DUCKDB_ERROR_FATAL: duckdb_error_type = 30;
+pub const duckdb_error_type_DUCKDB_ERROR_INTERNAL: duckdb_error_type = 31;
+pub const duckdb_error_type_DUCKDB_ERROR_INVALID_INPUT: duckdb_error_type = 32;
+pub const duckdb_error_type_DUCKDB_ERROR_OUT_OF_MEMORY: duckdb_error_type = 33;
+pub const duckdb_error_type_DUCKDB_ERROR_PERMISSION: duckdb_error_type = 34;
+pub const duckdb_error_type_DUCKDB_ERROR_PARAMETER_NOT_RESOLVED: duckdb_error_type = 35;
+pub const duckdb_error_type_DUCKDB_ERROR_PARAMETER_NOT_ALLOWED: duckdb_error_type = 36;
+pub const duckdb_error_type_DUCKDB_ERROR_DEPENDENCY: duckdb_error_type = 37;
+pub const duckdb_error_type_DUCKDB_ERROR_HTTP: duckdb_error_type = 38;
+pub const duckdb_error_type_DUCKDB_ERROR_MISSING_EXTENSION: duckdb_error_type = 39;
+pub const duckdb_error_type_DUCKDB_ERROR_AUTOLOAD: duckdb_error_type = 40;
+pub const duckdb_error_type_DUCKDB_ERROR_SEQUENCE: duckdb_error_type = 41;
+pub const duckdb_error_type_DUCKDB_INVALID_CONFIGURATION: duckdb_error_type = 42;
+#[doc = "! An enum over DuckDB's different error types."]
+pub type duckdb_error_type = ::std::os::raw::c_uint;
+pub const duckdb_cast_mode_DUCKDB_CAST_NORMAL: duckdb_cast_mode = 0;
+pub const duckdb_cast_mode_DUCKDB_CAST_TRY: duckdb_cast_mode = 1;
+#[doc = "! An enum over DuckDB's different cast modes."]
+pub type duckdb_cast_mode = ::std::os::raw::c_uint;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_INVALID: duckdb_file_flag = 0;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_READ: duckdb_file_flag = 1;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_WRITE: duckdb_file_flag = 2;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_CREATE: duckdb_file_flag = 3;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_CREATE_NEW: duckdb_file_flag = 4;
+pub const duckdb_file_flag_DUCKDB_FILE_FLAG_APPEND: duckdb_file_flag = 5;
+pub type duckdb_file_flag = ::std::os::raw::c_uint;
+pub const duckdb_config_option_scope_DUCKDB_CONFIG_OPTION_SCOPE_INVALID: duckdb_config_option_scope = 0;
+pub const duckdb_config_option_scope_DUCKDB_CONFIG_OPTION_SCOPE_LOCAL: duckdb_config_option_scope = 1;
+pub const duckdb_config_option_scope_DUCKDB_CONFIG_OPTION_SCOPE_SESSION: duckdb_config_option_scope = 2;
+pub const duckdb_config_option_scope_DUCKDB_CONFIG_OPTION_SCOPE_GLOBAL: duckdb_config_option_scope = 3;
+#[doc = "! An enum over DuckDB's configuration option scopes.\n! This enum can be used to specify the default scope when creating a custom configuration option,\n! but it is also be used to determine the scope in which a configuration option is set when it is\n! changed or retrieved."]
+pub type duckdb_config_option_scope = ::std::os::raw::c_uint;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_INVALID: duckdb_catalog_entry_type = 0;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_TABLE: duckdb_catalog_entry_type = 1;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_SCHEMA: duckdb_catalog_entry_type = 2;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_VIEW: duckdb_catalog_entry_type = 3;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_INDEX: duckdb_catalog_entry_type = 4;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_PREPARED_STATEMENT: duckdb_catalog_entry_type = 5;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_SEQUENCE: duckdb_catalog_entry_type = 6;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_COLLATION: duckdb_catalog_entry_type = 7;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_TYPE: duckdb_catalog_entry_type = 8;
+pub const duckdb_catalog_entry_type_DUCKDB_CATALOG_ENTRY_TYPE_DATABASE: duckdb_catalog_entry_type = 9;
+#[doc = "! An enum over DuckDB's catalog entry types."]
+pub type duckdb_catalog_entry_type = ::std::os::raw::c_uint;
+#[doc = "! DuckDB's index type."]
+pub type idx_t = u64;
+#[doc = "! Type definition for the data pointers of selection vectors."]
+pub type sel_t = u32;
+#[doc = "! The callback to destroy data, e.g.,\n! bind data (if any), init data (if any), extra data for replacement scans (if any), etc."]
+pub type duckdb_delete_callback_t = ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>;
+#[doc = "! The callback to copy data, e.g., bind data (if any)."]
+pub type duckdb_copy_callback_t =
+    ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void>;
+#[doc = "! Used for threading, contains a task state.\n! Must be destroyed with `duckdb_destroy_task_state`."]
+pub type duckdb_task_state = *mut ::std::os::raw::c_void;
+#[doc = "! DATE is stored as days since 1970-01-01.\n! Use the `duckdb_from_date` and `duckdb_to_date` functions to extract individual information."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_date {
+    pub days: i32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_date_struct {
+    pub year: i32,
+    pub month: i8,
+    pub day: i8,
+}
+#[doc = "! TIME is stored as microseconds since 00:00:00.\n! Use the `duckdb_from_time` and `duckdb_to_time` functions to extract individual information."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time {
+    pub micros: i64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time_struct {
+    pub hour: i8,
+    pub min: i8,
+    pub sec: i8,
+    pub micros: i32,
+}
+#[doc = "! TIME_NS is stored as nanoseconds since 00:00:00."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time_ns {
+    pub nanos: i64,
+}
+#[doc = "! TIME_TZ is stored as 40 bits for the int64_t microseconds, and 24 bits for the int32_t offset.\n! Use the `duckdb_from_time_tz` function to extract individual information."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time_tz {
+    pub bits: u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_time_tz_struct {
+    pub time: duckdb_time_struct,
+    pub offset: i32,
+}
+#[doc = "! TIMESTAMP is stored as microseconds since 1970-01-01.\n! Use the `duckdb_from_timestamp` and `duckdb_to_timestamp` functions to extract individual information."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp {
+    pub micros: i64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp_struct {
+    pub date: duckdb_date_struct,
+    pub time: duckdb_time_struct,
+}
+#[doc = "! TIMESTAMP_S is stored as seconds since 1970-01-01."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp_s {
+    pub seconds: i64,
+}
+#[doc = "! TIMESTAMP_MS is stored as milliseconds since 1970-01-01."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp_ms {
+    pub millis: i64,
+}
+#[doc = "! TIMESTAMP_NS is stored as nanoseconds since 1970-01-01."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_timestamp_ns {
+    pub nanos: i64,
+}
+#[doc = "! INTERVAL is stored in months, days, and micros."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_interval {
+    pub months: i32,
+    pub days: i32,
+    pub micros: i64,
+}
+#[doc = "! HUGEINT is composed of a lower and upper component.\n! Its value is upper * 2^64 + lower.\n! For simplified usage, use `duckdb_hugeint_to_double` and `duckdb_double_to_hugeint`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_hugeint {
+    pub lower: u64,
+    pub upper: i64,
+}
+#[doc = "! UHUGEINT is composed of a lower and upper component.\n! Its value is upper * 2^64 + lower.\n! For simplified usage, use `duckdb_uhugeint_to_double` and `duckdb_double_to_uhugeint`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_uhugeint {
+    pub lower: u64,
+    pub upper: u64,
+}
+#[doc = "! DECIMAL is composed of a width and a scale.\n! Their value is stored in a HUGEINT."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_decimal {
+    pub width: u8,
+    pub scale: u8,
+    pub value: duckdb_hugeint,
+}
+#[doc = "! A type holding information about the query execution progress."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_query_progress_type {
+    pub percentage: f64,
+    pub rows_processed: u64,
+    pub total_rows_to_process: u64,
+}
+#[doc = "! The internal representation of a VARCHAR (string_t). If the VARCHAR does not\n! exceed 12 characters, then we inline it. Otherwise, we inline a four-byte prefix for faster\n! string comparisons and store a pointer to the remaining characters. This is a non-\n! owning structure, i.e., it does not have to be freed."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct duckdb_string_t {
+    pub value: duckdb_string_t__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union duckdb_string_t__bindgen_ty_1 {
+    pub pointer: duckdb_string_t__bindgen_ty_1__bindgen_ty_1,
+    pub inlined: duckdb_string_t__bindgen_ty_1__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_string_t__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_string_t__bindgen_ty_1__bindgen_ty_2 {
+    pub length: u32,
+    pub inlined: [::std::os::raw::c_char; 12usize],
+}
+#[doc = "! DuckDB's LISTs are composed of a 'parent' vector holding metadata of each list,\n! and a child vector holding the entries of the lists.\n! The `duckdb_list_entry` struct contains the internal representation of a LIST metadata entry.\n! A metadata entry contains the length of the list, and its offset in the child vector."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_list_entry {
+    pub offset: u64,
+    pub length: u64,
+}
+#[doc = "! A column consists of a pointer to its internal data. Don't operate on this type directly.\n! Instead, use functions such as `duckdb_column_data`, `duckdb_nullmask_data`,\n! `duckdb_column_type`, and `duckdb_column_name`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_column {
+    pub deprecated_data: *mut ::std::os::raw::c_void,
+    pub deprecated_nullmask: *mut bool,
+    pub deprecated_type: duckdb_type,
+    pub deprecated_name: *mut ::std::os::raw::c_char,
+    pub internal_data: *mut ::std::os::raw::c_void,
+}
+#[doc = "! 1. A standalone vector that must be destroyed, or\n! 2. A vector to a column in a data chunk that lives as long as the data chunk lives."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_vector {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! 1. A standalone vector that must be destroyed, or\n! 2. A vector to a column in a data chunk that lives as long as the data chunk lives."]
+pub type duckdb_vector = *mut _duckdb_vector;
+#[doc = "! A selection vector is a vector of indices, which usually refer to values in a vector.\n! Can be used to slice vectors, changing their length and the order of their entries.\n! Standalone selection vectors must be destroyed."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_selection_vector {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A selection vector is a vector of indices, which usually refer to values in a vector.\n! Can be used to slice vectors, changing their length and the order of their entries.\n! Standalone selection vectors must be destroyed."]
+pub type duckdb_selection_vector = *mut _duckdb_selection_vector;
+#[doc = "! Strings are composed of a `char` pointer and a size.\n! You must free `string.data` with `duckdb_free`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_string {
+    pub data: *mut ::std::os::raw::c_char,
+    pub size: idx_t,
+}
+#[doc = "! BLOBs are composed of a byte pointer and a size.\n! You must free `blob.data` with `duckdb_free`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_blob {
+    pub data: *mut ::std::os::raw::c_void,
+    pub size: idx_t,
+}
+#[doc = "! BITs are composed of a byte pointer and a size.\n! BIT byte data has 0 to 7 bits of padding.\n! The first byte contains the number of padding bits.\n! The padding bits of the second byte are set to 1, starting from the MSB.\n! You must free `data` with `duckdb_free`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_bit {
+    pub data: *mut u8,
+    pub size: idx_t,
+}
+#[doc = "! BIGNUMs are composed of a byte pointer, a size, and an `is_negative` bool.\n! The absolute value of the number is stored in `data` in big endian format.\n! You must free `data` with `duckdb_free`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_bignum {
+    pub data: *mut u8,
+    pub size: idx_t,
+    pub is_negative: bool,
+}
+#[doc = "! A query result consists of a pointer to its internal data.\n! Must be freed with 'duckdb_destroy_result'."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_result {
+    pub deprecated_column_count: idx_t,
+    pub deprecated_row_count: idx_t,
+    pub deprecated_rows_changed: idx_t,
+    pub deprecated_columns: *mut duckdb_column,
+    pub deprecated_error_message: *mut ::std::os::raw::c_char,
+    pub internal_data: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A database instance cache object. Must be destroyed with `duckdb_destroy_instance_cache`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_instance_cache {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A database instance cache object. Must be destroyed with `duckdb_destroy_instance_cache`."]
+pub type duckdb_instance_cache = *mut _duckdb_instance_cache;
+#[doc = "! A database object. Must be closed with `duckdb_close`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_database {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A database object. Must be closed with `duckdb_close`."]
+pub type duckdb_database = *mut _duckdb_database;
+#[doc = "! A connection to a duckdb database. Must be closed with `duckdb_disconnect`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_connection {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A connection to a duckdb database. Must be closed with `duckdb_disconnect`."]
+pub type duckdb_connection = *mut _duckdb_connection;
+#[doc = "! A client context of a duckdb connection. Must be destroyed with `duckdb_destroy_context`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_client_context {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A client context of a duckdb connection. Must be destroyed with `duckdb_destroy_context`."]
+pub type duckdb_client_context = *mut _duckdb_client_context;
+#[doc = "! A prepared statement is a parameterized query that allows you to bind parameters to it.\n! Must be destroyed with `duckdb_destroy_prepare`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_prepared_statement {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A prepared statement is a parameterized query that allows you to bind parameters to it.\n! Must be destroyed with `duckdb_destroy_prepare`."]
+pub type duckdb_prepared_statement = *mut _duckdb_prepared_statement;
+#[doc = "! Extracted statements. Must be destroyed with `duckdb_destroy_extracted`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_extracted_statements {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Extracted statements. Must be destroyed with `duckdb_destroy_extracted`."]
+pub type duckdb_extracted_statements = *mut _duckdb_extracted_statements;
+#[doc = "! The pending result represents an intermediate structure for a query that is not yet fully executed.\n! Must be destroyed with `duckdb_destroy_pending`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_pending_result {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The pending result represents an intermediate structure for a query that is not yet fully executed.\n! Must be destroyed with `duckdb_destroy_pending`."]
+pub type duckdb_pending_result = *mut _duckdb_pending_result;
+#[doc = "! The appender enables fast data loading into DuckDB.\n! Must be destroyed with `duckdb_appender_destroy`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_appender {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The appender enables fast data loading into DuckDB.\n! Must be destroyed with `duckdb_appender_destroy`."]
+pub type duckdb_appender = *mut _duckdb_appender;
+#[doc = "! The table description allows querying information about the table.\n! Must be destroyed with `duckdb_table_description_destroy`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_table_description {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The table description allows querying information about the table.\n! Must be destroyed with `duckdb_table_description_destroy`."]
+pub type duckdb_table_description = *mut _duckdb_table_description;
+#[doc = "! The configuration can be used to provide start-up options for a database.\n! Must be destroyed with `duckdb_destroy_config`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_config {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The configuration can be used to provide start-up options for a database.\n! Must be destroyed with `duckdb_destroy_config`."]
+pub type duckdb_config = *mut _duckdb_config;
+#[doc = "! A custom configuration option instance. Used to register custom options that can be set on a duckdb_config.\n! or by the user in SQL using `SET <option_name> = <value>`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_config_option {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A custom configuration option instance. Used to register custom options that can be set on a duckdb_config.\n! or by the user in SQL using `SET <option_name> = <value>`."]
+pub type duckdb_config_option = *mut _duckdb_config_option;
+#[doc = "! A logical type.\n! Must be destroyed with `duckdb_destroy_logical_type`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_logical_type {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A logical type.\n! Must be destroyed with `duckdb_destroy_logical_type`."]
+pub type duckdb_logical_type = *mut _duckdb_logical_type;
+#[doc = "! Holds extra information to register a custom logical type.\n! Reserved for future use."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_create_type_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds extra information to register a custom logical type.\n! Reserved for future use."]
+pub type duckdb_create_type_info = *mut _duckdb_create_type_info;
+#[doc = "! Contains a data chunk of a duckdb_result.\n! Must be destroyed with `duckdb_destroy_data_chunk`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_data_chunk {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Contains a data chunk of a duckdb_result.\n! Must be destroyed with `duckdb_destroy_data_chunk`."]
+pub type duckdb_data_chunk = *mut _duckdb_data_chunk;
+#[doc = "! A value of a logical type.\n! Must be destroyed with `duckdb_destroy_value`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_value {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A value of a logical type.\n! Must be destroyed with `duckdb_destroy_value`."]
+pub type duckdb_value = *mut _duckdb_value;
+#[doc = "! Holds a recursive tree containing profiling metrics.\n! The tree matches the query plan, and has a top-level node."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_profiling_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds a recursive tree containing profiling metrics.\n! The tree matches the query plan, and has a top-level node."]
+pub type duckdb_profiling_info = *mut _duckdb_profiling_info;
+#[doc = "! Holds error data.\n! Must be destroyed with `duckdb_destroy_error_data`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_error_data {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds error data.\n! Must be destroyed with `duckdb_destroy_error_data`."]
+pub type duckdb_error_data = *mut _duckdb_error_data;
+#[doc = "! Holds a bound expression.\n! Must be destroyed with `duckdb_destroy_expression`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_expression {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds a bound expression.\n! Must be destroyed with `duckdb_destroy_expression`."]
+pub type duckdb_expression = *mut _duckdb_expression;
+#[doc = "! Holds the state of the C API extension initialization process."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_extension_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds the state of the C API extension initialization process."]
+pub type duckdb_extension_info = *mut _duckdb_extension_info;
+#[doc = "! Additional function info.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_function_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Additional function info.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+pub type duckdb_function_info = *mut _duckdb_function_info;
+#[doc = "! The bind info of a function.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_bind_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The bind info of a function.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+pub type duckdb_bind_info = *mut _duckdb_bind_info;
+#[doc = "! Additional function initialization info.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_init_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Additional function initialization info.\n! When setting this info, it is necessary to pass a destroy-callback function."]
+pub type duckdb_init_info = *mut _duckdb_init_info;
+#[doc = "! A scalar function. Must be destroyed with `duckdb_destroy_scalar_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_scalar_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A scalar function. Must be destroyed with `duckdb_destroy_scalar_function`."]
+pub type duckdb_scalar_function = *mut _duckdb_scalar_function;
+#[doc = "! A scalar function set. Must be destroyed with `duckdb_destroy_scalar_function_set`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_scalar_function_set {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A scalar function set. Must be destroyed with `duckdb_destroy_scalar_function_set`."]
+pub type duckdb_scalar_function_set = *mut _duckdb_scalar_function_set;
+#[doc = "! The bind function callback of the scalar function."]
+pub type duckdb_scalar_function_bind_t = ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info)>;
+#[doc = "! The thread-local initialization function of the scalar function."]
+pub type duckdb_scalar_function_init_t = ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info)>;
+#[doc = "! The function to execute the scalar function on an input chunk."]
+pub type duckdb_scalar_function_t = ::std::option::Option<
+    unsafe extern "C" fn(info: duckdb_function_info, input: duckdb_data_chunk, output: duckdb_vector),
+>;
+#[doc = "! An aggregate function. Must be destroyed with `duckdb_destroy_aggregate_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_aggregate_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! An aggregate function. Must be destroyed with `duckdb_destroy_aggregate_function`."]
+pub type duckdb_aggregate_function = *mut _duckdb_aggregate_function;
+#[doc = "! A aggregate function set. Must be destroyed with `duckdb_destroy_aggregate_function_set`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_aggregate_function_set {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A aggregate function set. Must be destroyed with `duckdb_destroy_aggregate_function_set`."]
+pub type duckdb_aggregate_function_set = *mut _duckdb_aggregate_function_set;
+#[doc = "! The state of an aggregate function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_aggregate_state {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The state of an aggregate function."]
+pub type duckdb_aggregate_state = *mut _duckdb_aggregate_state;
+#[doc = "! A function to return the aggregate state's size."]
+pub type duckdb_aggregate_state_size = ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> idx_t>;
+#[doc = "! A function to initialize an aggregate state."]
+pub type duckdb_aggregate_init_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info, state: duckdb_aggregate_state)>;
+#[doc = "! An optional function to destroy an aggregate state."]
+pub type duckdb_aggregate_destroy_t =
+    ::std::option::Option<unsafe extern "C" fn(states: *mut duckdb_aggregate_state, count: idx_t)>;
+#[doc = "! A function to update a set of aggregate states with new values."]
+pub type duckdb_aggregate_update_t = ::std::option::Option<
+    unsafe extern "C" fn(info: duckdb_function_info, input: duckdb_data_chunk, states: *mut duckdb_aggregate_state),
+>;
+#[doc = "! A function to combine aggregate states."]
+pub type duckdb_aggregate_combine_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        info: duckdb_function_info,
+        source: *mut duckdb_aggregate_state,
+        target: *mut duckdb_aggregate_state,
+        count: idx_t,
+    ),
+>;
+#[doc = "! A function to finalize aggregate states into a result vector."]
+pub type duckdb_aggregate_finalize_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        info: duckdb_function_info,
+        source: *mut duckdb_aggregate_state,
+        result: duckdb_vector,
+        count: idx_t,
+        offset: idx_t,
+    ),
+>;
+#[doc = "! A table function. Must be destroyed with `duckdb_destroy_table_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_table_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A table function. Must be destroyed with `duckdb_destroy_table_function`."]
+pub type duckdb_table_function = *mut _duckdb_table_function;
+#[doc = "! The bind function of the table function."]
+pub type duckdb_table_function_bind_t = ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info)>;
+#[doc = "! The possibly thread-local initialization function of the table function."]
+pub type duckdb_table_function_init_t = ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info)>;
+#[doc = "! The function to generate an output chunk during table function execution."]
+pub type duckdb_table_function_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info, output: duckdb_data_chunk)>;
+#[doc = "! A COPY function. Must be destroyed with `duckdb_destroy_copy_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A COPY function. Must be destroyed with `duckdb_destroy_copy_function`."]
+pub type duckdb_copy_function = *mut _duckdb_copy_function;
+#[doc = "! Info for the bind function of a COPY function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function_bind_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Info for the bind function of a COPY function."]
+pub type duckdb_copy_function_bind_info = *mut _duckdb_copy_function_bind_info;
+#[doc = "! Info for the global initialization function of a COPY function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function_global_init_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Info for the global initialization function of a COPY function."]
+pub type duckdb_copy_function_global_init_info = *mut _duckdb_copy_function_global_init_info;
+#[doc = "! Info for the sink function of a COPY function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function_sink_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Info for the sink function of a COPY function."]
+pub type duckdb_copy_function_sink_info = *mut _duckdb_copy_function_sink_info;
+#[doc = "! Info for the finalize function of a COPY function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_copy_function_finalize_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Info for the finalize function of a COPY function."]
+pub type duckdb_copy_function_finalize_info = *mut _duckdb_copy_function_finalize_info;
+#[doc = "! The bind function to use when binding a COPY ... TO function."]
+pub type duckdb_copy_function_bind_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_bind_info)>;
+#[doc = "! The initialization function to use when initializing a COPY ... TO function."]
+pub type duckdb_copy_function_global_init_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_global_init_info)>;
+#[doc = "! The function to sink an input chunk into during execution of a COPY ... TO function."]
+pub type duckdb_copy_function_sink_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_sink_info, input: duckdb_data_chunk)>;
+#[doc = "! The function to finalize the COPY ... TO function execution."]
+pub type duckdb_copy_function_finalize_t =
+    ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_finalize_info)>;
+#[doc = "! A cast function. Must be destroyed with `duckdb_destroy_cast_function`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_cast_function {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A cast function. Must be destroyed with `duckdb_destroy_cast_function`."]
+pub type duckdb_cast_function = *mut _duckdb_cast_function;
+#[doc = "! The function to cast from an input vector to an output vector."]
+pub type duckdb_cast_function_t = ::std::option::Option<
+    unsafe extern "C" fn(info: duckdb_function_info, count: idx_t, input: duckdb_vector, output: duckdb_vector) -> bool,
+>;
+#[doc = "! Additional replacement scan info. When setting this info, it is necessary to pass a destroy-callback function."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_replacement_scan_info {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Additional replacement scan info. When setting this info, it is necessary to pass a destroy-callback function."]
+pub type duckdb_replacement_scan_info = *mut _duckdb_replacement_scan_info;
+#[doc = "! A replacement scan function."]
+pub type duckdb_replacement_callback_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        info: duckdb_replacement_scan_info,
+        table_name: *const ::std::os::raw::c_char,
+        data: *mut ::std::os::raw::c_void,
+    ),
+>;
+#[doc = "! Holds an arrow query result. Must be destroyed with `duckdb_destroy_arrow`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow query result. Must be destroyed with `duckdb_destroy_arrow`."]
+pub type duckdb_arrow = *mut _duckdb_arrow;
+#[doc = "! Holds an arrow array stream. Must be destroyed with `duckdb_destroy_arrow_stream`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_stream {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow array stream. Must be destroyed with `duckdb_destroy_arrow_stream`."]
+pub type duckdb_arrow_stream = *mut _duckdb_arrow_stream;
+#[doc = "! Holds an arrow schema. Remember to release the respective ArrowSchema object."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_schema {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow schema. Remember to release the respective ArrowSchema object."]
+pub type duckdb_arrow_schema = *mut _duckdb_arrow_schema;
+#[doc = "! Holds an arrow converted schema (i.e., duckdb::ArrowTableSchema).\n! In practice, this object holds the information necessary to do proper conversion between Arrow Types and DuckDB\n! Types. Check duckdb/function/table/arrow/arrow_duck_schema.hpp for more details! Must be destroyed with\n! `duckdb_destroy_arrow_converted_schema`"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_converted_schema {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow converted schema (i.e., duckdb::ArrowTableSchema).\n! In practice, this object holds the information necessary to do proper conversion between Arrow Types and DuckDB\n! Types. Check duckdb/function/table/arrow/arrow_duck_schema.hpp for more details! Must be destroyed with\n! `duckdb_destroy_arrow_converted_schema`"]
+pub type duckdb_arrow_converted_schema = *mut _duckdb_arrow_converted_schema;
+#[doc = "! Holds an arrow array. Remember to release the respective ArrowSchema object."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_array {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds an arrow array. Remember to release the respective ArrowSchema object."]
+pub type duckdb_arrow_array = *mut _duckdb_arrow_array;
+#[doc = "! The arrow options used when transforming the DuckDB schema and datachunks into Arrow schema and arrays.\n! Used in `duckdb_to_arrow_schema` and `duckdb_data_chunk_to_arrow`"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_arrow_options {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! The arrow options used when transforming the DuckDB schema and datachunks into Arrow schema and arrays.\n! Used in `duckdb_to_arrow_schema` and `duckdb_data_chunk_to_arrow`"]
+pub type duckdb_arrow_options = *mut _duckdb_arrow_options;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_file_open_options {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+pub type duckdb_file_open_options = *mut _duckdb_file_open_options;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_file_system {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+pub type duckdb_file_system = *mut _duckdb_file_system;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_file_handle {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+pub type duckdb_file_handle = *mut _duckdb_file_handle;
+#[doc = "! A handle to a database catalog.\n! Must be destroyed with `duckdb_destroy_catalog`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_catalog {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A handle to a database catalog.\n! Must be destroyed with `duckdb_destroy_catalog`."]
+pub type duckdb_catalog = *mut _duckdb_catalog;
+#[doc = "! A handle to a catalog entry (e.g., table, view, index, etc.).\n! Must be destroyed with `duckdb_destroy_catalog_entry`."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_catalog_entry {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! A handle to a catalog entry (e.g., table, view, index, etc.).\n! Must be destroyed with `duckdb_destroy_catalog_entry`."]
+pub type duckdb_catalog_entry = *mut _duckdb_catalog_entry;
+#[doc = "! Holds a log storage object."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _duckdb_log_storage {
+    pub internal_ptr: *mut ::std::os::raw::c_void,
+}
+#[doc = "! Holds a log storage object."]
+pub type duckdb_log_storage = *mut _duckdb_log_storage;
+#[doc = "! This function is missing the logging context, which will be added later."]
+pub type duckdb_logger_write_log_entry_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        extra_data: *mut ::std::os::raw::c_void,
+        timestamp: *mut duckdb_timestamp,
+        level: *const ::std::os::raw::c_char,
+        log_type: *const ::std::os::raw::c_char,
+        log_message: *const ::std::os::raw::c_char,
+    ),
+>;
+#[doc = "! Passed to C API extension as a parameter to the entrypoint."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_extension_access {
+    #[doc = "! Indicate that an error has occurred."]
+    pub set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_extension_info, error: *const ::std::os::raw::c_char)>,
+    #[doc = "! Fetch the database on which to register the extension."]
+    pub get_database: ::std::option::Option<unsafe extern "C" fn(info: duckdb_extension_info) -> *mut duckdb_database>,
+    #[doc = "! Fetch the API struct pointer."]
+    pub get_api: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_extension_info,
+            version: *const ::std::os::raw::c_char,
+        ) -> *const ::std::os::raw::c_void,
+    >,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct duckdb_ext_api_v1 {
+    pub duckdb_open: ::std::option::Option<
+        unsafe extern "C" fn(path: *const ::std::os::raw::c_char, out_database: *mut duckdb_database) -> duckdb_state,
+    >,
+    pub duckdb_open_ext: ::std::option::Option<
+        unsafe extern "C" fn(
+            path: *const ::std::os::raw::c_char,
+            out_database: *mut duckdb_database,
+            config: duckdb_config,
+            out_error: *mut *mut ::std::os::raw::c_char,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_close: ::std::option::Option<unsafe extern "C" fn(database: *mut duckdb_database)>,
+    pub duckdb_connect: ::std::option::Option<
+        unsafe extern "C" fn(database: duckdb_database, out_connection: *mut duckdb_connection) -> duckdb_state,
+    >,
+    pub duckdb_interrupt: ::std::option::Option<unsafe extern "C" fn(connection: duckdb_connection)>,
+    pub duckdb_query_progress:
+        ::std::option::Option<unsafe extern "C" fn(connection: duckdb_connection) -> duckdb_query_progress_type>,
+    pub duckdb_disconnect: ::std::option::Option<unsafe extern "C" fn(connection: *mut duckdb_connection)>,
+    pub duckdb_library_version: ::std::option::Option<unsafe extern "C" fn() -> *const ::std::os::raw::c_char>,
+    pub duckdb_create_config:
+        ::std::option::Option<unsafe extern "C" fn(out_config: *mut duckdb_config) -> duckdb_state>,
+    pub duckdb_config_count: ::std::option::Option<unsafe extern "C" fn() -> usize>,
+    pub duckdb_get_config_flag: ::std::option::Option<
+        unsafe extern "C" fn(
+            index: usize,
+            out_name: *mut *const ::std::os::raw::c_char,
+            out_description: *mut *const ::std::os::raw::c_char,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_set_config: ::std::option::Option<
+        unsafe extern "C" fn(
+            config: duckdb_config,
+            name: *const ::std::os::raw::c_char,
+            option: *const ::std::os::raw::c_char,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_destroy_config: ::std::option::Option<unsafe extern "C" fn(config: *mut duckdb_config)>,
+    pub duckdb_query: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            query: *const ::std::os::raw::c_char,
+            out_result: *mut duckdb_result,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_destroy_result: ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result)>,
+    pub duckdb_column_name: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_column_type:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t) -> duckdb_type>,
+    pub duckdb_result_statement_type:
+        ::std::option::Option<unsafe extern "C" fn(result: duckdb_result) -> duckdb_statement_type>,
+    pub duckdb_column_logical_type:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t) -> duckdb_logical_type>,
+    pub duckdb_column_count: ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result) -> idx_t>,
+    pub duckdb_rows_changed: ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result) -> idx_t>,
+    pub duckdb_result_error:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result) -> *const ::std::os::raw::c_char>,
+    pub duckdb_result_error_type:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result) -> duckdb_error_type>,
+    pub duckdb_result_return_type:
+        ::std::option::Option<unsafe extern "C" fn(result: duckdb_result) -> duckdb_result_type>,
+    pub duckdb_malloc: ::std::option::Option<unsafe extern "C" fn(size: usize) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_free: ::std::option::Option<unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void)>,
+    pub duckdb_vector_size: ::std::option::Option<unsafe extern "C" fn() -> idx_t>,
+    pub duckdb_string_is_inlined: ::std::option::Option<unsafe extern "C" fn(string: duckdb_string_t) -> bool>,
+    pub duckdb_string_t_length: ::std::option::Option<unsafe extern "C" fn(string: duckdb_string_t) -> u32>,
+    pub duckdb_string_t_data:
+        ::std::option::Option<unsafe extern "C" fn(string: *mut duckdb_string_t) -> *const ::std::os::raw::c_char>,
+    pub duckdb_from_date: ::std::option::Option<unsafe extern "C" fn(date: duckdb_date) -> duckdb_date_struct>,
+    pub duckdb_to_date: ::std::option::Option<unsafe extern "C" fn(date: duckdb_date_struct) -> duckdb_date>,
+    pub duckdb_is_finite_date: ::std::option::Option<unsafe extern "C" fn(date: duckdb_date) -> bool>,
+    pub duckdb_from_time: ::std::option::Option<unsafe extern "C" fn(time: duckdb_time) -> duckdb_time_struct>,
+    pub duckdb_create_time_tz: ::std::option::Option<unsafe extern "C" fn(micros: i64, offset: i32) -> duckdb_time_tz>,
+    pub duckdb_from_time_tz:
+        ::std::option::Option<unsafe extern "C" fn(micros: duckdb_time_tz) -> duckdb_time_tz_struct>,
+    pub duckdb_to_time: ::std::option::Option<unsafe extern "C" fn(time: duckdb_time_struct) -> duckdb_time>,
+    pub duckdb_from_timestamp:
+        ::std::option::Option<unsafe extern "C" fn(ts: duckdb_timestamp) -> duckdb_timestamp_struct>,
+    pub duckdb_to_timestamp:
+        ::std::option::Option<unsafe extern "C" fn(ts: duckdb_timestamp_struct) -> duckdb_timestamp>,
+    pub duckdb_is_finite_timestamp: ::std::option::Option<unsafe extern "C" fn(ts: duckdb_timestamp) -> bool>,
+    pub duckdb_hugeint_to_double: ::std::option::Option<unsafe extern "C" fn(val: duckdb_hugeint) -> f64>,
+    pub duckdb_double_to_hugeint: ::std::option::Option<unsafe extern "C" fn(val: f64) -> duckdb_hugeint>,
+    pub duckdb_uhugeint_to_double: ::std::option::Option<unsafe extern "C" fn(val: duckdb_uhugeint) -> f64>,
+    pub duckdb_double_to_uhugeint: ::std::option::Option<unsafe extern "C" fn(val: f64) -> duckdb_uhugeint>,
+    pub duckdb_double_to_decimal:
+        ::std::option::Option<unsafe extern "C" fn(val: f64, width: u8, scale: u8) -> duckdb_decimal>,
+    pub duckdb_decimal_to_double: ::std::option::Option<unsafe extern "C" fn(val: duckdb_decimal) -> f64>,
+    pub duckdb_prepare: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            query: *const ::std::os::raw::c_char,
+            out_prepared_statement: *mut duckdb_prepared_statement,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_destroy_prepare:
+        ::std::option::Option<unsafe extern "C" fn(prepared_statement: *mut duckdb_prepared_statement)>,
+    pub duckdb_prepare_error: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_nparams:
+        ::std::option::Option<unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement) -> idx_t>,
+    pub duckdb_parameter_name: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            index: idx_t,
+        ) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_param_type: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t) -> duckdb_type,
+    >,
+    pub duckdb_param_logical_type: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t) -> duckdb_logical_type,
+    >,
+    pub duckdb_clear_bindings:
+        ::std::option::Option<unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement) -> duckdb_state>,
+    pub duckdb_prepared_statement_type:
+        ::std::option::Option<unsafe extern "C" fn(statement: duckdb_prepared_statement) -> duckdb_statement_type>,
+    pub duckdb_bind_value: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_value,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_parameter_index: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx_out: *mut idx_t,
+            name: *const ::std::os::raw::c_char,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_boolean: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: bool,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_int8: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: i8) -> duckdb_state,
+    >,
+    pub duckdb_bind_int16: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: i16) -> duckdb_state,
+    >,
+    pub duckdb_bind_int32: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: i32) -> duckdb_state,
+    >,
+    pub duckdb_bind_int64: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: i64) -> duckdb_state,
+    >,
+    pub duckdb_bind_hugeint: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_hugeint,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_uhugeint: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_uhugeint,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_decimal: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_decimal,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_uint8: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: u8) -> duckdb_state,
+    >,
+    pub duckdb_bind_uint16: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: u16) -> duckdb_state,
+    >,
+    pub duckdb_bind_uint32: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: u32) -> duckdb_state,
+    >,
+    pub duckdb_bind_uint64: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: u64) -> duckdb_state,
+    >,
+    pub duckdb_bind_float: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: f32) -> duckdb_state,
+    >,
+    pub duckdb_bind_double: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t, val: f64) -> duckdb_state,
+    >,
+    pub duckdb_bind_date: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_date,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_time: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_time,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_timestamp: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_timestamp,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_timestamp_tz: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_timestamp,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_interval: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: duckdb_interval,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_varchar: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: *const ::std::os::raw::c_char,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_varchar_length: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            val: *const ::std::os::raw::c_char,
+            length: idx_t,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_blob: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            param_idx: idx_t,
+            data: *const ::std::os::raw::c_void,
+            length: idx_t,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_bind_null: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, param_idx: idx_t) -> duckdb_state,
+    >,
+    pub duckdb_execute_prepared: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            out_result: *mut duckdb_result,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_extract_statements: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            query: *const ::std::os::raw::c_char,
+            out_extracted_statements: *mut duckdb_extracted_statements,
+        ) -> idx_t,
+    >,
+    pub duckdb_prepare_extracted_statement: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            extracted_statements: duckdb_extracted_statements,
+            index: idx_t,
+            out_prepared_statement: *mut duckdb_prepared_statement,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_extract_statements_error: ::std::option::Option<
+        unsafe extern "C" fn(extracted_statements: duckdb_extracted_statements) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_destroy_extracted:
+        ::std::option::Option<unsafe extern "C" fn(extracted_statements: *mut duckdb_extracted_statements)>,
+    pub duckdb_pending_prepared: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            out_result: *mut duckdb_pending_result,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_destroy_pending: ::std::option::Option<unsafe extern "C" fn(pending_result: *mut duckdb_pending_result)>,
+    pub duckdb_pending_error: ::std::option::Option<
+        unsafe extern "C" fn(pending_result: duckdb_pending_result) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_pending_execute_task:
+        ::std::option::Option<unsafe extern "C" fn(pending_result: duckdb_pending_result) -> duckdb_pending_state>,
+    pub duckdb_pending_execute_check_state:
+        ::std::option::Option<unsafe extern "C" fn(pending_result: duckdb_pending_result) -> duckdb_pending_state>,
+    pub duckdb_execute_pending: ::std::option::Option<
+        unsafe extern "C" fn(pending_result: duckdb_pending_result, out_result: *mut duckdb_result) -> duckdb_state,
+    >,
+    pub duckdb_pending_execution_is_finished:
+        ::std::option::Option<unsafe extern "C" fn(pending_state: duckdb_pending_state) -> bool>,
+    pub duckdb_destroy_value: ::std::option::Option<unsafe extern "C" fn(value: *mut duckdb_value)>,
+    pub duckdb_create_varchar:
+        ::std::option::Option<unsafe extern "C" fn(text: *const ::std::os::raw::c_char) -> duckdb_value>,
+    pub duckdb_create_varchar_length:
+        ::std::option::Option<unsafe extern "C" fn(text: *const ::std::os::raw::c_char, length: idx_t) -> duckdb_value>,
+    pub duckdb_create_bool: ::std::option::Option<unsafe extern "C" fn(input: bool) -> duckdb_value>,
+    pub duckdb_create_int8: ::std::option::Option<unsafe extern "C" fn(input: i8) -> duckdb_value>,
+    pub duckdb_create_uint8: ::std::option::Option<unsafe extern "C" fn(input: u8) -> duckdb_value>,
+    pub duckdb_create_int16: ::std::option::Option<unsafe extern "C" fn(input: i16) -> duckdb_value>,
+    pub duckdb_create_uint16: ::std::option::Option<unsafe extern "C" fn(input: u16) -> duckdb_value>,
+    pub duckdb_create_int32: ::std::option::Option<unsafe extern "C" fn(input: i32) -> duckdb_value>,
+    pub duckdb_create_uint32: ::std::option::Option<unsafe extern "C" fn(input: u32) -> duckdb_value>,
+    pub duckdb_create_uint64: ::std::option::Option<unsafe extern "C" fn(input: u64) -> duckdb_value>,
+    pub duckdb_create_int64: ::std::option::Option<unsafe extern "C" fn(val: i64) -> duckdb_value>,
+    pub duckdb_create_hugeint: ::std::option::Option<unsafe extern "C" fn(input: duckdb_hugeint) -> duckdb_value>,
+    pub duckdb_create_uhugeint: ::std::option::Option<unsafe extern "C" fn(input: duckdb_uhugeint) -> duckdb_value>,
+    pub duckdb_create_float: ::std::option::Option<unsafe extern "C" fn(input: f32) -> duckdb_value>,
+    pub duckdb_create_double: ::std::option::Option<unsafe extern "C" fn(input: f64) -> duckdb_value>,
+    pub duckdb_create_date: ::std::option::Option<unsafe extern "C" fn(input: duckdb_date) -> duckdb_value>,
+    pub duckdb_create_time: ::std::option::Option<unsafe extern "C" fn(input: duckdb_time) -> duckdb_value>,
+    pub duckdb_create_time_tz_value: ::std::option::Option<unsafe extern "C" fn(value: duckdb_time_tz) -> duckdb_value>,
+    pub duckdb_create_timestamp: ::std::option::Option<unsafe extern "C" fn(input: duckdb_timestamp) -> duckdb_value>,
+    pub duckdb_create_interval: ::std::option::Option<unsafe extern "C" fn(input: duckdb_interval) -> duckdb_value>,
+    pub duckdb_create_blob: ::std::option::Option<unsafe extern "C" fn(data: *const u8, length: idx_t) -> duckdb_value>,
+    pub duckdb_create_bignum: ::std::option::Option<unsafe extern "C" fn(input: duckdb_bignum) -> duckdb_value>,
+    pub duckdb_create_decimal: ::std::option::Option<unsafe extern "C" fn(input: duckdb_decimal) -> duckdb_value>,
+    pub duckdb_create_bit: ::std::option::Option<unsafe extern "C" fn(input: duckdb_bit) -> duckdb_value>,
+    pub duckdb_create_uuid: ::std::option::Option<unsafe extern "C" fn(input: duckdb_uhugeint) -> duckdb_value>,
+    pub duckdb_get_bool: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> bool>,
+    pub duckdb_get_int8: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> i8>,
+    pub duckdb_get_uint8: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> u8>,
+    pub duckdb_get_int16: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> i16>,
+    pub duckdb_get_uint16: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> u16>,
+    pub duckdb_get_int32: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> i32>,
+    pub duckdb_get_uint32: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> u32>,
+    pub duckdb_get_int64: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> i64>,
+    pub duckdb_get_uint64: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> u64>,
+    pub duckdb_get_hugeint: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_hugeint>,
+    pub duckdb_get_uhugeint: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_uhugeint>,
+    pub duckdb_get_float: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> f32>,
+    pub duckdb_get_double: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> f64>,
+    pub duckdb_get_date: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_date>,
+    pub duckdb_get_time: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_time>,
+    pub duckdb_get_time_tz: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_time_tz>,
+    pub duckdb_get_timestamp: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_timestamp>,
+    pub duckdb_get_interval: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_interval>,
+    pub duckdb_get_value_type: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_logical_type>,
+    pub duckdb_get_blob: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_blob>,
+    pub duckdb_get_bignum: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_bignum>,
+    pub duckdb_get_decimal: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_decimal>,
+    pub duckdb_get_bit: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_bit>,
+    pub duckdb_get_uuid: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_uhugeint>,
+    pub duckdb_get_varchar:
+        ::std::option::Option<unsafe extern "C" fn(value: duckdb_value) -> *mut ::std::os::raw::c_char>,
+    pub duckdb_create_struct_value: ::std::option::Option<
+        unsafe extern "C" fn(type_: duckdb_logical_type, values: *mut duckdb_value) -> duckdb_value,
+    >,
+    pub duckdb_create_list_value: ::std::option::Option<
+        unsafe extern "C" fn(type_: duckdb_logical_type, values: *mut duckdb_value, value_count: idx_t) -> duckdb_value,
+    >,
+    pub duckdb_create_array_value: ::std::option::Option<
+        unsafe extern "C" fn(type_: duckdb_logical_type, values: *mut duckdb_value, value_count: idx_t) -> duckdb_value,
+    >,
+    pub duckdb_get_map_size: ::std::option::Option<unsafe extern "C" fn(value: duckdb_value) -> idx_t>,
+    pub duckdb_get_map_key:
+        ::std::option::Option<unsafe extern "C" fn(value: duckdb_value, index: idx_t) -> duckdb_value>,
+    pub duckdb_get_map_value:
+        ::std::option::Option<unsafe extern "C" fn(value: duckdb_value, index: idx_t) -> duckdb_value>,
+    pub duckdb_is_null_value: ::std::option::Option<unsafe extern "C" fn(value: duckdb_value) -> bool>,
+    pub duckdb_create_null_value: ::std::option::Option<unsafe extern "C" fn() -> duckdb_value>,
+    pub duckdb_get_list_size: ::std::option::Option<unsafe extern "C" fn(value: duckdb_value) -> idx_t>,
+    pub duckdb_get_list_child:
+        ::std::option::Option<unsafe extern "C" fn(value: duckdb_value, index: idx_t) -> duckdb_value>,
+    pub duckdb_create_enum_value:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type, value: u64) -> duckdb_value>,
+    pub duckdb_get_enum_value: ::std::option::Option<unsafe extern "C" fn(value: duckdb_value) -> u64>,
+    pub duckdb_get_struct_child:
+        ::std::option::Option<unsafe extern "C" fn(value: duckdb_value, index: idx_t) -> duckdb_value>,
+    pub duckdb_create_logical_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_type) -> duckdb_logical_type>,
+    pub duckdb_logical_type_get_alias:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> *mut ::std::os::raw::c_char>,
+    pub duckdb_logical_type_set_alias:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type, alias: *const ::std::os::raw::c_char)>,
+    pub duckdb_create_list_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> duckdb_logical_type>,
+    pub duckdb_create_array_type: ::std::option::Option<
+        unsafe extern "C" fn(type_: duckdb_logical_type, array_size: idx_t) -> duckdb_logical_type,
+    >,
+    pub duckdb_create_map_type: ::std::option::Option<
+        unsafe extern "C" fn(key_type: duckdb_logical_type, value_type: duckdb_logical_type) -> duckdb_logical_type,
+    >,
+    pub duckdb_create_union_type: ::std::option::Option<
+        unsafe extern "C" fn(
+            member_types: *mut duckdb_logical_type,
+            member_names: *mut *const ::std::os::raw::c_char,
+            member_count: idx_t,
+        ) -> duckdb_logical_type,
+    >,
+    pub duckdb_create_struct_type: ::std::option::Option<
+        unsafe extern "C" fn(
+            member_types: *mut duckdb_logical_type,
+            member_names: *mut *const ::std::os::raw::c_char,
+            member_count: idx_t,
+        ) -> duckdb_logical_type,
+    >,
+    pub duckdb_create_enum_type: ::std::option::Option<
+        unsafe extern "C" fn(
+            member_names: *mut *const ::std::os::raw::c_char,
+            member_count: idx_t,
+        ) -> duckdb_logical_type,
+    >,
+    pub duckdb_create_decimal_type:
+        ::std::option::Option<unsafe extern "C" fn(width: u8, scale: u8) -> duckdb_logical_type>,
+    pub duckdb_get_type_id: ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> duckdb_type>,
+    pub duckdb_decimal_width: ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> u8>,
+    pub duckdb_decimal_scale: ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> u8>,
+    pub duckdb_decimal_internal_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> duckdb_type>,
+    pub duckdb_enum_internal_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> duckdb_type>,
+    pub duckdb_enum_dictionary_size: ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> u32>,
+    pub duckdb_enum_dictionary_value: ::std::option::Option<
+        unsafe extern "C" fn(type_: duckdb_logical_type, index: idx_t) -> *mut ::std::os::raw::c_char,
+    >,
+    pub duckdb_list_type_child_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> duckdb_logical_type>,
+    pub duckdb_array_type_child_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> duckdb_logical_type>,
+    pub duckdb_array_type_array_size: ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> idx_t>,
+    pub duckdb_map_type_key_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> duckdb_logical_type>,
+    pub duckdb_map_type_value_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> duckdb_logical_type>,
+    pub duckdb_struct_type_child_count:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> idx_t>,
+    pub duckdb_struct_type_child_name: ::std::option::Option<
+        unsafe extern "C" fn(type_: duckdb_logical_type, index: idx_t) -> *mut ::std::os::raw::c_char,
+    >,
+    pub duckdb_struct_type_child_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type, index: idx_t) -> duckdb_logical_type>,
+    pub duckdb_union_type_member_count:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> idx_t>,
+    pub duckdb_union_type_member_name: ::std::option::Option<
+        unsafe extern "C" fn(type_: duckdb_logical_type, index: idx_t) -> *mut ::std::os::raw::c_char,
+    >,
+    pub duckdb_union_type_member_type:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type, index: idx_t) -> duckdb_logical_type>,
+    pub duckdb_destroy_logical_type: ::std::option::Option<unsafe extern "C" fn(type_: *mut duckdb_logical_type)>,
+    pub duckdb_register_logical_type: ::std::option::Option<
+        unsafe extern "C" fn(
+            con: duckdb_connection,
+            type_: duckdb_logical_type,
+            info: duckdb_create_type_info,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_create_data_chunk: ::std::option::Option<
+        unsafe extern "C" fn(types: *mut duckdb_logical_type, column_count: idx_t) -> duckdb_data_chunk,
+    >,
+    pub duckdb_destroy_data_chunk: ::std::option::Option<unsafe extern "C" fn(chunk: *mut duckdb_data_chunk)>,
+    pub duckdb_data_chunk_reset: ::std::option::Option<unsafe extern "C" fn(chunk: duckdb_data_chunk)>,
+    pub duckdb_data_chunk_get_column_count:
+        ::std::option::Option<unsafe extern "C" fn(chunk: duckdb_data_chunk) -> idx_t>,
+    pub duckdb_data_chunk_get_vector:
+        ::std::option::Option<unsafe extern "C" fn(chunk: duckdb_data_chunk, col_idx: idx_t) -> duckdb_vector>,
+    pub duckdb_data_chunk_get_size: ::std::option::Option<unsafe extern "C" fn(chunk: duckdb_data_chunk) -> idx_t>,
+    pub duckdb_data_chunk_set_size: ::std::option::Option<unsafe extern "C" fn(chunk: duckdb_data_chunk, size: idx_t)>,
+    pub duckdb_vector_get_column_type:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector) -> duckdb_logical_type>,
+    pub duckdb_vector_get_data:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_vector_get_validity: ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector) -> *mut u64>,
+    pub duckdb_vector_ensure_validity_writable: ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector)>,
+    pub duckdb_vector_assign_string_element: ::std::option::Option<
+        unsafe extern "C" fn(vector: duckdb_vector, index: idx_t, str_: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_vector_assign_string_element_len: ::std::option::Option<
+        unsafe extern "C" fn(vector: duckdb_vector, index: idx_t, str_: *const ::std::os::raw::c_char, str_len: idx_t),
+    >,
+    pub duckdb_list_vector_get_child:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector) -> duckdb_vector>,
+    pub duckdb_list_vector_get_size: ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector) -> idx_t>,
+    pub duckdb_list_vector_set_size:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector, size: idx_t) -> duckdb_state>,
+    pub duckdb_list_vector_reserve:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector, required_capacity: idx_t) -> duckdb_state>,
+    pub duckdb_struct_vector_get_child:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector, index: idx_t) -> duckdb_vector>,
+    pub duckdb_array_vector_get_child:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector) -> duckdb_vector>,
+    pub duckdb_validity_row_is_valid:
+        ::std::option::Option<unsafe extern "C" fn(validity: *mut u64, row: idx_t) -> bool>,
+    pub duckdb_validity_set_row_validity:
+        ::std::option::Option<unsafe extern "C" fn(validity: *mut u64, row: idx_t, valid: bool)>,
+    pub duckdb_validity_set_row_invalid: ::std::option::Option<unsafe extern "C" fn(validity: *mut u64, row: idx_t)>,
+    pub duckdb_validity_set_row_valid: ::std::option::Option<unsafe extern "C" fn(validity: *mut u64, row: idx_t)>,
+    pub duckdb_create_scalar_function: ::std::option::Option<unsafe extern "C" fn() -> duckdb_scalar_function>,
+    pub duckdb_destroy_scalar_function:
+        ::std::option::Option<unsafe extern "C" fn(scalar_function: *mut duckdb_scalar_function)>,
+    pub duckdb_scalar_function_set_name: ::std::option::Option<
+        unsafe extern "C" fn(scalar_function: duckdb_scalar_function, name: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_scalar_function_set_varargs: ::std::option::Option<
+        unsafe extern "C" fn(scalar_function: duckdb_scalar_function, type_: duckdb_logical_type),
+    >,
+    pub duckdb_scalar_function_set_special_handling:
+        ::std::option::Option<unsafe extern "C" fn(scalar_function: duckdb_scalar_function)>,
+    pub duckdb_scalar_function_set_volatile:
+        ::std::option::Option<unsafe extern "C" fn(scalar_function: duckdb_scalar_function)>,
+    pub duckdb_scalar_function_add_parameter: ::std::option::Option<
+        unsafe extern "C" fn(scalar_function: duckdb_scalar_function, type_: duckdb_logical_type),
+    >,
+    pub duckdb_scalar_function_set_return_type: ::std::option::Option<
+        unsafe extern "C" fn(scalar_function: duckdb_scalar_function, type_: duckdb_logical_type),
+    >,
+    pub duckdb_scalar_function_set_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(
+            scalar_function: duckdb_scalar_function,
+            extra_info: *mut ::std::os::raw::c_void,
+            destroy: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_scalar_function_set_function: ::std::option::Option<
+        unsafe extern "C" fn(scalar_function: duckdb_scalar_function, function: duckdb_scalar_function_t),
+    >,
+    pub duckdb_register_scalar_function: ::std::option::Option<
+        unsafe extern "C" fn(con: duckdb_connection, scalar_function: duckdb_scalar_function) -> duckdb_state,
+    >,
+    pub duckdb_scalar_function_get_extra_info:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_scalar_function_set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info, error: *const ::std::os::raw::c_char)>,
+    pub duckdb_create_scalar_function_set:
+        ::std::option::Option<unsafe extern "C" fn(name: *const ::std::os::raw::c_char) -> duckdb_scalar_function_set>,
+    pub duckdb_destroy_scalar_function_set:
+        ::std::option::Option<unsafe extern "C" fn(scalar_function_set: *mut duckdb_scalar_function_set)>,
+    pub duckdb_add_scalar_function_to_set: ::std::option::Option<
+        unsafe extern "C" fn(set: duckdb_scalar_function_set, function: duckdb_scalar_function) -> duckdb_state,
+    >,
+    pub duckdb_register_scalar_function_set: ::std::option::Option<
+        unsafe extern "C" fn(con: duckdb_connection, set: duckdb_scalar_function_set) -> duckdb_state,
+    >,
+    pub duckdb_create_aggregate_function: ::std::option::Option<unsafe extern "C" fn() -> duckdb_aggregate_function>,
+    pub duckdb_destroy_aggregate_function:
+        ::std::option::Option<unsafe extern "C" fn(aggregate_function: *mut duckdb_aggregate_function)>,
+    pub duckdb_aggregate_function_set_name: ::std::option::Option<
+        unsafe extern "C" fn(aggregate_function: duckdb_aggregate_function, name: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_aggregate_function_add_parameter: ::std::option::Option<
+        unsafe extern "C" fn(aggregate_function: duckdb_aggregate_function, type_: duckdb_logical_type),
+    >,
+    pub duckdb_aggregate_function_set_return_type: ::std::option::Option<
+        unsafe extern "C" fn(aggregate_function: duckdb_aggregate_function, type_: duckdb_logical_type),
+    >,
+    pub duckdb_aggregate_function_set_functions: ::std::option::Option<
+        unsafe extern "C" fn(
+            aggregate_function: duckdb_aggregate_function,
+            state_size: duckdb_aggregate_state_size,
+            state_init: duckdb_aggregate_init_t,
+            update: duckdb_aggregate_update_t,
+            combine: duckdb_aggregate_combine_t,
+            finalize: duckdb_aggregate_finalize_t,
+        ),
+    >,
+    pub duckdb_aggregate_function_set_destructor: ::std::option::Option<
+        unsafe extern "C" fn(aggregate_function: duckdb_aggregate_function, destroy: duckdb_aggregate_destroy_t),
+    >,
+    pub duckdb_register_aggregate_function: ::std::option::Option<
+        unsafe extern "C" fn(con: duckdb_connection, aggregate_function: duckdb_aggregate_function) -> duckdb_state,
+    >,
+    pub duckdb_aggregate_function_set_special_handling:
+        ::std::option::Option<unsafe extern "C" fn(aggregate_function: duckdb_aggregate_function)>,
+    pub duckdb_aggregate_function_set_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(
+            aggregate_function: duckdb_aggregate_function,
+            extra_info: *mut ::std::os::raw::c_void,
+            destroy: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_aggregate_function_get_extra_info:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_aggregate_function_set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info, error: *const ::std::os::raw::c_char)>,
+    pub duckdb_create_aggregate_function_set: ::std::option::Option<
+        unsafe extern "C" fn(name: *const ::std::os::raw::c_char) -> duckdb_aggregate_function_set,
+    >,
+    pub duckdb_destroy_aggregate_function_set:
+        ::std::option::Option<unsafe extern "C" fn(aggregate_function_set: *mut duckdb_aggregate_function_set)>,
+    pub duckdb_add_aggregate_function_to_set: ::std::option::Option<
+        unsafe extern "C" fn(set: duckdb_aggregate_function_set, function: duckdb_aggregate_function) -> duckdb_state,
+    >,
+    pub duckdb_register_aggregate_function_set: ::std::option::Option<
+        unsafe extern "C" fn(con: duckdb_connection, set: duckdb_aggregate_function_set) -> duckdb_state,
+    >,
+    pub duckdb_create_table_function: ::std::option::Option<unsafe extern "C" fn() -> duckdb_table_function>,
+    pub duckdb_destroy_table_function:
+        ::std::option::Option<unsafe extern "C" fn(table_function: *mut duckdb_table_function)>,
+    pub duckdb_table_function_set_name: ::std::option::Option<
+        unsafe extern "C" fn(table_function: duckdb_table_function, name: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_table_function_add_parameter:
+        ::std::option::Option<unsafe extern "C" fn(table_function: duckdb_table_function, type_: duckdb_logical_type)>,
+    pub duckdb_table_function_add_named_parameter: ::std::option::Option<
+        unsafe extern "C" fn(
+            table_function: duckdb_table_function,
+            name: *const ::std::os::raw::c_char,
+            type_: duckdb_logical_type,
+        ),
+    >,
+    pub duckdb_table_function_set_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(
+            table_function: duckdb_table_function,
+            extra_info: *mut ::std::os::raw::c_void,
+            destroy: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_table_function_set_bind: ::std::option::Option<
+        unsafe extern "C" fn(table_function: duckdb_table_function, bind: duckdb_table_function_bind_t),
+    >,
+    pub duckdb_table_function_set_init: ::std::option::Option<
+        unsafe extern "C" fn(table_function: duckdb_table_function, init: duckdb_table_function_init_t),
+    >,
+    pub duckdb_table_function_set_local_init: ::std::option::Option<
+        unsafe extern "C" fn(table_function: duckdb_table_function, init: duckdb_table_function_init_t),
+    >,
+    pub duckdb_table_function_set_function: ::std::option::Option<
+        unsafe extern "C" fn(table_function: duckdb_table_function, function: duckdb_table_function_t),
+    >,
+    pub duckdb_table_function_supports_projection_pushdown:
+        ::std::option::Option<unsafe extern "C" fn(table_function: duckdb_table_function, pushdown: bool)>,
+    pub duckdb_register_table_function: ::std::option::Option<
+        unsafe extern "C" fn(con: duckdb_connection, function: duckdb_table_function) -> duckdb_state,
+    >,
+    pub duckdb_bind_get_extra_info:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_bind_add_result_column: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_bind_info, name: *const ::std::os::raw::c_char, type_: duckdb_logical_type),
+    >,
+    pub duckdb_bind_get_parameter_count: ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info) -> idx_t>,
+    pub duckdb_bind_get_parameter:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, index: idx_t) -> duckdb_value>,
+    pub duckdb_bind_get_named_parameter: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_bind_info, name: *const ::std::os::raw::c_char) -> duckdb_value,
+    >,
+    pub duckdb_bind_set_bind_data: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_bind_info,
+            bind_data: *mut ::std::os::raw::c_void,
+            destroy: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_bind_set_cardinality:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, cardinality: idx_t, is_exact: bool)>,
+    pub duckdb_bind_set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, error: *const ::std::os::raw::c_char)>,
+    pub duckdb_init_get_extra_info:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_init_get_bind_data:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_init_set_init_data: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_init_info,
+            init_data: *mut ::std::os::raw::c_void,
+            destroy: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_init_get_column_count: ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info) -> idx_t>,
+    pub duckdb_init_get_column_index:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info, column_index: idx_t) -> idx_t>,
+    pub duckdb_init_set_max_threads:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info, max_threads: idx_t)>,
+    pub duckdb_init_set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info, error: *const ::std::os::raw::c_char)>,
+    pub duckdb_function_get_extra_info:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_function_get_bind_data:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_function_get_init_data:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_function_get_local_init_data:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_function_set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info, error: *const ::std::os::raw::c_char)>,
+    pub duckdb_add_replacement_scan: ::std::option::Option<
+        unsafe extern "C" fn(
+            db: duckdb_database,
+            replacement: duckdb_replacement_callback_t,
+            extra_data: *mut ::std::os::raw::c_void,
+            delete_callback: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_replacement_scan_set_function_name: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_replacement_scan_info, function_name: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_replacement_scan_add_parameter:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_replacement_scan_info, parameter: duckdb_value)>,
+    pub duckdb_replacement_scan_set_error: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_replacement_scan_info, error: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_profiling_info_get_metrics:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_profiling_info) -> duckdb_value>,
+    pub duckdb_profiling_info_get_child_count:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_profiling_info) -> idx_t>,
+    pub duckdb_profiling_info_get_child:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_profiling_info, index: idx_t) -> duckdb_profiling_info>,
+    pub duckdb_appender_create: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            schema: *const ::std::os::raw::c_char,
+            table: *const ::std::os::raw::c_char,
+            out_appender: *mut duckdb_appender,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_appender_create_ext: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            catalog: *const ::std::os::raw::c_char,
+            schema: *const ::std::os::raw::c_char,
+            table: *const ::std::os::raw::c_char,
+            out_appender: *mut duckdb_appender,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_appender_column_count: ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> idx_t>,
+    pub duckdb_appender_column_type:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, col_idx: idx_t) -> duckdb_logical_type>,
+    pub duckdb_appender_error:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> *const ::std::os::raw::c_char>,
+    pub duckdb_appender_flush: ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state>,
+    pub duckdb_appender_close: ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state>,
+    pub duckdb_appender_destroy:
+        ::std::option::Option<unsafe extern "C" fn(appender: *mut duckdb_appender) -> duckdb_state>,
+    pub duckdb_appender_add_column: ::std::option::Option<
+        unsafe extern "C" fn(appender: duckdb_appender, name: *const ::std::os::raw::c_char) -> duckdb_state,
+    >,
+    pub duckdb_appender_clear_columns:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state>,
+    pub duckdb_append_data_chunk: ::std::option::Option<
+        unsafe extern "C" fn(appender: duckdb_appender, chunk: duckdb_data_chunk) -> duckdb_state,
+    >,
+    pub duckdb_table_description_create: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            schema: *const ::std::os::raw::c_char,
+            table: *const ::std::os::raw::c_char,
+            out: *mut duckdb_table_description,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_table_description_create_ext: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            catalog: *const ::std::os::raw::c_char,
+            schema: *const ::std::os::raw::c_char,
+            table: *const ::std::os::raw::c_char,
+            out: *mut duckdb_table_description,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_table_description_destroy:
+        ::std::option::Option<unsafe extern "C" fn(table_description: *mut duckdb_table_description)>,
+    pub duckdb_table_description_error: ::std::option::Option<
+        unsafe extern "C" fn(table_description: duckdb_table_description) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_column_has_default: ::std::option::Option<
+        unsafe extern "C" fn(table_description: duckdb_table_description, index: idx_t, out: *mut bool) -> duckdb_state,
+    >,
+    pub duckdb_table_description_get_column_name: ::std::option::Option<
+        unsafe extern "C" fn(table_description: duckdb_table_description, index: idx_t) -> *mut ::std::os::raw::c_char,
+    >,
+    pub duckdb_execute_tasks: ::std::option::Option<unsafe extern "C" fn(database: duckdb_database, max_tasks: idx_t)>,
+    pub duckdb_create_task_state:
+        ::std::option::Option<unsafe extern "C" fn(database: duckdb_database) -> duckdb_task_state>,
+    pub duckdb_execute_tasks_state: ::std::option::Option<unsafe extern "C" fn(state: duckdb_task_state)>,
+    pub duckdb_execute_n_tasks_state:
+        ::std::option::Option<unsafe extern "C" fn(state: duckdb_task_state, max_tasks: idx_t) -> idx_t>,
+    pub duckdb_finish_execution: ::std::option::Option<unsafe extern "C" fn(state: duckdb_task_state)>,
+    pub duckdb_task_state_is_finished: ::std::option::Option<unsafe extern "C" fn(state: duckdb_task_state) -> bool>,
+    pub duckdb_destroy_task_state: ::std::option::Option<unsafe extern "C" fn(state: duckdb_task_state)>,
+    pub duckdb_execution_is_finished: ::std::option::Option<unsafe extern "C" fn(con: duckdb_connection) -> bool>,
+    pub duckdb_fetch_chunk: ::std::option::Option<unsafe extern "C" fn(result: duckdb_result) -> duckdb_data_chunk>,
+    pub duckdb_create_cast_function: ::std::option::Option<unsafe extern "C" fn() -> duckdb_cast_function>,
+    pub duckdb_cast_function_set_source_type: ::std::option::Option<
+        unsafe extern "C" fn(cast_function: duckdb_cast_function, source_type: duckdb_logical_type),
+    >,
+    pub duckdb_cast_function_set_target_type: ::std::option::Option<
+        unsafe extern "C" fn(cast_function: duckdb_cast_function, target_type: duckdb_logical_type),
+    >,
+    pub duckdb_cast_function_set_implicit_cast_cost:
+        ::std::option::Option<unsafe extern "C" fn(cast_function: duckdb_cast_function, cost: i64)>,
+    pub duckdb_cast_function_set_function: ::std::option::Option<
+        unsafe extern "C" fn(cast_function: duckdb_cast_function, function: duckdb_cast_function_t),
+    >,
+    pub duckdb_cast_function_set_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(
+            cast_function: duckdb_cast_function,
+            extra_info: *mut ::std::os::raw::c_void,
+            destroy: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_cast_function_get_extra_info:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_cast_function_get_cast_mode:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> duckdb_cast_mode>,
+    pub duckdb_cast_function_set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info, error: *const ::std::os::raw::c_char)>,
+    pub duckdb_cast_function_set_row_error: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_function_info,
+            error: *const ::std::os::raw::c_char,
+            row: idx_t,
+            output: duckdb_vector,
+        ),
+    >,
+    pub duckdb_register_cast_function: ::std::option::Option<
+        unsafe extern "C" fn(con: duckdb_connection, cast_function: duckdb_cast_function) -> duckdb_state,
+    >,
+    pub duckdb_destroy_cast_function:
+        ::std::option::Option<unsafe extern "C" fn(cast_function: *mut duckdb_cast_function)>,
+    pub duckdb_is_finite_timestamp_s: ::std::option::Option<unsafe extern "C" fn(ts: duckdb_timestamp_s) -> bool>,
+    pub duckdb_is_finite_timestamp_ms: ::std::option::Option<unsafe extern "C" fn(ts: duckdb_timestamp_ms) -> bool>,
+    pub duckdb_is_finite_timestamp_ns: ::std::option::Option<unsafe extern "C" fn(ts: duckdb_timestamp_ns) -> bool>,
+    pub duckdb_create_timestamp_tz:
+        ::std::option::Option<unsafe extern "C" fn(input: duckdb_timestamp) -> duckdb_value>,
+    pub duckdb_create_timestamp_s:
+        ::std::option::Option<unsafe extern "C" fn(input: duckdb_timestamp_s) -> duckdb_value>,
+    pub duckdb_create_timestamp_ms:
+        ::std::option::Option<unsafe extern "C" fn(input: duckdb_timestamp_ms) -> duckdb_value>,
+    pub duckdb_create_timestamp_ns:
+        ::std::option::Option<unsafe extern "C" fn(input: duckdb_timestamp_ns) -> duckdb_value>,
+    pub duckdb_get_timestamp_tz: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_timestamp>,
+    pub duckdb_get_timestamp_s: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_timestamp_s>,
+    pub duckdb_get_timestamp_ms: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_timestamp_ms>,
+    pub duckdb_get_timestamp_ns: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_timestamp_ns>,
+    pub duckdb_append_value:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: duckdb_value) -> duckdb_state>,
+    pub duckdb_get_profiling_info:
+        ::std::option::Option<unsafe extern "C" fn(connection: duckdb_connection) -> duckdb_profiling_info>,
+    pub duckdb_profiling_info_get_value: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_profiling_info, key: *const ::std::os::raw::c_char) -> duckdb_value,
+    >,
+    pub duckdb_appender_begin_row:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state>,
+    pub duckdb_appender_end_row: ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state>,
+    pub duckdb_append_default: ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state>,
+    pub duckdb_append_bool:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: bool) -> duckdb_state>,
+    pub duckdb_append_int8:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: i8) -> duckdb_state>,
+    pub duckdb_append_int16:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: i16) -> duckdb_state>,
+    pub duckdb_append_int32:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: i32) -> duckdb_state>,
+    pub duckdb_append_int64:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: i64) -> duckdb_state>,
+    pub duckdb_append_hugeint:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: duckdb_hugeint) -> duckdb_state>,
+    pub duckdb_append_uint8:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: u8) -> duckdb_state>,
+    pub duckdb_append_uint16:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: u16) -> duckdb_state>,
+    pub duckdb_append_uint32:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: u32) -> duckdb_state>,
+    pub duckdb_append_uint64:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: u64) -> duckdb_state>,
+    pub duckdb_append_uhugeint:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: duckdb_uhugeint) -> duckdb_state>,
+    pub duckdb_append_float:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: f32) -> duckdb_state>,
+    pub duckdb_append_double:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: f64) -> duckdb_state>,
+    pub duckdb_append_date:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: duckdb_date) -> duckdb_state>,
+    pub duckdb_append_time:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: duckdb_time) -> duckdb_state>,
+    pub duckdb_append_timestamp:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: duckdb_timestamp) -> duckdb_state>,
+    pub duckdb_append_interval:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender, value: duckdb_interval) -> duckdb_state>,
+    pub duckdb_append_varchar: ::std::option::Option<
+        unsafe extern "C" fn(appender: duckdb_appender, val: *const ::std::os::raw::c_char) -> duckdb_state,
+    >,
+    pub duckdb_append_varchar_length: ::std::option::Option<
+        unsafe extern "C" fn(
+            appender: duckdb_appender,
+            val: *const ::std::os::raw::c_char,
+            length: idx_t,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_append_blob: ::std::option::Option<
+        unsafe extern "C" fn(
+            appender: duckdb_appender,
+            data: *const ::std::os::raw::c_void,
+            length: idx_t,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_append_null: ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state>,
+    pub duckdb_row_count: ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result) -> idx_t>,
+    pub duckdb_column_data: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_nullmask_data:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t) -> *mut bool>,
+    pub duckdb_result_get_chunk:
+        ::std::option::Option<unsafe extern "C" fn(result: duckdb_result, chunk_index: idx_t) -> duckdb_data_chunk>,
+    pub duckdb_result_is_streaming: ::std::option::Option<unsafe extern "C" fn(result: duckdb_result) -> bool>,
+    pub duckdb_result_chunk_count: ::std::option::Option<unsafe extern "C" fn(result: duckdb_result) -> idx_t>,
+    pub duckdb_value_boolean:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> bool>,
+    pub duckdb_value_int8:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> i8>,
+    pub duckdb_value_int16:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> i16>,
+    pub duckdb_value_int32:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> i32>,
+    pub duckdb_value_int64:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> i64>,
+    pub duckdb_value_hugeint: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_hugeint,
+    >,
+    pub duckdb_value_uhugeint: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_uhugeint,
+    >,
+    pub duckdb_value_decimal: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_decimal,
+    >,
+    pub duckdb_value_uint8:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> u8>,
+    pub duckdb_value_uint16:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> u16>,
+    pub duckdb_value_uint32:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> u32>,
+    pub duckdb_value_uint64:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> u64>,
+    pub duckdb_value_float:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> f32>,
+    pub duckdb_value_double:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> f64>,
+    pub duckdb_value_date:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_date>,
+    pub duckdb_value_time:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_time>,
+    pub duckdb_value_timestamp: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_timestamp,
+    >,
+    pub duckdb_value_interval: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_interval,
+    >,
+    pub duckdb_value_varchar: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> *mut ::std::os::raw::c_char,
+    >,
+    pub duckdb_value_string: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_string,
+    >,
+    pub duckdb_value_varchar_internal: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> *mut ::std::os::raw::c_char,
+    >,
+    pub duckdb_value_string_internal: ::std::option::Option<
+        unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_string,
+    >,
+    pub duckdb_value_blob:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> duckdb_blob>,
+    pub duckdb_value_is_null:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result, col: idx_t, row: idx_t) -> bool>,
+    pub duckdb_execute_prepared_streaming: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            out_result: *mut duckdb_result,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_pending_prepared_streaming: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            out_result: *mut duckdb_pending_result,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_query_arrow: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            query: *const ::std::os::raw::c_char,
+            out_result: *mut duckdb_arrow,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_query_arrow_schema: ::std::option::Option<
+        unsafe extern "C" fn(result: duckdb_arrow, out_schema: *mut duckdb_arrow_schema) -> duckdb_state,
+    >,
+    pub duckdb_prepared_arrow_schema: ::std::option::Option<
+        unsafe extern "C" fn(prepared: duckdb_prepared_statement, out_schema: *mut duckdb_arrow_schema) -> duckdb_state,
+    >,
+    pub duckdb_result_arrow_array: ::std::option::Option<
+        unsafe extern "C" fn(result: duckdb_result, chunk: duckdb_data_chunk, out_array: *mut duckdb_arrow_array),
+    >,
+    pub duckdb_query_arrow_array: ::std::option::Option<
+        unsafe extern "C" fn(result: duckdb_arrow, out_array: *mut duckdb_arrow_array) -> duckdb_state,
+    >,
+    pub duckdb_arrow_column_count: ::std::option::Option<unsafe extern "C" fn(result: duckdb_arrow) -> idx_t>,
+    pub duckdb_arrow_row_count: ::std::option::Option<unsafe extern "C" fn(result: duckdb_arrow) -> idx_t>,
+    pub duckdb_arrow_rows_changed: ::std::option::Option<unsafe extern "C" fn(result: duckdb_arrow) -> idx_t>,
+    pub duckdb_query_arrow_error:
+        ::std::option::Option<unsafe extern "C" fn(result: duckdb_arrow) -> *const ::std::os::raw::c_char>,
+    pub duckdb_destroy_arrow: ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_arrow)>,
+    pub duckdb_destroy_arrow_stream: ::std::option::Option<unsafe extern "C" fn(stream_p: *mut duckdb_arrow_stream)>,
+    pub duckdb_execute_prepared_arrow: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            out_result: *mut duckdb_arrow,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_arrow_scan: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            table_name: *const ::std::os::raw::c_char,
+            arrow: duckdb_arrow_stream,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_arrow_array_scan: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            table_name: *const ::std::os::raw::c_char,
+            arrow_schema: duckdb_arrow_schema,
+            arrow_array: duckdb_arrow_array,
+            out_stream: *mut duckdb_arrow_stream,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_stream_fetch_chunk:
+        ::std::option::Option<unsafe extern "C" fn(result: duckdb_result) -> duckdb_data_chunk>,
+    pub duckdb_create_instance_cache: ::std::option::Option<unsafe extern "C" fn() -> duckdb_instance_cache>,
+    pub duckdb_get_or_create_from_cache: ::std::option::Option<
+        unsafe extern "C" fn(
+            instance_cache: duckdb_instance_cache,
+            path: *const ::std::os::raw::c_char,
+            out_database: *mut duckdb_database,
+            config: duckdb_config,
+            out_error: *mut *mut ::std::os::raw::c_char,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_destroy_instance_cache:
+        ::std::option::Option<unsafe extern "C" fn(instance_cache: *mut duckdb_instance_cache)>,
+    pub duckdb_append_default_to_chunk: ::std::option::Option<
+        unsafe extern "C" fn(
+            appender: duckdb_appender,
+            chunk: duckdb_data_chunk,
+            col: idx_t,
+            row: idx_t,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_appender_error_data:
+        ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_error_data>,
+    pub duckdb_appender_create_query: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            query: *const ::std::os::raw::c_char,
+            column_count: idx_t,
+            types: *mut duckdb_logical_type,
+            table_name: *const ::std::os::raw::c_char,
+            column_names: *mut *const ::std::os::raw::c_char,
+            out_appender: *mut duckdb_appender,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_appender_clear: ::std::option::Option<unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state>,
+    pub duckdb_to_arrow_schema: ::std::option::Option<
+        unsafe extern "C" fn(
+            arrow_options: duckdb_arrow_options,
+            types: *mut duckdb_logical_type,
+            names: *mut *const ::std::os::raw::c_char,
+            column_count: idx_t,
+            out_schema: *mut ArrowSchema,
+        ) -> duckdb_error_data,
+    >,
+    pub duckdb_data_chunk_to_arrow: ::std::option::Option<
+        unsafe extern "C" fn(
+            arrow_options: duckdb_arrow_options,
+            chunk: duckdb_data_chunk,
+            out_arrow_array: *mut ArrowArray,
+        ) -> duckdb_error_data,
+    >,
+    pub duckdb_schema_from_arrow: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            schema: *mut ArrowSchema,
+            out_types: *mut duckdb_arrow_converted_schema,
+        ) -> duckdb_error_data,
+    >,
+    pub duckdb_data_chunk_from_arrow: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            arrow_array: *mut ArrowArray,
+            converted_schema: duckdb_arrow_converted_schema,
+            out_chunk: *mut duckdb_data_chunk,
+        ) -> duckdb_error_data,
+    >,
+    pub duckdb_destroy_arrow_converted_schema:
+        ::std::option::Option<unsafe extern "C" fn(arrow_converted_schema: *mut duckdb_arrow_converted_schema)>,
+    pub duckdb_client_context_get_catalog: ::std::option::Option<
+        unsafe extern "C" fn(
+            context: duckdb_client_context,
+            catalog_name: *const ::std::os::raw::c_char,
+        ) -> duckdb_catalog,
+    >,
+    pub duckdb_catalog_get_type_name:
+        ::std::option::Option<unsafe extern "C" fn(catalog: duckdb_catalog) -> *const ::std::os::raw::c_char>,
+    pub duckdb_catalog_get_entry: ::std::option::Option<
+        unsafe extern "C" fn(
+            catalog: duckdb_catalog,
+            context: duckdb_client_context,
+            entry_type: duckdb_catalog_entry_type,
+            schema_name: *const ::std::os::raw::c_char,
+            entry_name: *const ::std::os::raw::c_char,
+        ) -> duckdb_catalog_entry,
+    >,
+    pub duckdb_destroy_catalog: ::std::option::Option<unsafe extern "C" fn(catalog: *mut duckdb_catalog)>,
+    pub duckdb_catalog_entry_get_type:
+        ::std::option::Option<unsafe extern "C" fn(entry: duckdb_catalog_entry) -> duckdb_catalog_entry_type>,
+    pub duckdb_catalog_entry_get_name:
+        ::std::option::Option<unsafe extern "C" fn(entry: duckdb_catalog_entry) -> *const ::std::os::raw::c_char>,
+    pub duckdb_destroy_catalog_entry: ::std::option::Option<unsafe extern "C" fn(entry: *mut duckdb_catalog_entry)>,
+    pub duckdb_create_config_option: ::std::option::Option<unsafe extern "C" fn() -> duckdb_config_option>,
+    pub duckdb_destroy_config_option: ::std::option::Option<unsafe extern "C" fn(option: *mut duckdb_config_option)>,
+    pub duckdb_config_option_set_name:
+        ::std::option::Option<unsafe extern "C" fn(option: duckdb_config_option, name: *const ::std::os::raw::c_char)>,
+    pub duckdb_config_option_set_type:
+        ::std::option::Option<unsafe extern "C" fn(option: duckdb_config_option, type_: duckdb_logical_type)>,
+    pub duckdb_config_option_set_default_value:
+        ::std::option::Option<unsafe extern "C" fn(option: duckdb_config_option, default_value: duckdb_value)>,
+    pub duckdb_config_option_set_default_scope: ::std::option::Option<
+        unsafe extern "C" fn(option: duckdb_config_option, default_scope: duckdb_config_option_scope),
+    >,
+    pub duckdb_config_option_set_description: ::std::option::Option<
+        unsafe extern "C" fn(option: duckdb_config_option, description: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_register_config_option: ::std::option::Option<
+        unsafe extern "C" fn(connection: duckdb_connection, option: duckdb_config_option) -> duckdb_state,
+    >,
+    pub duckdb_client_context_get_config_option: ::std::option::Option<
+        unsafe extern "C" fn(
+            context: duckdb_client_context,
+            name: *const ::std::os::raw::c_char,
+            out_scope: *mut duckdb_config_option_scope,
+        ) -> duckdb_value,
+    >,
+    pub duckdb_create_copy_function: ::std::option::Option<unsafe extern "C" fn() -> duckdb_copy_function>,
+    pub duckdb_copy_function_set_name: ::std::option::Option<
+        unsafe extern "C" fn(copy_function: duckdb_copy_function, name: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_copy_function_set_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(
+            copy_function: duckdb_copy_function,
+            extra_info: *mut ::std::os::raw::c_void,
+            destructor: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_register_copy_function: ::std::option::Option<
+        unsafe extern "C" fn(connection: duckdb_connection, copy_function: duckdb_copy_function) -> duckdb_state,
+    >,
+    pub duckdb_destroy_copy_function:
+        ::std::option::Option<unsafe extern "C" fn(copy_function: *mut duckdb_copy_function)>,
+    pub duckdb_copy_function_set_bind: ::std::option::Option<
+        unsafe extern "C" fn(copy_function: duckdb_copy_function, bind: duckdb_copy_function_bind_t),
+    >,
+    pub duckdb_copy_function_bind_set_error: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_bind_info, error: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_copy_function_bind_get_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_bind_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_bind_get_client_context:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_bind_info) -> duckdb_client_context>,
+    pub duckdb_copy_function_bind_get_column_count:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_bind_info) -> idx_t>,
+    pub duckdb_copy_function_bind_get_column_type: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_bind_info, col_idx: idx_t) -> duckdb_logical_type,
+    >,
+    pub duckdb_copy_function_bind_get_options:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_bind_info) -> duckdb_value>,
+    pub duckdb_copy_function_bind_set_bind_data: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_copy_function_bind_info,
+            bind_data: *mut ::std::os::raw::c_void,
+            destructor: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_copy_function_set_global_init: ::std::option::Option<
+        unsafe extern "C" fn(copy_function: duckdb_copy_function, init: duckdb_copy_function_global_init_t),
+    >,
+    pub duckdb_copy_function_global_init_set_error: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_global_init_info, error: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_copy_function_global_init_get_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_global_init_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_global_init_get_client_context: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_global_init_info) -> duckdb_client_context,
+    >,
+    pub duckdb_copy_function_global_init_get_bind_data: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_global_init_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_global_init_set_global_state: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_copy_function_global_init_info,
+            global_state: *mut ::std::os::raw::c_void,
+            destructor: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_copy_function_global_init_get_file_path: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_global_init_info) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_copy_function_set_sink: ::std::option::Option<
+        unsafe extern "C" fn(copy_function: duckdb_copy_function, function: duckdb_copy_function_sink_t),
+    >,
+    pub duckdb_copy_function_sink_set_error: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_sink_info, error: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_copy_function_sink_get_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_sink_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_sink_get_client_context:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_sink_info) -> duckdb_client_context>,
+    pub duckdb_copy_function_sink_get_bind_data: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_sink_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_sink_get_global_state: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_sink_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_set_finalize: ::std::option::Option<
+        unsafe extern "C" fn(copy_function: duckdb_copy_function, finalize: duckdb_copy_function_finalize_t),
+    >,
+    pub duckdb_copy_function_finalize_set_error: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_finalize_info, error: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_copy_function_finalize_get_extra_info: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_finalize_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_finalize_get_client_context:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_copy_function_finalize_info) -> duckdb_client_context>,
+    pub duckdb_copy_function_finalize_get_bind_data: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_finalize_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_finalize_get_global_state: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_copy_function_finalize_info) -> *mut ::std::os::raw::c_void,
+    >,
+    pub duckdb_copy_function_set_copy_from_function: ::std::option::Option<
+        unsafe extern "C" fn(copy_function: duckdb_copy_function, table_function: duckdb_table_function),
+    >,
+    pub duckdb_table_function_bind_get_result_column_count:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info) -> idx_t>,
+    pub duckdb_table_function_bind_get_result_column_name: ::std::option::Option<
+        unsafe extern "C" fn(info: duckdb_bind_info, col_idx: idx_t) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_table_function_bind_get_result_column_type:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, col_idx: idx_t) -> duckdb_logical_type>,
+    pub duckdb_create_error_data: ::std::option::Option<
+        unsafe extern "C" fn(type_: duckdb_error_type, message: *const ::std::os::raw::c_char) -> duckdb_error_data,
+    >,
+    pub duckdb_destroy_error_data: ::std::option::Option<unsafe extern "C" fn(error_data: *mut duckdb_error_data)>,
+    pub duckdb_error_data_error_type:
+        ::std::option::Option<unsafe extern "C" fn(error_data: duckdb_error_data) -> duckdb_error_type>,
+    pub duckdb_error_data_message:
+        ::std::option::Option<unsafe extern "C" fn(error_data: duckdb_error_data) -> *const ::std::os::raw::c_char>,
+    pub duckdb_error_data_has_error: ::std::option::Option<unsafe extern "C" fn(error_data: duckdb_error_data) -> bool>,
+    pub duckdb_destroy_expression: ::std::option::Option<unsafe extern "C" fn(expr: *mut duckdb_expression)>,
+    pub duckdb_expression_return_type:
+        ::std::option::Option<unsafe extern "C" fn(expr: duckdb_expression) -> duckdb_logical_type>,
+    pub duckdb_expression_is_foldable: ::std::option::Option<unsafe extern "C" fn(expr: duckdb_expression) -> bool>,
+    pub duckdb_expression_fold: ::std::option::Option<
+        unsafe extern "C" fn(
+            context: duckdb_client_context,
+            expr: duckdb_expression,
+            out_value: *mut duckdb_value,
+        ) -> duckdb_error_data,
+    >,
+    pub duckdb_client_context_get_file_system:
+        ::std::option::Option<unsafe extern "C" fn(context: duckdb_client_context) -> duckdb_file_system>,
+    pub duckdb_destroy_file_system: ::std::option::Option<unsafe extern "C" fn(file_system: *mut duckdb_file_system)>,
+    pub duckdb_file_system_open: ::std::option::Option<
+        unsafe extern "C" fn(
+            file_system: duckdb_file_system,
+            path: *const ::std::os::raw::c_char,
+            options: duckdb_file_open_options,
+            out_file: *mut duckdb_file_handle,
+        ) -> duckdb_state,
+    >,
+    pub duckdb_file_system_error_data:
+        ::std::option::Option<unsafe extern "C" fn(file_system: duckdb_file_system) -> duckdb_error_data>,
+    pub duckdb_create_file_open_options: ::std::option::Option<unsafe extern "C" fn() -> duckdb_file_open_options>,
+    pub duckdb_file_open_options_set_flag: ::std::option::Option<
+        unsafe extern "C" fn(options: duckdb_file_open_options, flag: duckdb_file_flag, value: bool) -> duckdb_state,
+    >,
+    pub duckdb_destroy_file_open_options:
+        ::std::option::Option<unsafe extern "C" fn(options: *mut duckdb_file_open_options)>,
+    pub duckdb_destroy_file_handle: ::std::option::Option<unsafe extern "C" fn(file_handle: *mut duckdb_file_handle)>,
+    pub duckdb_file_handle_error_data:
+        ::std::option::Option<unsafe extern "C" fn(file_handle: duckdb_file_handle) -> duckdb_error_data>,
+    pub duckdb_file_handle_close:
+        ::std::option::Option<unsafe extern "C" fn(file_handle: duckdb_file_handle) -> duckdb_state>,
+    pub duckdb_file_handle_read: ::std::option::Option<
+        unsafe extern "C" fn(file_handle: duckdb_file_handle, buffer: *mut ::std::os::raw::c_void, size: i64) -> i64,
+    >,
+    pub duckdb_file_handle_write: ::std::option::Option<
+        unsafe extern "C" fn(file_handle: duckdb_file_handle, buffer: *const ::std::os::raw::c_void, size: i64) -> i64,
+    >,
+    pub duckdb_file_handle_seek:
+        ::std::option::Option<unsafe extern "C" fn(file_handle: duckdb_file_handle, position: i64) -> duckdb_state>,
+    pub duckdb_file_handle_tell: ::std::option::Option<unsafe extern "C" fn(file_handle: duckdb_file_handle) -> i64>,
+    pub duckdb_file_handle_sync:
+        ::std::option::Option<unsafe extern "C" fn(file_handle: duckdb_file_handle) -> duckdb_state>,
+    pub duckdb_file_handle_size: ::std::option::Option<unsafe extern "C" fn(file_handle: duckdb_file_handle) -> i64>,
+    pub duckdb_geometry_type_get_crs:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type) -> *mut ::std::os::raw::c_char>,
+    pub duckdb_create_log_storage: ::std::option::Option<unsafe extern "C" fn() -> duckdb_log_storage>,
+    pub duckdb_destroy_log_storage: ::std::option::Option<unsafe extern "C" fn(log_storage: *mut duckdb_log_storage)>,
+    pub duckdb_log_storage_set_write_log_entry: ::std::option::Option<
+        unsafe extern "C" fn(log_storage: duckdb_log_storage, function: duckdb_logger_write_log_entry_t),
+    >,
+    pub duckdb_log_storage_set_extra_data: ::std::option::Option<
+        unsafe extern "C" fn(
+            log_storage: duckdb_log_storage,
+            extra_data: *mut ::std::os::raw::c_void,
+            delete_callback: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_log_storage_set_name: ::std::option::Option<
+        unsafe extern "C" fn(log_storage: duckdb_log_storage, name: *const ::std::os::raw::c_char),
+    >,
+    pub duckdb_register_log_storage: ::std::option::Option<
+        unsafe extern "C" fn(database: duckdb_database, log_storage: duckdb_log_storage) -> duckdb_state,
+    >,
+    pub duckdb_client_context_get_connection_id:
+        ::std::option::Option<unsafe extern "C" fn(context: duckdb_client_context) -> idx_t>,
+    pub duckdb_destroy_client_context: ::std::option::Option<unsafe extern "C" fn(context: *mut duckdb_client_context)>,
+    pub duckdb_connection_get_client_context: ::std::option::Option<
+        unsafe extern "C" fn(connection: duckdb_connection, out_context: *mut duckdb_client_context),
+    >,
+    pub duckdb_get_table_names: ::std::option::Option<
+        unsafe extern "C" fn(
+            connection: duckdb_connection,
+            query: *const ::std::os::raw::c_char,
+            qualified: bool,
+        ) -> duckdb_value,
+    >,
+    pub duckdb_connection_get_arrow_options: ::std::option::Option<
+        unsafe extern "C" fn(connection: duckdb_connection, out_arrow_options: *mut duckdb_arrow_options),
+    >,
+    pub duckdb_destroy_arrow_options:
+        ::std::option::Option<unsafe extern "C" fn(arrow_options: *mut duckdb_arrow_options)>,
+    pub duckdb_prepared_statement_column_count:
+        ::std::option::Option<unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement) -> idx_t>,
+    pub duckdb_prepared_statement_column_name: ::std::option::Option<
+        unsafe extern "C" fn(
+            prepared_statement: duckdb_prepared_statement,
+            col_idx: idx_t,
+        ) -> *const ::std::os::raw::c_char,
+    >,
+    pub duckdb_prepared_statement_column_logical_type: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, col_idx: idx_t) -> duckdb_logical_type,
+    >,
+    pub duckdb_prepared_statement_column_type: ::std::option::Option<
+        unsafe extern "C" fn(prepared_statement: duckdb_prepared_statement, col_idx: idx_t) -> duckdb_type,
+    >,
+    pub duckdb_result_get_arrow_options:
+        ::std::option::Option<unsafe extern "C" fn(result: *mut duckdb_result) -> duckdb_arrow_options>,
+    pub duckdb_scalar_function_set_bind: ::std::option::Option<
+        unsafe extern "C" fn(scalar_function: duckdb_scalar_function, bind: duckdb_scalar_function_bind_t),
+    >,
+    pub duckdb_scalar_function_bind_set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, error: *const ::std::os::raw::c_char)>,
+    pub duckdb_scalar_function_get_client_context:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, out_context: *mut duckdb_client_context)>,
+    pub duckdb_scalar_function_set_bind_data: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_bind_info,
+            bind_data: *mut ::std::os::raw::c_void,
+            destroy: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_scalar_function_get_bind_data:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_scalar_function_bind_get_extra_info:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_scalar_function_bind_get_argument_count:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info) -> idx_t>,
+    pub duckdb_scalar_function_bind_get_argument:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, index: idx_t) -> duckdb_expression>,
+    pub duckdb_scalar_function_set_bind_data_copy:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, copy: duckdb_copy_callback_t)>,
+    pub duckdb_scalar_function_get_state:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_function_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_scalar_function_set_init: ::std::option::Option<
+        unsafe extern "C" fn(scalar_function: duckdb_scalar_function, init: duckdb_scalar_function_init_t),
+    >,
+    pub duckdb_scalar_function_init_set_error:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info, error: *const ::std::os::raw::c_char)>,
+    pub duckdb_scalar_function_init_set_state: ::std::option::Option<
+        unsafe extern "C" fn(
+            info: duckdb_init_info,
+            state: *mut ::std::os::raw::c_void,
+            destroy: duckdb_delete_callback_t,
+        ),
+    >,
+    pub duckdb_scalar_function_init_get_client_context:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info, out_context: *mut duckdb_client_context)>,
+    pub duckdb_scalar_function_init_get_bind_data:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_scalar_function_init_get_extra_info:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_init_info) -> *mut ::std::os::raw::c_void>,
+    pub duckdb_value_to_string:
+        ::std::option::Option<unsafe extern "C" fn(value: duckdb_value) -> *mut ::std::os::raw::c_char>,
+    pub duckdb_valid_utf8_check: ::std::option::Option<
+        unsafe extern "C" fn(str_: *const ::std::os::raw::c_char, len: idx_t) -> duckdb_error_data,
+    >,
+    pub duckdb_table_description_get_column_count:
+        ::std::option::Option<unsafe extern "C" fn(table_description: duckdb_table_description) -> idx_t>,
+    pub duckdb_table_description_get_column_type: ::std::option::Option<
+        unsafe extern "C" fn(table_description: duckdb_table_description, index: idx_t) -> duckdb_logical_type,
+    >,
+    pub duckdb_table_function_get_client_context:
+        ::std::option::Option<unsafe extern "C" fn(info: duckdb_bind_info, out_context: *mut duckdb_client_context)>,
+    pub duckdb_create_map_value: ::std::option::Option<
+        unsafe extern "C" fn(
+            map_type: duckdb_logical_type,
+            keys: *mut duckdb_value,
+            values: *mut duckdb_value,
+            entry_count: idx_t,
+        ) -> duckdb_value,
+    >,
+    pub duckdb_create_union_value: ::std::option::Option<
+        unsafe extern "C" fn(union_type: duckdb_logical_type, tag_index: idx_t, value: duckdb_value) -> duckdb_value,
+    >,
+    pub duckdb_create_time_ns: ::std::option::Option<unsafe extern "C" fn(input: duckdb_time_ns) -> duckdb_value>,
+    pub duckdb_get_time_ns: ::std::option::Option<unsafe extern "C" fn(val: duckdb_value) -> duckdb_time_ns>,
+    pub duckdb_create_vector:
+        ::std::option::Option<unsafe extern "C" fn(type_: duckdb_logical_type, capacity: idx_t) -> duckdb_vector>,
+    pub duckdb_destroy_vector: ::std::option::Option<unsafe extern "C" fn(vector: *mut duckdb_vector)>,
+    pub duckdb_slice_vector:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector, sel: duckdb_selection_vector, len: idx_t)>,
+    pub duckdb_vector_reference_value:
+        ::std::option::Option<unsafe extern "C" fn(vector: duckdb_vector, value: duckdb_value)>,
+    pub duckdb_vector_reference_vector:
+        ::std::option::Option<unsafe extern "C" fn(to_vector: duckdb_vector, from_vector: duckdb_vector)>,
+    pub duckdb_create_selection_vector:
+        ::std::option::Option<unsafe extern "C" fn(size: idx_t) -> duckdb_selection_vector>,
+    pub duckdb_destroy_selection_vector: ::std::option::Option<unsafe extern "C" fn(sel: duckdb_selection_vector)>,
+    pub duckdb_selection_vector_get_data_ptr:
+        ::std::option::Option<unsafe extern "C" fn(sel: duckdb_selection_vector) -> *mut sel_t>,
+    pub duckdb_vector_copy_sel: ::std::option::Option<
+        unsafe extern "C" fn(
+            src: duckdb_vector,
+            dst: duckdb_vector,
+            sel: duckdb_selection_vector,
+            src_count: idx_t,
+            src_offset: idx_t,
+            dst_offset: idx_t,
+        ),
+    >,
+    pub duckdb_unsafe_vector_assign_string_element_len: ::std::option::Option<
+        unsafe extern "C" fn(vector: duckdb_vector, index: idx_t, str_: *const ::std::os::raw::c_char, str_len: idx_t),
+    >,
+}
+static __DUCKDB_OPEN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_open(
+    path: *const ::std::os::raw::c_char,
+    out_database: *mut duckdb_database,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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(
+        path: *const ::std::os::raw::c_char,
+        out_database: *mut duckdb_database,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(path, out_database)
+}
+
+static __DUCKDB_OPEN_EXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_open_ext(
+    path: *const ::std::os::raw::c_char,
+    out_database: *mut duckdb_database,
+    config: duckdb_config,
+    out_error: *mut *mut ::std::os::raw::c_char,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_OPEN_EXT.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        path: *const ::std::os::raw::c_char,
+        out_database: *mut duckdb_database,
+        config: duckdb_config,
+        out_error: *mut *mut ::std::os::raw::c_char,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(path, out_database, config, out_error)
+}
+
+static __DUCKDB_CLOSE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_close(database: *mut duckdb_database) {
+    let function_ptr = __DUCKDB_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(database: *mut duckdb_database) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(database)
+}
+
+static __DUCKDB_CONNECT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_connect(
+    database: duckdb_database,
+    out_connection: *mut duckdb_connection,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_CONNECT.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        database: duckdb_database,
+        out_connection: *mut duckdb_connection,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(database, out_connection)
+}
+
+static __DUCKDB_INTERRUPT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_interrupt(connection: duckdb_connection) {
+    let function_ptr = __DUCKDB_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(connection: duckdb_connection) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(connection)
+}
+
+static __DUCKDB_QUERY_PROGRESS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_query_progress(
+    connection: duckdb_connection,
+) -> duckdb_query_progress_type {
+    let function_ptr = __DUCKDB_QUERY_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(
+        connection: duckdb_connection,
+    ) -> duckdb_query_progress_type = ::std::mem::transmute(function_ptr);
+    (fun)(connection)
+}
+
+static __DUCKDB_DISCONNECT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_disconnect(connection: *mut duckdb_connection) {
+    let function_ptr = __DUCKDB_DISCONNECT.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(connection: *mut duckdb_connection) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(connection)
+}
+
+static __DUCKDB_LIBRARY_VERSION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_library_version() -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_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() -> *const ::std::os::raw::c_char = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_CREATE_CONFIG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_config(out_config: *mut duckdb_config) -> duckdb_state {
+    let function_ptr = __DUCKDB_CREATE_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(out_config: *mut duckdb_config) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(out_config)
+}
+
+static __DUCKDB_CONFIG_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_config_count() -> usize {
+    let function_ptr = __DUCKDB_CONFIG_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() -> usize = ::std::mem::transmute(function_ptr);
+    (fun)()
+}
+
+static __DUCKDB_GET_CONFIG_FLAG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_config_flag(
+    index: usize,
+    out_name: *mut *const ::std::os::raw::c_char,
+    out_description: *mut *const ::std::os::raw::c_char,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_GET_CONFIG_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(
+        index: usize,
+        out_name: *mut *const ::std::os::raw::c_char,
+        out_description: *mut *const ::std::os::raw::c_char,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(index, out_name, out_description)
+}
+
+static __DUCKDB_SET_CONFIG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_set_config(
+    config: duckdb_config,
+    name: *const ::std::os::raw::c_char,
+    option: *const ::std::os::raw::c_char,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_SET_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(
+        config: duckdb_config,
+        name: *const ::std::os::raw::c_char,
+        option: *const ::std::os::raw::c_char,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(config, name, option)
+}
+
+static __DUCKDB_DESTROY_CONFIG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_config(config: *mut duckdb_config) {
+    let function_ptr = __DUCKDB_DESTROY_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(config: *mut duckdb_config) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(config)
+}
+
+static __DUCKDB_QUERY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_query(
+    connection: duckdb_connection,
+    query: *const ::std::os::raw::c_char,
+    out_result: *mut duckdb_result,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        out_result: *mut duckdb_result,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, query, out_result)
+}
+
+static __DUCKDB_DESTROY_RESULT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_result(result: *mut duckdb_result) {
+    let function_ptr = __DUCKDB_DESTROY_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(result: *mut duckdb_result) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_COLUMN_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_column_name(
+    result: *mut duckdb_result,
+    col: idx_t,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(result, col)
+}
+
+static __DUCKDB_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_column_type(result: *mut duckdb_result, col: idx_t) -> duckdb_type {
+    let function_ptr = __DUCKDB_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+    ) -> duckdb_type = ::std::mem::transmute(function_ptr);
+    (fun)(result, col)
+}
+
+static __DUCKDB_RESULT_STATEMENT_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_statement_type(
+    result: duckdb_result,
+) -> duckdb_statement_type {
+    let function_ptr = __DUCKDB_RESULT_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_result) -> duckdb_statement_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_COLUMN_LOGICAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_column_logical_type(
+    result: *mut duckdb_result,
+    col: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_COLUMN_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(result, col)
+}
+
+static __DUCKDB_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_column_count(result: *mut duckdb_result) -> idx_t {
+    let function_ptr = __DUCKDB_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(result: *mut duckdb_result) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_ROWS_CHANGED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_rows_changed(result: *mut duckdb_result) -> idx_t {
+    let function_ptr = __DUCKDB_ROWS_CHANGED
+        .load(::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_result) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_RESULT_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_error(
+    result: *mut duckdb_result,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_RESULT_ERROR
+        .load(::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_result,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(result)
+}
+
+static __DUCKDB_RESULT_ERROR_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_error_type(result: *mut duckdb_result) -> duckdb_error_type {
+    let function_ptr = __DUCKDB_RESULT_ERROR_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: *mut duckdb_result) -> duckdb_error_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_RESULT_RETURN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_return_type(result: duckdb_result) -> duckdb_result_type {
+    let function_ptr = __DUCKDB_RESULT_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(result: duckdb_result) -> duckdb_result_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_MALLOC: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_malloc(size: usize) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_MALLOC.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(size: usize) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(size)
+}
+
+static __DUCKDB_FREE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_free(ptr: *mut ::std::os::raw::c_void) {
+    let function_ptr = __DUCKDB_FREE.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(ptr)
+}
+
+static __DUCKDB_VECTOR_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_size() -> idx_t {
+    let function_ptr = __DUCKDB_VECTOR_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() -> idx_t = ::std::mem::transmute(function_ptr);
+    (fun)()
+}
+
+static __DUCKDB_STRING_IS_INLINED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_string_is_inlined(string: duckdb_string_t) -> bool {
+    let function_ptr = __DUCKDB_STRING_IS_INLINED
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(string: duckdb_string_t) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(string)
+}
+
+static __DUCKDB_STRING_T_LENGTH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_string_t_length(string: duckdb_string_t) -> u32 {
+    let function_ptr = __DUCKDB_STRING_T_LENGTH
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(string: duckdb_string_t) -> u32 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(string)
+}
+
+static __DUCKDB_STRING_T_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_string_t_data(
+    string: *mut duckdb_string_t,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_STRING_T_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(
+        string: *mut duckdb_string_t,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(string)
+}
+
+static __DUCKDB_FROM_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_from_date(date: duckdb_date) -> duckdb_date_struct {
+    let function_ptr = __DUCKDB_FROM_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(date: duckdb_date) -> duckdb_date_struct = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(date)
+}
+
+static __DUCKDB_TO_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_to_date(date: duckdb_date_struct) -> duckdb_date {
+    let function_ptr = __DUCKDB_TO_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(date: duckdb_date_struct) -> duckdb_date = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(date)
+}
+
+static __DUCKDB_IS_FINITE_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_is_finite_date(date: duckdb_date) -> bool {
+    let function_ptr = __DUCKDB_IS_FINITE_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(date: duckdb_date) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(date)
+}
+
+static __DUCKDB_FROM_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_from_time(time: duckdb_time) -> duckdb_time_struct {
+    let function_ptr = __DUCKDB_FROM_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(time: duckdb_time) -> duckdb_time_struct = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(time)
+}
+
+static __DUCKDB_CREATE_TIME_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_time_tz(micros: i64, offset: i32) -> duckdb_time_tz {
+    let function_ptr = __DUCKDB_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(micros: i64, offset: i32) -> duckdb_time_tz = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(micros, offset)
+}
+
+static __DUCKDB_FROM_TIME_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_from_time_tz(micros: duckdb_time_tz) -> duckdb_time_tz_struct {
+    let function_ptr = __DUCKDB_FROM_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(micros: duckdb_time_tz) -> duckdb_time_tz_struct = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(micros)
+}
+
+static __DUCKDB_TO_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_to_time(time: duckdb_time_struct) -> duckdb_time {
+    let function_ptr = __DUCKDB_TO_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(time: duckdb_time_struct) -> duckdb_time = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(time)
+}
+
+static __DUCKDB_FROM_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_from_timestamp(ts: duckdb_timestamp) -> duckdb_timestamp_struct {
+    let function_ptr = __DUCKDB_FROM_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(ts: duckdb_timestamp) -> duckdb_timestamp_struct = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(ts)
+}
+
+static __DUCKDB_TO_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_to_timestamp(ts: duckdb_timestamp_struct) -> duckdb_timestamp {
+    let function_ptr = __DUCKDB_TO_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(ts: duckdb_timestamp_struct) -> duckdb_timestamp = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(ts)
+}
+
+static __DUCKDB_IS_FINITE_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_is_finite_timestamp(ts: duckdb_timestamp) -> bool {
+    let function_ptr = __DUCKDB_IS_FINITE_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(ts: duckdb_timestamp) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(ts)
+}
+
+static __DUCKDB_HUGEINT_TO_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_hugeint_to_double(val: duckdb_hugeint) -> f64 {
+    let function_ptr = __DUCKDB_HUGEINT_TO_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(val: duckdb_hugeint) -> f64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_DOUBLE_TO_HUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_double_to_hugeint(val: f64) -> duckdb_hugeint {
+    let function_ptr = __DUCKDB_DOUBLE_TO_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(val: f64) -> duckdb_hugeint = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_UHUGEINT_TO_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_uhugeint_to_double(val: duckdb_uhugeint) -> f64 {
+    let function_ptr = __DUCKDB_UHUGEINT_TO_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(val: duckdb_uhugeint) -> f64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_DOUBLE_TO_UHUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_double_to_uhugeint(val: f64) -> duckdb_uhugeint {
+    let function_ptr = __DUCKDB_DOUBLE_TO_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(val: f64) -> duckdb_uhugeint = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_DOUBLE_TO_DECIMAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_double_to_decimal(
+    val: f64,
+    width: u8,
+    scale: u8,
+) -> duckdb_decimal {
+    let function_ptr = __DUCKDB_DOUBLE_TO_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(val: f64, width: u8, scale: u8) -> duckdb_decimal = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val, width, scale)
+}
+
+static __DUCKDB_DECIMAL_TO_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_decimal_to_double(val: duckdb_decimal) -> f64 {
+    let function_ptr = __DUCKDB_DECIMAL_TO_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(val: duckdb_decimal) -> f64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_PREPARE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_prepare(
+    connection: duckdb_connection,
+    query: *const ::std::os::raw::c_char,
+    out_prepared_statement: *mut duckdb_prepared_statement,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_PREPARE.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        out_prepared_statement: *mut duckdb_prepared_statement,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, query, out_prepared_statement)
+}
+
+static __DUCKDB_DESTROY_PREPARE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_prepare(
+    prepared_statement: *mut duckdb_prepared_statement,
+) {
+    let function_ptr = __DUCKDB_DESTROY_PREPARE
+        .load(::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_statement: *mut duckdb_prepared_statement) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(prepared_statement)
+}
+
+static __DUCKDB_PREPARE_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_prepare_error(
+    prepared_statement: duckdb_prepared_statement,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_PREPARE_ERROR
+        .load(::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_statement: duckdb_prepared_statement,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement)
+}
+
+static __DUCKDB_NPARAMS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_nparams(prepared_statement: duckdb_prepared_statement) -> idx_t {
+    let function_ptr = __DUCKDB_NPARAMS.load(::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_statement: duckdb_prepared_statement,
+    ) -> idx_t = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement)
+}
+
+static __DUCKDB_PARAMETER_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_parameter_name(
+    prepared_statement: duckdb_prepared_statement,
+    index: idx_t,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_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(
+        prepared_statement: duckdb_prepared_statement,
+        index: idx_t,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, index)
+}
+
+static __DUCKDB_PARAM_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_param_type(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+) -> duckdb_type {
+    let function_ptr = __DUCKDB_PARAM_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+    ) -> duckdb_type = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx)
+}
+
+static __DUCKDB_PARAM_LOGICAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_param_logical_type(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_PARAM_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx)
+}
+
+static __DUCKDB_CLEAR_BINDINGS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_clear_bindings(
+    prepared_statement: duckdb_prepared_statement,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_CLEAR_BINDINGS
+        .load(::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_statement: duckdb_prepared_statement,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement)
+}
+
+static __DUCKDB_PREPARED_STATEMENT_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_prepared_statement_type(
+    statement: duckdb_prepared_statement,
+) -> duckdb_statement_type {
+    let function_ptr = __DUCKDB_PREPARED_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(
+        statement: duckdb_prepared_statement,
+    ) -> duckdb_statement_type = ::std::mem::transmute(function_ptr);
+    (fun)(statement)
+}
+
+static __DUCKDB_BIND_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_value(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_value,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_value,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_PARAMETER_INDEX: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_parameter_index(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx_out: *mut idx_t,
+    name: *const ::std::os::raw::c_char,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_PARAMETER_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx_out: *mut idx_t,
+        name: *const ::std::os::raw::c_char,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx_out, name)
+}
+
+static __DUCKDB_BIND_BOOLEAN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_boolean(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: bool,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_BOOLEAN
+        .load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: bool,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_INT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_int8(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: i8,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_INT8.load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: i8,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_INT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_int16(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: i16,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_INT16.load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: i16,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_INT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_int32(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: i32,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_INT32.load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: i32,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_INT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_int64(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: i64,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_INT64.load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: i64,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_HUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_hugeint(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_hugeint,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_hugeint,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_UHUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_uhugeint(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_uhugeint,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_uhugeint,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_DECIMAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_decimal(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_decimal,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_decimal,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_UINT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_uint8(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: u8,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_UINT8.load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: u8,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_UINT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_uint16(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: u16,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_UINT16.load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: u16,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_UINT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_uint32(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: u32,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_UINT32.load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: u32,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_UINT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_uint64(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: u64,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_UINT64.load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: u64,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_FLOAT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_float(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: f32,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: f32,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_double(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: f64,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: f64,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_date(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_date,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_date,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_time(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_time,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_time,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_timestamp(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_timestamp,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_timestamp,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_TIMESTAMP_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_timestamp_tz(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_timestamp,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_timestamp,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_INTERVAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_interval(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: duckdb_interval,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: duckdb_interval,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_VARCHAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_varchar(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: *const ::std::os::raw::c_char,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: *const ::std::os::raw::c_char,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val)
+}
+
+static __DUCKDB_BIND_VARCHAR_LENGTH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_varchar_length(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    val: *const ::std::os::raw::c_char,
+    length: idx_t,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_VARCHAR_LENGTH
+        .load(::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_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        val: *const ::std::os::raw::c_char,
+        length: idx_t,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, val, length)
+}
+
+static __DUCKDB_BIND_BLOB: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_blob(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+    data: *const ::std::os::raw::c_void,
+    length: idx_t,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+        data: *const ::std::os::raw::c_void,
+        length: idx_t,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx, data, length)
+}
+
+static __DUCKDB_BIND_NULL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_null(
+    prepared_statement: duckdb_prepared_statement,
+    param_idx: idx_t,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_BIND_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(
+        prepared_statement: duckdb_prepared_statement,
+        param_idx: idx_t,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, param_idx)
+}
+
+static __DUCKDB_EXECUTE_PREPARED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_execute_prepared(
+    prepared_statement: duckdb_prepared_statement,
+    out_result: *mut duckdb_result,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_EXECUTE_PREPARED
+        .load(::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_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_result,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, out_result)
+}
+
+static __DUCKDB_EXTRACT_STATEMENTS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_extract_statements(
+    connection: duckdb_connection,
+    query: *const ::std::os::raw::c_char,
+    out_extracted_statements: *mut duckdb_extracted_statements,
+) -> idx_t {
+    let function_ptr = __DUCKDB_EXTRACT_STATEMENTS
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        out_extracted_statements: *mut duckdb_extracted_statements,
+    ) -> idx_t = ::std::mem::transmute(function_ptr);
+    (fun)(connection, query, out_extracted_statements)
+}
+
+static __DUCKDB_PREPARE_EXTRACTED_STATEMENT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_prepare_extracted_statement(
+    connection: duckdb_connection,
+    extracted_statements: duckdb_extracted_statements,
+    index: idx_t,
+    out_prepared_statement: *mut duckdb_prepared_statement,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_PREPARE_EXTRACTED_STATEMENT
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        connection: duckdb_connection,
+        extracted_statements: duckdb_extracted_statements,
+        index: idx_t,
+        out_prepared_statement: *mut duckdb_prepared_statement,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, extracted_statements, index, out_prepared_statement)
+}
+
+static __DUCKDB_EXTRACT_STATEMENTS_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_extract_statements_error(
+    extracted_statements: duckdb_extracted_statements,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_EXTRACT_STATEMENTS_ERROR
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        extracted_statements: duckdb_extracted_statements,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(extracted_statements)
+}
+
+static __DUCKDB_DESTROY_EXTRACTED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_extracted(
+    extracted_statements: *mut duckdb_extracted_statements,
+) {
+    let function_ptr = __DUCKDB_DESTROY_EXTRACTED
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        extracted_statements: *mut duckdb_extracted_statements,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(extracted_statements)
+}
+
+static __DUCKDB_PENDING_PREPARED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_pending_prepared(
+    prepared_statement: duckdb_prepared_statement,
+    out_result: *mut duckdb_pending_result,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_PENDING_PREPARED
+        .load(::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_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_pending_result,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, out_result)
+}
+
+static __DUCKDB_DESTROY_PENDING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_pending(pending_result: *mut duckdb_pending_result) {
+    let function_ptr = __DUCKDB_DESTROY_PENDING
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(pending_result: *mut duckdb_pending_result) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(pending_result)
+}
+
+static __DUCKDB_PENDING_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_pending_error(
+    pending_result: duckdb_pending_result,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_PENDING_ERROR
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        pending_result: duckdb_pending_result,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(pending_result)
+}
+
+static __DUCKDB_PENDING_EXECUTE_TASK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_pending_execute_task(
+    pending_result: duckdb_pending_result,
+) -> duckdb_pending_state {
+    let function_ptr = __DUCKDB_PENDING_EXECUTE_TASK
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        pending_result: duckdb_pending_result,
+    ) -> duckdb_pending_state = ::std::mem::transmute(function_ptr);
+    (fun)(pending_result)
+}
+
+static __DUCKDB_PENDING_EXECUTE_CHECK_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_pending_execute_check_state(
+    pending_result: duckdb_pending_result,
+) -> duckdb_pending_state {
+    let function_ptr = __DUCKDB_PENDING_EXECUTE_CHECK_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(
+        pending_result: duckdb_pending_result,
+    ) -> duckdb_pending_state = ::std::mem::transmute(function_ptr);
+    (fun)(pending_result)
+}
+
+static __DUCKDB_EXECUTE_PENDING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_execute_pending(
+    pending_result: duckdb_pending_result,
+    out_result: *mut duckdb_result,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_EXECUTE_PENDING
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        pending_result: duckdb_pending_result,
+        out_result: *mut duckdb_result,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(pending_result, out_result)
+}
+
+static __DUCKDB_PENDING_EXECUTION_IS_FINISHED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_pending_execution_is_finished(
+    pending_state: duckdb_pending_state,
+) -> bool {
+    let function_ptr = __DUCKDB_PENDING_EXECUTION_IS_FINISHED
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(pending_state: duckdb_pending_state) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(pending_state)
+}
+
+static __DUCKDB_DESTROY_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_value(value: *mut duckdb_value) {
+    let function_ptr = __DUCKDB_DESTROY_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(value: *mut duckdb_value) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value)
+}
+
+static __DUCKDB_CREATE_VARCHAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_varchar(
+    text: *const ::std::os::raw::c_char,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(text: *const ::std::os::raw::c_char) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(text)
+}
+
+static __DUCKDB_CREATE_VARCHAR_LENGTH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_varchar_length(
+    text: *const ::std::os::raw::c_char,
+    length: idx_t,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_VARCHAR_LENGTH
+        .load(::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 ::std::os::raw::c_char,
+        length: idx_t,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(text, length)
+}
+
+static __DUCKDB_CREATE_BOOL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_bool(input: bool) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: bool) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_INT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_int8(input: i8) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_INT8.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(input: i8) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_UINT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_uint8(input: u8) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_UINT8
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(input: u8) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_INT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_int16(input: i16) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_INT16
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(input: i16) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_UINT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_uint16(input: u16) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_UINT16
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(input: u16) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_INT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_int32(input: i32) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_INT32
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(input: i32) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_UINT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_uint32(input: u32) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_UINT32
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(input: u32) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_UINT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_uint64(input: u64) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_UINT64
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(input: u64) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_INT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_int64(val: i64) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_INT64
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: i64) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_CREATE_HUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_hugeint(input: duckdb_hugeint) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_hugeint) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_UHUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_uhugeint(input: duckdb_uhugeint) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_uhugeint) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_FLOAT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_float(input: f32) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: f32) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_double(input: f64) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: f64) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_date(input: duckdb_date) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_date) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_time(input: duckdb_time) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_time) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_TIME_TZ_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_time_tz_value(value: duckdb_time_tz) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_TIME_TZ_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(value: duckdb_time_tz) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value)
+}
+
+static __DUCKDB_CREATE_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_timestamp(input: duckdb_timestamp) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_timestamp) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_INTERVAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_interval(input: duckdb_interval) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_interval) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_BLOB: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_blob(data: *const u8, length: idx_t) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(data: *const u8, length: idx_t) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(data, length)
+}
+
+static __DUCKDB_CREATE_BIGNUM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_bignum(input: duckdb_bignum) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_bignum) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_DECIMAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_decimal(input: duckdb_decimal) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_decimal) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_BIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_bit(input: duckdb_bit) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_bit) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_UUID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_uuid(input: duckdb_uhugeint) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_uhugeint) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_GET_BOOL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_bool(val: duckdb_value) -> bool {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_INT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_int8(val: duckdb_value) -> i8 {
+    let function_ptr = __DUCKDB_GET_INT8.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> i8 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_UINT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_uint8(val: duckdb_value) -> u8 {
+    let function_ptr = __DUCKDB_GET_UINT8.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> u8 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_INT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_int16(val: duckdb_value) -> i16 {
+    let function_ptr = __DUCKDB_GET_INT16.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> i16 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_UINT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_uint16(val: duckdb_value) -> u16 {
+    let function_ptr = __DUCKDB_GET_UINT16.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> u16 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_INT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_int32(val: duckdb_value) -> i32 {
+    let function_ptr = __DUCKDB_GET_INT32.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> i32 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_UINT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_uint32(val: duckdb_value) -> u32 {
+    let function_ptr = __DUCKDB_GET_UINT32.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> u32 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_INT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_int64(val: duckdb_value) -> i64 {
+    let function_ptr = __DUCKDB_GET_INT64.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> i64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_UINT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_uint64(val: duckdb_value) -> u64 {
+    let function_ptr = __DUCKDB_GET_UINT64.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> u64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_HUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_hugeint(val: duckdb_value) -> duckdb_hugeint {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_hugeint = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_UHUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_uhugeint(val: duckdb_value) -> duckdb_uhugeint {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_uhugeint = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_FLOAT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_float(val: duckdb_value) -> f32 {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> f32 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_double(val: duckdb_value) -> f64 {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> f64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_date(val: duckdb_value) -> duckdb_date {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_date = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_time(val: duckdb_value) -> duckdb_time {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_time = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_TIME_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_time_tz(val: duckdb_value) -> duckdb_time_tz {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_time_tz = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_timestamp(val: duckdb_value) -> duckdb_timestamp {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_timestamp = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_INTERVAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_interval(val: duckdb_value) -> duckdb_interval {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_interval = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_VALUE_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_value_type(val: duckdb_value) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_GET_VALUE_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(val: duckdb_value) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_BLOB: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_blob(val: duckdb_value) -> duckdb_blob {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_blob = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_BIGNUM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_bignum(val: duckdb_value) -> duckdb_bignum {
+    let function_ptr = __DUCKDB_GET_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(val: duckdb_value) -> duckdb_bignum = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_DECIMAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_decimal(val: duckdb_value) -> duckdb_decimal {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_decimal = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_BIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_bit(val: duckdb_value) -> duckdb_bit {
+    let function_ptr = __DUCKDB_GET_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(val: duckdb_value) -> duckdb_bit = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_UUID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_uuid(val: duckdb_value) -> duckdb_uhugeint {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_uhugeint = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_VARCHAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_varchar(value: duckdb_value) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_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_value) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value)
+}
+
+static __DUCKDB_CREATE_STRUCT_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_struct_value(
+    type_: duckdb_logical_type,
+    values: *mut duckdb_value,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_STRUCT_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(
+        type_: duckdb_logical_type,
+        values: *mut duckdb_value,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(type_, values)
+}
+
+static __DUCKDB_CREATE_LIST_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_list_value(
+    type_: duckdb_logical_type,
+    values: *mut duckdb_value,
+    value_count: idx_t,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_LIST_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(
+        type_: duckdb_logical_type,
+        values: *mut duckdb_value,
+        value_count: idx_t,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(type_, values, value_count)
+}
+
+static __DUCKDB_CREATE_ARRAY_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_array_value(
+    type_: duckdb_logical_type,
+    values: *mut duckdb_value,
+    value_count: idx_t,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_ARRAY_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(
+        type_: duckdb_logical_type,
+        values: *mut duckdb_value,
+        value_count: idx_t,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(type_, values, value_count)
+}
+
+static __DUCKDB_GET_MAP_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_map_size(value: duckdb_value) -> idx_t {
+    let function_ptr = __DUCKDB_GET_MAP_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(value: duckdb_value) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value)
+}
+
+static __DUCKDB_GET_MAP_KEY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_map_key(value: duckdb_value, index: idx_t) -> duckdb_value {
+    let function_ptr = __DUCKDB_GET_MAP_KEY.load(::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_value, index: idx_t) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value, index)
+}
+
+static __DUCKDB_GET_MAP_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_map_value(value: duckdb_value, index: idx_t) -> duckdb_value {
+    let function_ptr = __DUCKDB_GET_MAP_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(value: duckdb_value, index: idx_t) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value, index)
+}
+
+static __DUCKDB_IS_NULL_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_is_null_value(value: duckdb_value) -> bool {
+    let function_ptr = __DUCKDB_IS_NULL_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(value: duckdb_value) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value)
+}
+
+static __DUCKDB_CREATE_NULL_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_null_value() -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_NULL_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() -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_GET_LIST_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_list_size(value: duckdb_value) -> idx_t {
+    let function_ptr = __DUCKDB_GET_LIST_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(value: duckdb_value) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value)
+}
+
+static __DUCKDB_GET_LIST_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_list_child(value: duckdb_value, index: idx_t) -> duckdb_value {
+    let function_ptr = __DUCKDB_GET_LIST_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_value, index: idx_t) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value, index)
+}
+
+static __DUCKDB_CREATE_ENUM_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_enum_value(
+    type_: duckdb_logical_type,
+    value: u64,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_ENUM_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(
+        type_: duckdb_logical_type,
+        value: u64,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(type_, value)
+}
+
+static __DUCKDB_GET_ENUM_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_enum_value(value: duckdb_value) -> u64 {
+    let function_ptr = __DUCKDB_GET_ENUM_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(value: duckdb_value) -> u64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value)
+}
+
+static __DUCKDB_GET_STRUCT_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_struct_child(
+    value: duckdb_value,
+    index: idx_t,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_GET_STRUCT_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_value, index: idx_t) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value, index)
+}
+
+static __DUCKDB_CREATE_LOGICAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_logical_type(type_: duckdb_type) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_CREATE_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(type_: duckdb_type) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_LOGICAL_TYPE_GET_ALIAS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_logical_type_get_alias(
+    type_: duckdb_logical_type,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_LOGICAL_TYPE_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(
+        type_: duckdb_logical_type,
+    ) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(type_)
+}
+
+static __DUCKDB_LOGICAL_TYPE_SET_ALIAS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_logical_type_set_alias(
+    type_: duckdb_logical_type,
+    alias: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_LOGICAL_TYPE_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(
+        type_: duckdb_logical_type,
+        alias: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(type_, alias)
+}
+
+static __DUCKDB_CREATE_LIST_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_list_type(
+    type_: duckdb_logical_type,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_CREATE_LIST_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_logical_type) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_CREATE_ARRAY_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_array_type(
+    type_: duckdb_logical_type,
+    array_size: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_CREATE_ARRAY_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_logical_type,
+        array_size: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(type_, array_size)
+}
+
+static __DUCKDB_CREATE_MAP_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_map_type(
+    key_type: duckdb_logical_type,
+    value_type: duckdb_logical_type,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_CREATE_MAP_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(
+        key_type: duckdb_logical_type,
+        value_type: duckdb_logical_type,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(key_type, value_type)
+}
+
+static __DUCKDB_CREATE_UNION_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_union_type(
+    member_types: *mut duckdb_logical_type,
+    member_names: *mut *const ::std::os::raw::c_char,
+    member_count: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_CREATE_UNION_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(
+        member_types: *mut duckdb_logical_type,
+        member_names: *mut *const ::std::os::raw::c_char,
+        member_count: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(member_types, member_names, member_count)
+}
+
+static __DUCKDB_CREATE_STRUCT_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_struct_type(
+    member_types: *mut duckdb_logical_type,
+    member_names: *mut *const ::std::os::raw::c_char,
+    member_count: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_CREATE_STRUCT_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(
+        member_types: *mut duckdb_logical_type,
+        member_names: *mut *const ::std::os::raw::c_char,
+        member_count: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(member_types, member_names, member_count)
+}
+
+static __DUCKDB_CREATE_ENUM_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_enum_type(
+    member_names: *mut *const ::std::os::raw::c_char,
+    member_count: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_CREATE_ENUM_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(
+        member_names: *mut *const ::std::os::raw::c_char,
+        member_count: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(member_names, member_count)
+}
+
+static __DUCKDB_CREATE_DECIMAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_decimal_type(width: u8, scale: u8) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_CREATE_DECIMAL_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(width: u8, scale: u8) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(width, scale)
+}
+
+static __DUCKDB_GET_TYPE_ID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_type_id(type_: duckdb_logical_type) -> duckdb_type {
+    let function_ptr = __DUCKDB_GET_TYPE_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_logical_type) -> duckdb_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_DECIMAL_WIDTH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_decimal_width(type_: duckdb_logical_type) -> u8 {
+    let function_ptr = __DUCKDB_DECIMAL_WIDTH
+        .load(::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_logical_type) -> u8 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_DECIMAL_SCALE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_decimal_scale(type_: duckdb_logical_type) -> u8 {
+    let function_ptr = __DUCKDB_DECIMAL_SCALE
+        .load(::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_logical_type) -> u8 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_DECIMAL_INTERNAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_decimal_internal_type(type_: duckdb_logical_type) -> duckdb_type {
+    let function_ptr = __DUCKDB_DECIMAL_INTERNAL_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_logical_type) -> duckdb_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_ENUM_INTERNAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_enum_internal_type(type_: duckdb_logical_type) -> duckdb_type {
+    let function_ptr = __DUCKDB_ENUM_INTERNAL_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_logical_type) -> duckdb_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_ENUM_DICTIONARY_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_enum_dictionary_size(type_: duckdb_logical_type) -> u32 {
+    let function_ptr = __DUCKDB_ENUM_DICTIONARY_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(type_: duckdb_logical_type) -> u32 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_ENUM_DICTIONARY_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_enum_dictionary_value(
+    type_: duckdb_logical_type,
+    index: idx_t,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_ENUM_DICTIONARY_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(
+        type_: duckdb_logical_type,
+        index: idx_t,
+    ) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(type_, index)
+}
+
+static __DUCKDB_LIST_TYPE_CHILD_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_list_type_child_type(
+    type_: duckdb_logical_type,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_LIST_TYPE_CHILD_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_logical_type) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_ARRAY_TYPE_CHILD_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_array_type_child_type(
+    type_: duckdb_logical_type,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_ARRAY_TYPE_CHILD_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_logical_type) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_ARRAY_TYPE_ARRAY_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_array_type_array_size(type_: duckdb_logical_type) -> idx_t {
+    let function_ptr = __DUCKDB_ARRAY_TYPE_ARRAY_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(type_: duckdb_logical_type) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_MAP_TYPE_KEY_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_map_type_key_type(
+    type_: duckdb_logical_type,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_MAP_TYPE_KEY_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_logical_type) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_MAP_TYPE_VALUE_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_map_type_value_type(
+    type_: duckdb_logical_type,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_MAP_TYPE_VALUE_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_logical_type) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_STRUCT_TYPE_CHILD_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_struct_type_child_count(type_: duckdb_logical_type) -> idx_t {
+    let function_ptr = __DUCKDB_STRUCT_TYPE_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(type_: duckdb_logical_type) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_STRUCT_TYPE_CHILD_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_struct_type_child_name(
+    type_: duckdb_logical_type,
+    index: idx_t,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_STRUCT_TYPE_CHILD_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_logical_type,
+        index: idx_t,
+    ) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(type_, index)
+}
+
+static __DUCKDB_STRUCT_TYPE_CHILD_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_struct_type_child_type(
+    type_: duckdb_logical_type,
+    index: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_STRUCT_TYPE_CHILD_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_logical_type,
+        index: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(type_, index)
+}
+
+static __DUCKDB_UNION_TYPE_MEMBER_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_union_type_member_count(type_: duckdb_logical_type) -> idx_t {
+    let function_ptr = __DUCKDB_UNION_TYPE_MEMBER_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_logical_type) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_UNION_TYPE_MEMBER_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_union_type_member_name(
+    type_: duckdb_logical_type,
+    index: idx_t,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_UNION_TYPE_MEMBER_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_logical_type,
+        index: idx_t,
+    ) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(type_, index)
+}
+
+static __DUCKDB_UNION_TYPE_MEMBER_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_union_type_member_type(
+    type_: duckdb_logical_type,
+    index: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_UNION_TYPE_MEMBER_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_logical_type,
+        index: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(type_, index)
+}
+
+static __DUCKDB_DESTROY_LOGICAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_logical_type(type_: *mut duckdb_logical_type) {
+    let function_ptr = __DUCKDB_DESTROY_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(type_: *mut duckdb_logical_type) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(type_)
+}
+
+static __DUCKDB_REGISTER_LOGICAL_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_logical_type(
+    con: duckdb_connection,
+    type_: duckdb_logical_type,
+    info: duckdb_create_type_info,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_REGISTER_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(
+        con: duckdb_connection,
+        type_: duckdb_logical_type,
+        info: duckdb_create_type_info,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(con, type_, info)
+}
+
+static __DUCKDB_CREATE_DATA_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_data_chunk(
+    types: *mut duckdb_logical_type,
+    column_count: idx_t,
+) -> duckdb_data_chunk {
+    let function_ptr = __DUCKDB_CREATE_DATA_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(
+        types: *mut duckdb_logical_type,
+        column_count: idx_t,
+    ) -> duckdb_data_chunk = ::std::mem::transmute(function_ptr);
+    (fun)(types, column_count)
+}
+
+static __DUCKDB_DESTROY_DATA_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_data_chunk(chunk: *mut duckdb_data_chunk) {
+    let function_ptr = __DUCKDB_DESTROY_DATA_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(chunk: *mut duckdb_data_chunk) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(chunk)
+}
+
+static __DUCKDB_DATA_CHUNK_RESET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_data_chunk_reset(chunk: duckdb_data_chunk) {
+    let function_ptr = __DUCKDB_DATA_CHUNK_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(chunk: duckdb_data_chunk) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(chunk)
+}
+
+static __DUCKDB_DATA_CHUNK_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_data_chunk_get_column_count(chunk: duckdb_data_chunk) -> idx_t {
+    let function_ptr = __DUCKDB_DATA_CHUNK_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(chunk: duckdb_data_chunk) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(chunk)
+}
+
+static __DUCKDB_DATA_CHUNK_GET_VECTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_data_chunk_get_vector(
+    chunk: duckdb_data_chunk,
+    col_idx: idx_t,
+) -> duckdb_vector {
+    let function_ptr = __DUCKDB_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_data_chunk,
+        col_idx: idx_t,
+    ) -> duckdb_vector = ::std::mem::transmute(function_ptr);
+    (fun)(chunk, col_idx)
+}
+
+static __DUCKDB_DATA_CHUNK_GET_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_data_chunk_get_size(chunk: duckdb_data_chunk) -> idx_t {
+    let function_ptr = __DUCKDB_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_data_chunk) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(chunk)
+}
+
+static __DUCKDB_DATA_CHUNK_SET_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_data_chunk_set_size(chunk: duckdb_data_chunk, size: idx_t) {
+    let function_ptr = __DUCKDB_DATA_CHUNK_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(chunk: duckdb_data_chunk, size: idx_t) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(chunk, size)
+}
+
+static __DUCKDB_VECTOR_GET_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_get_column_type(
+    vector: duckdb_vector,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_VECTOR_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(vector: duckdb_vector) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector)
+}
+
+static __DUCKDB_VECTOR_GET_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_get_data(
+    vector: duckdb_vector,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_VECTOR_GET_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(
+        vector: duckdb_vector,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(vector)
+}
+
+static __DUCKDB_VECTOR_GET_VALIDITY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_get_validity(vector: duckdb_vector) -> *mut u64 {
+    let function_ptr = __DUCKDB_VECTOR_GET_VALIDITY
+        .load(::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_vector) -> *mut u64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector)
+}
+
+static __DUCKDB_VECTOR_ENSURE_VALIDITY_WRITABLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_ensure_validity_writable(vector: duckdb_vector) {
+    let function_ptr = __DUCKDB_VECTOR_ENSURE_VALIDITY_WRITABLE
+        .load(::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_vector) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector)
+}
+
+static __DUCKDB_VECTOR_ASSIGN_STRING_ELEMENT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_assign_string_element(
+    vector: duckdb_vector,
+    index: idx_t,
+    str_: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_VECTOR_ASSIGN_STRING_ELEMENT
+        .load(::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_vector,
+        index: idx_t,
+        str_: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(vector, index, str_)
+}
+
+static __DUCKDB_VECTOR_ASSIGN_STRING_ELEMENT_LEN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_assign_string_element_len(
+    vector: duckdb_vector,
+    index: idx_t,
+    str_: *const ::std::os::raw::c_char,
+    str_len: idx_t,
+) {
+    let function_ptr = __DUCKDB_VECTOR_ASSIGN_STRING_ELEMENT_LEN
+        .load(::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_vector,
+        index: idx_t,
+        str_: *const ::std::os::raw::c_char,
+        str_len: idx_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(vector, index, str_, str_len)
+}
+
+static __DUCKDB_LIST_VECTOR_GET_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_list_vector_get_child(vector: duckdb_vector) -> duckdb_vector {
+    let function_ptr = __DUCKDB_LIST_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_vector) -> duckdb_vector = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector)
+}
+
+static __DUCKDB_LIST_VECTOR_GET_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_list_vector_get_size(vector: duckdb_vector) -> idx_t {
+    let function_ptr = __DUCKDB_LIST_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_vector) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector)
+}
+
+static __DUCKDB_LIST_VECTOR_SET_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_list_vector_set_size(
+    vector: duckdb_vector,
+    size: idx_t,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_LIST_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_vector, size: idx_t) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector, size)
+}
+
+static __DUCKDB_LIST_VECTOR_RESERVE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_list_vector_reserve(
+    vector: duckdb_vector,
+    required_capacity: idx_t,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_LIST_VECTOR_RESERVE
+        .load(::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_vector,
+        required_capacity: idx_t,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(vector, required_capacity)
+}
+
+static __DUCKDB_STRUCT_VECTOR_GET_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_struct_vector_get_child(
+    vector: duckdb_vector,
+    index: idx_t,
+) -> duckdb_vector {
+    let function_ptr = __DUCKDB_STRUCT_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_vector,
+        index: idx_t,
+    ) -> duckdb_vector = ::std::mem::transmute(function_ptr);
+    (fun)(vector, index)
+}
+
+static __DUCKDB_ARRAY_VECTOR_GET_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_array_vector_get_child(vector: duckdb_vector) -> duckdb_vector {
+    let function_ptr = __DUCKDB_ARRAY_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_vector) -> duckdb_vector = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector)
+}
+
+static __DUCKDB_VALIDITY_ROW_IS_VALID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_validity_row_is_valid(validity: *mut u64, row: idx_t) -> bool {
+    let function_ptr = __DUCKDB_VALIDITY_ROW_IS_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(validity: *mut u64, row: idx_t) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(validity, row)
+}
+
+static __DUCKDB_VALIDITY_SET_ROW_VALIDITY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_validity_set_row_validity(
+    validity: *mut u64,
+    row: idx_t,
+    valid: bool,
+) {
+    let function_ptr = __DUCKDB_VALIDITY_SET_ROW_VALIDITY
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(validity: *mut u64, row: idx_t, valid: bool) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(validity, row, valid)
+}
+
+static __DUCKDB_VALIDITY_SET_ROW_INVALID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_validity_set_row_invalid(validity: *mut u64, row: idx_t) {
+    let function_ptr = __DUCKDB_VALIDITY_SET_ROW_INVALID
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(validity: *mut u64, row: idx_t) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(validity, row)
+}
+
+static __DUCKDB_VALIDITY_SET_ROW_VALID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_validity_set_row_valid(validity: *mut u64, row: idx_t) {
+    let function_ptr = __DUCKDB_VALIDITY_SET_ROW_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(validity: *mut u64, row: idx_t) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(validity, row)
+}
+
+static __DUCKDB_CREATE_SCALAR_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_scalar_function() -> duckdb_scalar_function {
+    let function_ptr = __DUCKDB_CREATE_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() -> duckdb_scalar_function = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_DESTROY_SCALAR_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_scalar_function(
+    scalar_function: *mut duckdb_scalar_function,
+) {
+    let function_ptr = __DUCKDB_DESTROY_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(scalar_function: *mut duckdb_scalar_function) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(scalar_function)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_name(
+    scalar_function: duckdb_scalar_function,
+    name: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_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(
+        scalar_function: duckdb_scalar_function,
+        name: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function, name)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_VARARGS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_varargs(
+    scalar_function: duckdb_scalar_function,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_VARARGS
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        scalar_function: duckdb_scalar_function,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function, type_)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_SPECIAL_HANDLING: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_scalar_function_set_special_handling(
+    scalar_function: duckdb_scalar_function,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_SPECIAL_HANDLING
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(scalar_function: duckdb_scalar_function) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(scalar_function)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_VOLATILE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_volatile(
+    scalar_function: duckdb_scalar_function,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_VOLATILE
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(scalar_function: duckdb_scalar_function) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(scalar_function)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_ADD_PARAMETER: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_add_parameter(
+    scalar_function: duckdb_scalar_function,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_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(
+        scalar_function: duckdb_scalar_function,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function, type_)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_RETURN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_return_type(
+    scalar_function: duckdb_scalar_function,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_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(
+        scalar_function: duckdb_scalar_function,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function, type_)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_extra_info(
+    scalar_function: duckdb_scalar_function,
+    extra_info: *mut ::std::os::raw::c_void,
+    destroy: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_EXTRA_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(
+        scalar_function: duckdb_scalar_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function, extra_info, destroy)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_function(
+    scalar_function: duckdb_scalar_function,
+    function: duckdb_scalar_function_t,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_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(
+        scalar_function: duckdb_scalar_function,
+        function: duckdb_scalar_function_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function, function)
+}
+
+static __DUCKDB_REGISTER_SCALAR_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_scalar_function(
+    con: duckdb_connection,
+    scalar_function: duckdb_scalar_function,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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(
+        con: duckdb_connection,
+        scalar_function: duckdb_scalar_function,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(con, scalar_function)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_get_extra_info(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_GET_EXTRA_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_error(
+    info: duckdb_function_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_ERROR
+        .load(::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_function_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_CREATE_SCALAR_FUNCTION_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_scalar_function_set(
+    name: *const ::std::os::raw::c_char,
+) -> duckdb_scalar_function_set {
+    let function_ptr = __DUCKDB_CREATE_SCALAR_FUNCTION_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(
+        name: *const ::std::os::raw::c_char,
+    ) -> duckdb_scalar_function_set = ::std::mem::transmute(function_ptr);
+    (fun)(name)
+}
+
+static __DUCKDB_DESTROY_SCALAR_FUNCTION_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_scalar_function_set(
+    scalar_function_set: *mut duckdb_scalar_function_set,
+) {
+    let function_ptr = __DUCKDB_DESTROY_SCALAR_FUNCTION_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(
+        scalar_function_set: *mut duckdb_scalar_function_set,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function_set)
+}
+
+static __DUCKDB_ADD_SCALAR_FUNCTION_TO_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_add_scalar_function_to_set(
+    set: duckdb_scalar_function_set,
+    function: duckdb_scalar_function,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_ADD_SCALAR_FUNCTION_TO_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(
+        set: duckdb_scalar_function_set,
+        function: duckdb_scalar_function,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(set, function)
+}
+
+static __DUCKDB_REGISTER_SCALAR_FUNCTION_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_scalar_function_set(
+    con: duckdb_connection,
+    set: duckdb_scalar_function_set,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_REGISTER_SCALAR_FUNCTION_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(
+        con: duckdb_connection,
+        set: duckdb_scalar_function_set,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(con, set)
+}
+
+static __DUCKDB_CREATE_AGGREGATE_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_aggregate_function() -> duckdb_aggregate_function {
+    let function_ptr = __DUCKDB_CREATE_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() -> duckdb_aggregate_function = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_DESTROY_AGGREGATE_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_aggregate_function(
+    aggregate_function: *mut duckdb_aggregate_function,
+) {
+    let function_ptr = __DUCKDB_DESTROY_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(aggregate_function: *mut duckdb_aggregate_function) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(aggregate_function)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_aggregate_function_set_name(
+    aggregate_function: duckdb_aggregate_function,
+    name: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_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(
+        aggregate_function: duckdb_aggregate_function,
+        name: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(aggregate_function, name)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_ADD_PARAMETER: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_aggregate_function_add_parameter(
+    aggregate_function: duckdb_aggregate_function,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_AGGREGATE_FUNCTION_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(
+        aggregate_function: duckdb_aggregate_function,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(aggregate_function, type_)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_SET_RETURN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_aggregate_function_set_return_type(
+    aggregate_function: duckdb_aggregate_function,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_AGGREGATE_FUNCTION_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(
+        aggregate_function: duckdb_aggregate_function,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(aggregate_function, type_)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_SET_FUNCTIONS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_aggregate_function_set_functions(
+    aggregate_function: duckdb_aggregate_function,
+    state_size: duckdb_aggregate_state_size,
+    state_init: duckdb_aggregate_init_t,
+    update: duckdb_aggregate_update_t,
+    combine: duckdb_aggregate_combine_t,
+    finalize: duckdb_aggregate_finalize_t,
+) {
+    let function_ptr = __DUCKDB_AGGREGATE_FUNCTION_SET_FUNCTIONS
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        aggregate_function: duckdb_aggregate_function,
+        state_size: duckdb_aggregate_state_size,
+        state_init: duckdb_aggregate_init_t,
+        update: duckdb_aggregate_update_t,
+        combine: duckdb_aggregate_combine_t,
+        finalize: duckdb_aggregate_finalize_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(aggregate_function, state_size, state_init, update, combine, finalize)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_SET_DESTRUCTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_aggregate_function_set_destructor(
+    aggregate_function: duckdb_aggregate_function,
+    destroy: duckdb_aggregate_destroy_t,
+) {
+    let function_ptr = __DUCKDB_AGGREGATE_FUNCTION_SET_DESTRUCTOR
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        aggregate_function: duckdb_aggregate_function,
+        destroy: duckdb_aggregate_destroy_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(aggregate_function, destroy)
+}
+
+static __DUCKDB_REGISTER_AGGREGATE_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_aggregate_function(
+    con: duckdb_connection,
+    aggregate_function: duckdb_aggregate_function,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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(
+        con: duckdb_connection,
+        aggregate_function: duckdb_aggregate_function,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(con, aggregate_function)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_SET_SPECIAL_HANDLING: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_aggregate_function_set_special_handling(
+    aggregate_function: duckdb_aggregate_function,
+) {
+    let function_ptr = __DUCKDB_AGGREGATE_FUNCTION_SET_SPECIAL_HANDLING
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(aggregate_function: duckdb_aggregate_function) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(aggregate_function)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_SET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_aggregate_function_set_extra_info(
+    aggregate_function: duckdb_aggregate_function,
+    extra_info: *mut ::std::os::raw::c_void,
+    destroy: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_AGGREGATE_FUNCTION_SET_EXTRA_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(
+        aggregate_function: duckdb_aggregate_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(aggregate_function, extra_info, destroy)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_aggregate_function_get_extra_info(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_AGGREGATE_FUNCTION_GET_EXTRA_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_AGGREGATE_FUNCTION_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_aggregate_function_set_error(
+    info: duckdb_function_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_AGGREGATE_FUNCTION_SET_ERROR
+        .load(::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_function_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_CREATE_AGGREGATE_FUNCTION_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_aggregate_function_set(
+    name: *const ::std::os::raw::c_char,
+) -> duckdb_aggregate_function_set {
+    let function_ptr = __DUCKDB_CREATE_AGGREGATE_FUNCTION_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(
+        name: *const ::std::os::raw::c_char,
+    ) -> duckdb_aggregate_function_set = ::std::mem::transmute(function_ptr);
+    (fun)(name)
+}
+
+static __DUCKDB_DESTROY_AGGREGATE_FUNCTION_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_aggregate_function_set(
+    aggregate_function_set: *mut duckdb_aggregate_function_set,
+) {
+    let function_ptr = __DUCKDB_DESTROY_AGGREGATE_FUNCTION_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(
+        aggregate_function_set: *mut duckdb_aggregate_function_set,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(aggregate_function_set)
+}
+
+static __DUCKDB_ADD_AGGREGATE_FUNCTION_TO_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_add_aggregate_function_to_set(
+    set: duckdb_aggregate_function_set,
+    function: duckdb_aggregate_function,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_ADD_AGGREGATE_FUNCTION_TO_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(
+        set: duckdb_aggregate_function_set,
+        function: duckdb_aggregate_function,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(set, function)
+}
+
+static __DUCKDB_REGISTER_AGGREGATE_FUNCTION_SET: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_aggregate_function_set(
+    con: duckdb_connection,
+    set: duckdb_aggregate_function_set,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_REGISTER_AGGREGATE_FUNCTION_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(
+        con: duckdb_connection,
+        set: duckdb_aggregate_function_set,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(con, set)
+}
+
+static __DUCKDB_CREATE_TABLE_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_table_function() -> duckdb_table_function {
+    let function_ptr = __DUCKDB_CREATE_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() -> duckdb_table_function = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_DESTROY_TABLE_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_table_function(table_function: *mut duckdb_table_function) {
+    let function_ptr = __DUCKDB_DESTROY_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(table_function: *mut duckdb_table_function) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(table_function)
+}
+
+static __DUCKDB_TABLE_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_set_name(
+    table_function: duckdb_table_function,
+    name: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_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(
+        table_function: duckdb_table_function,
+        name: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, name)
+}
+
+static __DUCKDB_TABLE_FUNCTION_ADD_PARAMETER: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_add_parameter(
+    table_function: duckdb_table_function,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_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(
+        table_function: duckdb_table_function,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, type_)
+}
+
+static __DUCKDB_TABLE_FUNCTION_ADD_NAMED_PARAMETER: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_add_named_parameter(
+    table_function: duckdb_table_function,
+    name: *const ::std::os::raw::c_char,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_ADD_NAMED_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(
+        table_function: duckdb_table_function,
+        name: *const ::std::os::raw::c_char,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, name, type_)
+}
+
+static __DUCKDB_TABLE_FUNCTION_SET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_set_extra_info(
+    table_function: duckdb_table_function,
+    extra_info: *mut ::std::os::raw::c_void,
+    destroy: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_SET_EXTRA_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(
+        table_function: duckdb_table_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, extra_info, destroy)
+}
+
+static __DUCKDB_TABLE_FUNCTION_SET_BIND: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_set_bind(
+    table_function: duckdb_table_function,
+    bind: duckdb_table_function_bind_t,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_SET_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(
+        table_function: duckdb_table_function,
+        bind: duckdb_table_function_bind_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, bind)
+}
+
+static __DUCKDB_TABLE_FUNCTION_SET_INIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_set_init(
+    table_function: duckdb_table_function,
+    init: duckdb_table_function_init_t,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_SET_INIT
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        table_function: duckdb_table_function,
+        init: duckdb_table_function_init_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, init)
+}
+
+static __DUCKDB_TABLE_FUNCTION_SET_LOCAL_INIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_set_local_init(
+    table_function: duckdb_table_function,
+    init: duckdb_table_function_init_t,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_SET_LOCAL_INIT
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        table_function: duckdb_table_function,
+        init: duckdb_table_function_init_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, init)
+}
+
+static __DUCKDB_TABLE_FUNCTION_SET_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_set_function(
+    table_function: duckdb_table_function,
+    function: duckdb_table_function_t,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_SET_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(
+        table_function: duckdb_table_function,
+        function: duckdb_table_function_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, function)
+}
+
+static __DUCKDB_TABLE_FUNCTION_SUPPORTS_PROJECTION_PUSHDOWN: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_table_function_supports_projection_pushdown(
+    table_function: duckdb_table_function,
+    pushdown: bool,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_SUPPORTS_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(
+        table_function: duckdb_table_function,
+        pushdown: bool,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(table_function, pushdown)
+}
+
+static __DUCKDB_REGISTER_TABLE_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_table_function(
+    con: duckdb_connection,
+    function: duckdb_table_function,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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(
+        con: duckdb_connection,
+        function: duckdb_table_function,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(con, function)
+}
+
+static __DUCKDB_BIND_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_get_extra_info(
+    info: duckdb_bind_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_BIND_GET_EXTRA_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_bind_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_BIND_ADD_RESULT_COLUMN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_add_result_column(
+    info: duckdb_bind_info,
+    name: *const ::std::os::raw::c_char,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_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_bind_info,
+        name: *const ::std::os::raw::c_char,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, name, type_)
+}
+
+static __DUCKDB_BIND_GET_PARAMETER_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_get_parameter_count(info: duckdb_bind_info) -> idx_t {
+    let function_ptr = __DUCKDB_BIND_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(info: duckdb_bind_info) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info)
+}
+
+static __DUCKDB_BIND_GET_PARAMETER: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_get_parameter(
+    info: duckdb_bind_info,
+    index: idx_t,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_BIND_GET_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(
+        info: duckdb_bind_info,
+        index: idx_t,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(info, index)
+}
+
+static __DUCKDB_BIND_GET_NAMED_PARAMETER: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_get_named_parameter(
+    info: duckdb_bind_info,
+    name: *const ::std::os::raw::c_char,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_BIND_GET_NAMED_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(
+        info: duckdb_bind_info,
+        name: *const ::std::os::raw::c_char,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(info, name)
+}
+
+static __DUCKDB_BIND_SET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_set_bind_data(
+    info: duckdb_bind_info,
+    bind_data: *mut ::std::os::raw::c_void,
+    destroy: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_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_bind_info,
+        bind_data: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, bind_data, destroy)
+}
+
+static __DUCKDB_BIND_SET_CARDINALITY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_set_cardinality(
+    info: duckdb_bind_info,
+    cardinality: idx_t,
+    is_exact: bool,
+) {
+    let function_ptr = __DUCKDB_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_bind_info,
+        cardinality: idx_t,
+        is_exact: bool,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, cardinality, is_exact)
+}
+
+static __DUCKDB_BIND_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_bind_set_error(
+    info: duckdb_bind_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_BIND_SET_ERROR
+        .load(::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_bind_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_INIT_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_init_get_extra_info(
+    info: duckdb_init_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_INIT_GET_EXTRA_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_init_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_INIT_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_init_get_bind_data(
+    info: duckdb_init_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_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_init_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_INIT_SET_INIT_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_init_set_init_data(
+    info: duckdb_init_info,
+    init_data: *mut ::std::os::raw::c_void,
+    destroy: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_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_init_info,
+        init_data: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, init_data, destroy)
+}
+
+static __DUCKDB_INIT_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_init_get_column_count(info: duckdb_init_info) -> idx_t {
+    let function_ptr = __DUCKDB_INIT_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_init_info) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info)
+}
+
+static __DUCKDB_INIT_GET_COLUMN_INDEX: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_init_get_column_index(
+    info: duckdb_init_info,
+    column_index: idx_t,
+) -> idx_t {
+    let function_ptr = __DUCKDB_INIT_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_init_info,
+        column_index: idx_t,
+    ) -> idx_t = ::std::mem::transmute(function_ptr);
+    (fun)(info, column_index)
+}
+
+static __DUCKDB_INIT_SET_MAX_THREADS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_init_set_max_threads(info: duckdb_init_info, max_threads: idx_t) {
+    let function_ptr = __DUCKDB_INIT_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_init_info, max_threads: idx_t) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info, max_threads)
+}
+
+static __DUCKDB_INIT_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_init_set_error(
+    info: duckdb_init_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_INIT_SET_ERROR
+        .load(::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_init_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_FUNCTION_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_function_get_extra_info(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_FUNCTION_GET_EXTRA_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_FUNCTION_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_function_get_bind_data(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_FUNCTION_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_FUNCTION_GET_INIT_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_function_get_init_data(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_FUNCTION_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_FUNCTION_GET_LOCAL_INIT_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_function_get_local_init_data(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_FUNCTION_GET_LOCAL_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_FUNCTION_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_function_set_error(
+    info: duckdb_function_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_FUNCTION_SET_ERROR
+        .load(::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_function_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_ADD_REPLACEMENT_SCAN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_add_replacement_scan(
+    db: duckdb_database,
+    replacement: duckdb_replacement_callback_t,
+    extra_data: *mut ::std::os::raw::c_void,
+    delete_callback: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_ADD_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(
+        db: duckdb_database,
+        replacement: duckdb_replacement_callback_t,
+        extra_data: *mut ::std::os::raw::c_void,
+        delete_callback: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(db, replacement, extra_data, delete_callback)
+}
+
+static __DUCKDB_REPLACEMENT_SCAN_SET_FUNCTION_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_replacement_scan_set_function_name(
+    info: duckdb_replacement_scan_info,
+    function_name: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_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_replacement_scan_info,
+        function_name: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, function_name)
+}
+
+static __DUCKDB_REPLACEMENT_SCAN_ADD_PARAMETER: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_replacement_scan_add_parameter(
+    info: duckdb_replacement_scan_info,
+    parameter: duckdb_value,
+) {
+    let function_ptr = __DUCKDB_REPLACEMENT_SCAN_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(
+        info: duckdb_replacement_scan_info,
+        parameter: duckdb_value,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, parameter)
+}
+
+static __DUCKDB_REPLACEMENT_SCAN_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_replacement_scan_set_error(
+    info: duckdb_replacement_scan_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_REPLACEMENT_SCAN_SET_ERROR
+        .load(::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_replacement_scan_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_PROFILING_INFO_GET_METRICS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_profiling_info_get_metrics(
+    info: duckdb_profiling_info,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_PROFILING_INFO_GET_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(info: duckdb_profiling_info) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info)
+}
+
+static __DUCKDB_PROFILING_INFO_GET_CHILD_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_profiling_info_get_child_count(
+    info: duckdb_profiling_info,
+) -> idx_t {
+    let function_ptr = __DUCKDB_PROFILING_INFO_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(info: duckdb_profiling_info) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info)
+}
+
+static __DUCKDB_PROFILING_INFO_GET_CHILD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_profiling_info_get_child(
+    info: duckdb_profiling_info,
+    index: idx_t,
+) -> duckdb_profiling_info {
+    let function_ptr = __DUCKDB_PROFILING_INFO_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(
+        info: duckdb_profiling_info,
+        index: idx_t,
+    ) -> duckdb_profiling_info = ::std::mem::transmute(function_ptr);
+    (fun)(info, index)
+}
+
+static __DUCKDB_APPENDER_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_create(
+    connection: duckdb_connection,
+    schema: *const ::std::os::raw::c_char,
+    table: *const ::std::os::raw::c_char,
+    out_appender: *mut duckdb_appender,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_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(
+        connection: duckdb_connection,
+        schema: *const ::std::os::raw::c_char,
+        table: *const ::std::os::raw::c_char,
+        out_appender: *mut duckdb_appender,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, schema, table, out_appender)
+}
+
+static __DUCKDB_APPENDER_CREATE_EXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_create_ext(
+    connection: duckdb_connection,
+    catalog: *const ::std::os::raw::c_char,
+    schema: *const ::std::os::raw::c_char,
+    table: *const ::std::os::raw::c_char,
+    out_appender: *mut duckdb_appender,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_CREATE_EXT
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        connection: duckdb_connection,
+        catalog: *const ::std::os::raw::c_char,
+        schema: *const ::std::os::raw::c_char,
+        table: *const ::std::os::raw::c_char,
+        out_appender: *mut duckdb_appender,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, catalog, schema, table, out_appender)
+}
+
+static __DUCKDB_APPENDER_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_column_count(appender: duckdb_appender) -> idx_t {
+    let function_ptr = __DUCKDB_APPENDER_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(appender: duckdb_appender) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPENDER_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_column_type(
+    appender: duckdb_appender,
+    col_idx: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_APPENDER_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(
+        appender: duckdb_appender,
+        col_idx: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(appender, col_idx)
+}
+
+static __DUCKDB_APPENDER_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_error(
+    appender: duckdb_appender,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_APPENDER_ERROR
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(appender)
+}
+
+static __DUCKDB_APPENDER_FLUSH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_flush(appender: duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_FLUSH
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPENDER_CLOSE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_close(appender: duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_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(appender: duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPENDER_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_destroy(appender: *mut duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_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(appender: *mut duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPENDER_ADD_COLUMN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_add_column(
+    appender: duckdb_appender,
+    name: *const ::std::os::raw::c_char,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_ADD_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(
+        appender: duckdb_appender,
+        name: *const ::std::os::raw::c_char,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, name)
+}
+
+static __DUCKDB_APPENDER_CLEAR_COLUMNS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_clear_columns(appender: duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_CLEAR_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(appender: duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPEND_DATA_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_data_chunk(
+    appender: duckdb_appender,
+    chunk: duckdb_data_chunk,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_DATA_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(
+        appender: duckdb_appender,
+        chunk: duckdb_data_chunk,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, chunk)
+}
+
+static __DUCKDB_TABLE_DESCRIPTION_CREATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_description_create(
+    connection: duckdb_connection,
+    schema: *const ::std::os::raw::c_char,
+    table: *const ::std::os::raw::c_char,
+    out: *mut duckdb_table_description,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_TABLE_DESCRIPTION_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(
+        connection: duckdb_connection,
+        schema: *const ::std::os::raw::c_char,
+        table: *const ::std::os::raw::c_char,
+        out: *mut duckdb_table_description,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, schema, table, out)
+}
+
+static __DUCKDB_TABLE_DESCRIPTION_CREATE_EXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_description_create_ext(
+    connection: duckdb_connection,
+    catalog: *const ::std::os::raw::c_char,
+    schema: *const ::std::os::raw::c_char,
+    table: *const ::std::os::raw::c_char,
+    out: *mut duckdb_table_description,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_TABLE_DESCRIPTION_CREATE_EXT
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        connection: duckdb_connection,
+        catalog: *const ::std::os::raw::c_char,
+        schema: *const ::std::os::raw::c_char,
+        table: *const ::std::os::raw::c_char,
+        out: *mut duckdb_table_description,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, catalog, schema, table, out)
+}
+
+static __DUCKDB_TABLE_DESCRIPTION_DESTROY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_description_destroy(
+    table_description: *mut duckdb_table_description,
+) {
+    let function_ptr = __DUCKDB_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(table_description: *mut duckdb_table_description) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(table_description)
+}
+
+static __DUCKDB_TABLE_DESCRIPTION_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_description_error(
+    table_description: duckdb_table_description,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_TABLE_DESCRIPTION_ERROR
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        table_description: duckdb_table_description,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(table_description)
+}
+
+static __DUCKDB_COLUMN_HAS_DEFAULT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_column_has_default(
+    table_description: duckdb_table_description,
+    index: idx_t,
+    out: *mut bool,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_COLUMN_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(
+        table_description: duckdb_table_description,
+        index: idx_t,
+        out: *mut bool,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(table_description, index, out)
+}
+
+static __DUCKDB_TABLE_DESCRIPTION_GET_COLUMN_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_description_get_column_name(
+    table_description: duckdb_table_description,
+    index: idx_t,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_TABLE_DESCRIPTION_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(
+        table_description: duckdb_table_description,
+        index: idx_t,
+    ) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(table_description, index)
+}
+
+static __DUCKDB_EXECUTE_TASKS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_execute_tasks(database: duckdb_database, max_tasks: idx_t) {
+    let function_ptr = __DUCKDB_EXECUTE_TASKS
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(database: duckdb_database, max_tasks: idx_t) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(database, max_tasks)
+}
+
+static __DUCKDB_CREATE_TASK_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_task_state(database: duckdb_database) -> duckdb_task_state {
+    let function_ptr = __DUCKDB_CREATE_TASK_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(database: duckdb_database) -> duckdb_task_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(database)
+}
+
+static __DUCKDB_EXECUTE_TASKS_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_execute_tasks_state(state: duckdb_task_state) {
+    let function_ptr = __DUCKDB_EXECUTE_TASKS_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(state: duckdb_task_state) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(state)
+}
+
+static __DUCKDB_EXECUTE_N_TASKS_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_execute_n_tasks_state(
+    state: duckdb_task_state,
+    max_tasks: idx_t,
+) -> idx_t {
+    let function_ptr = __DUCKDB_EXECUTE_N_TASKS_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(state: duckdb_task_state, max_tasks: idx_t) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(state, max_tasks)
+}
+
+static __DUCKDB_FINISH_EXECUTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_finish_execution(state: duckdb_task_state) {
+    let function_ptr = __DUCKDB_FINISH_EXECUTION
+        .load(::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: duckdb_task_state) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(state)
+}
+
+static __DUCKDB_TASK_STATE_IS_FINISHED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_task_state_is_finished(state: duckdb_task_state) -> bool {
+    let function_ptr = __DUCKDB_TASK_STATE_IS_FINISHED
+        .load(::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: duckdb_task_state) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(state)
+}
+
+static __DUCKDB_DESTROY_TASK_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_task_state(state: duckdb_task_state) {
+    let function_ptr = __DUCKDB_DESTROY_TASK_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(state: duckdb_task_state) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(state)
+}
+
+static __DUCKDB_EXECUTION_IS_FINISHED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_execution_is_finished(con: duckdb_connection) -> bool {
+    let function_ptr = __DUCKDB_EXECUTION_IS_FINISHED
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(con: duckdb_connection) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(con)
+}
+
+static __DUCKDB_FETCH_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_fetch_chunk(result: duckdb_result) -> duckdb_data_chunk {
+    let function_ptr = __DUCKDB_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_result) -> duckdb_data_chunk = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_CREATE_CAST_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_cast_function() -> duckdb_cast_function {
+    let function_ptr = __DUCKDB_CREATE_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() -> duckdb_cast_function = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_CAST_FUNCTION_SET_SOURCE_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_cast_function_set_source_type(
+    cast_function: duckdb_cast_function,
+    source_type: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_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(
+        cast_function: duckdb_cast_function,
+        source_type: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(cast_function, source_type)
+}
+
+static __DUCKDB_CAST_FUNCTION_SET_TARGET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_cast_function_set_target_type(
+    cast_function: duckdb_cast_function,
+    target_type: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_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(
+        cast_function: duckdb_cast_function,
+        target_type: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(cast_function, target_type)
+}
+
+static __DUCKDB_CAST_FUNCTION_SET_IMPLICIT_CAST_COST: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_cast_function_set_implicit_cast_cost(
+    cast_function: duckdb_cast_function,
+    cost: i64,
+) {
+    let function_ptr = __DUCKDB_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(cast_function: duckdb_cast_function, cost: i64) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(cast_function, cost)
+}
+
+static __DUCKDB_CAST_FUNCTION_SET_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_cast_function_set_function(
+    cast_function: duckdb_cast_function,
+    function: duckdb_cast_function_t,
+) {
+    let function_ptr = __DUCKDB_CAST_FUNCTION_SET_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(
+        cast_function: duckdb_cast_function,
+        function: duckdb_cast_function_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(cast_function, function)
+}
+
+static __DUCKDB_CAST_FUNCTION_SET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_cast_function_set_extra_info(
+    cast_function: duckdb_cast_function,
+    extra_info: *mut ::std::os::raw::c_void,
+    destroy: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_CAST_FUNCTION_SET_EXTRA_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(
+        cast_function: duckdb_cast_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(cast_function, extra_info, destroy)
+}
+
+static __DUCKDB_CAST_FUNCTION_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_cast_function_get_extra_info(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_CAST_FUNCTION_GET_EXTRA_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_CAST_FUNCTION_GET_CAST_MODE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_cast_function_get_cast_mode(
+    info: duckdb_function_info,
+) -> duckdb_cast_mode {
+    let function_ptr = __DUCKDB_CAST_FUNCTION_GET_CAST_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_function_info) -> duckdb_cast_mode = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info)
+}
+
+static __DUCKDB_CAST_FUNCTION_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_cast_function_set_error(
+    info: duckdb_function_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_CAST_FUNCTION_SET_ERROR
+        .load(::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_function_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_CAST_FUNCTION_SET_ROW_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_cast_function_set_row_error(
+    info: duckdb_function_info,
+    error: *const ::std::os::raw::c_char,
+    row: idx_t,
+    output: duckdb_vector,
+) {
+    let function_ptr = __DUCKDB_CAST_FUNCTION_SET_ROW_ERROR
+        .load(::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_function_info,
+        error: *const ::std::os::raw::c_char,
+        row: idx_t,
+        output: duckdb_vector,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error, row, output)
+}
+
+static __DUCKDB_REGISTER_CAST_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_cast_function(
+    con: duckdb_connection,
+    cast_function: duckdb_cast_function,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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(
+        con: duckdb_connection,
+        cast_function: duckdb_cast_function,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(con, cast_function)
+}
+
+static __DUCKDB_DESTROY_CAST_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_cast_function(cast_function: *mut duckdb_cast_function) {
+    let function_ptr = __DUCKDB_DESTROY_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(cast_function: *mut duckdb_cast_function) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(cast_function)
+}
+
+static __DUCKDB_IS_FINITE_TIMESTAMP_S: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_is_finite_timestamp_s(ts: duckdb_timestamp_s) -> bool {
+    let function_ptr = __DUCKDB_IS_FINITE_TIMESTAMP_S
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(ts: duckdb_timestamp_s) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(ts)
+}
+
+static __DUCKDB_IS_FINITE_TIMESTAMP_MS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_is_finite_timestamp_ms(ts: duckdb_timestamp_ms) -> bool {
+    let function_ptr = __DUCKDB_IS_FINITE_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(ts: duckdb_timestamp_ms) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(ts)
+}
+
+static __DUCKDB_IS_FINITE_TIMESTAMP_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_is_finite_timestamp_ns(ts: duckdb_timestamp_ns) -> bool {
+    let function_ptr = __DUCKDB_IS_FINITE_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(ts: duckdb_timestamp_ns) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(ts)
+}
+
+static __DUCKDB_CREATE_TIMESTAMP_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_timestamp_tz(input: duckdb_timestamp) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_timestamp) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_TIMESTAMP_S: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_timestamp_s(input: duckdb_timestamp_s) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_TIMESTAMP_S
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(input: duckdb_timestamp_s) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_TIMESTAMP_MS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_timestamp_ms(input: duckdb_timestamp_ms) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_timestamp_ms) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_CREATE_TIMESTAMP_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_timestamp_ns(input: duckdb_timestamp_ns) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_timestamp_ns) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_GET_TIMESTAMP_TZ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_timestamp_tz(val: duckdb_value) -> duckdb_timestamp {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_timestamp = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_TIMESTAMP_S: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_timestamp_s(val: duckdb_value) -> duckdb_timestamp_s {
+    let function_ptr = __DUCKDB_GET_TIMESTAMP_S
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(val: duckdb_value) -> duckdb_timestamp_s = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_TIMESTAMP_MS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_timestamp_ms(val: duckdb_value) -> duckdb_timestamp_ms {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_timestamp_ms = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_GET_TIMESTAMP_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_timestamp_ns(val: duckdb_value) -> duckdb_timestamp_ns {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_timestamp_ns = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_APPEND_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_value(
+    appender: duckdb_appender,
+    value: duckdb_value,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: duckdb_value,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_GET_PROFILING_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_profiling_info(
+    connection: duckdb_connection,
+) -> duckdb_profiling_info {
+    let function_ptr = __DUCKDB_GET_PROFILING_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(
+        connection: duckdb_connection,
+    ) -> duckdb_profiling_info = ::std::mem::transmute(function_ptr);
+    (fun)(connection)
+}
+
+static __DUCKDB_PROFILING_INFO_GET_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_profiling_info_get_value(
+    info: duckdb_profiling_info,
+    key: *const ::std::os::raw::c_char,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_PROFILING_INFO_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_profiling_info,
+        key: *const ::std::os::raw::c_char,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(info, key)
+}
+
+static __DUCKDB_APPENDER_BEGIN_ROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_begin_row(appender: duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_BEGIN_ROW
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPENDER_END_ROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_end_row(appender: duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_END_ROW
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(appender: duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPEND_DEFAULT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_default(appender: duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(appender: duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPEND_BOOL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_bool(
+    appender: duckdb_appender,
+    value: bool,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: bool,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_INT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_int8(appender: duckdb_appender, value: i8) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_INT8.load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        value: i8,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_INT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_int16(
+    appender: duckdb_appender,
+    value: i16,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_INT16
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        value: i16,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_INT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_int32(
+    appender: duckdb_appender,
+    value: i32,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_INT32
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        value: i32,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_INT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_int64(
+    appender: duckdb_appender,
+    value: i64,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_INT64
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        value: i64,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_HUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_hugeint(
+    appender: duckdb_appender,
+    value: duckdb_hugeint,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: duckdb_hugeint,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_UINT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_uint8(appender: duckdb_appender, value: u8) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_UINT8
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        value: u8,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_UINT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_uint16(
+    appender: duckdb_appender,
+    value: u16,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_UINT16
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        value: u16,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_UINT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_uint32(
+    appender: duckdb_appender,
+    value: u32,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_UINT32
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        value: u32,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_UINT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_uint64(
+    appender: duckdb_appender,
+    value: u64,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_UINT64
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        value: u64,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_UHUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_uhugeint(
+    appender: duckdb_appender,
+    value: duckdb_uhugeint,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: duckdb_uhugeint,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_FLOAT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_float(
+    appender: duckdb_appender,
+    value: f32,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: f32,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_double(
+    appender: duckdb_appender,
+    value: f64,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: f64,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_date(
+    appender: duckdb_appender,
+    value: duckdb_date,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: duckdb_date,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_time(
+    appender: duckdb_appender,
+    value: duckdb_time,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: duckdb_time,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_timestamp(
+    appender: duckdb_appender,
+    value: duckdb_timestamp,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: duckdb_timestamp,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_INTERVAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_interval(
+    appender: duckdb_appender,
+    value: duckdb_interval,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        value: duckdb_interval,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, value)
+}
+
+static __DUCKDB_APPEND_VARCHAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_varchar(
+    appender: duckdb_appender,
+    val: *const ::std::os::raw::c_char,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        val: *const ::std::os::raw::c_char,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, val)
+}
+
+static __DUCKDB_APPEND_VARCHAR_LENGTH: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_varchar_length(
+    appender: duckdb_appender,
+    val: *const ::std::os::raw::c_char,
+    length: idx_t,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_VARCHAR_LENGTH
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        appender: duckdb_appender,
+        val: *const ::std::os::raw::c_char,
+        length: idx_t,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, val, length)
+}
+
+static __DUCKDB_APPEND_BLOB: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_blob(
+    appender: duckdb_appender,
+    data: *const ::std::os::raw::c_void,
+    length: idx_t,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(
+        appender: duckdb_appender,
+        data: *const ::std::os::raw::c_void,
+        length: idx_t,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, data, length)
+}
+
+static __DUCKDB_APPEND_NULL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_null(appender: duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_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(appender: duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_ROW_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_row_count(result: *mut duckdb_result) -> idx_t {
+    let function_ptr = __DUCKDB_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(result: *mut duckdb_result) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_COLUMN_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_column_data(
+    result: *mut duckdb_result,
+    col: idx_t,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COLUMN_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(result, col)
+}
+
+static __DUCKDB_NULLMASK_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_nullmask_data(result: *mut duckdb_result, col: idx_t) -> *mut bool {
+    let function_ptr = __DUCKDB_NULLMASK_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(result: *mut duckdb_result, col: idx_t) -> *mut bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result, col)
+}
+
+static __DUCKDB_RESULT_GET_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_get_chunk(
+    result: duckdb_result,
+    chunk_index: idx_t,
+) -> duckdb_data_chunk {
+    let function_ptr = __DUCKDB_RESULT_GET_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_result,
+        chunk_index: idx_t,
+    ) -> duckdb_data_chunk = ::std::mem::transmute(function_ptr);
+    (fun)(result, chunk_index)
+}
+
+static __DUCKDB_RESULT_IS_STREAMING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_is_streaming(result: duckdb_result) -> bool {
+    let function_ptr = __DUCKDB_RESULT_IS_STREAMING
+        .load(::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_result) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_RESULT_CHUNK_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_chunk_count(result: duckdb_result) -> idx_t {
+    let function_ptr = __DUCKDB_RESULT_CHUNK_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(result: duckdb_result) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_VALUE_BOOLEAN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_boolean(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> bool {
+    let function_ptr = __DUCKDB_VALUE_BOOLEAN
+        .load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> bool = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_INT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_int8(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> i8 {
+    let function_ptr = __DUCKDB_VALUE_INT8.load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> i8 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_INT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_int16(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> i16 {
+    let function_ptr = __DUCKDB_VALUE_INT16.load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> i16 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_INT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_int32(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> i32 {
+    let function_ptr = __DUCKDB_VALUE_INT32.load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> i32 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_INT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_int64(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> i64 {
+    let function_ptr = __DUCKDB_VALUE_INT64.load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> i64 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_HUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_hugeint(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_hugeint {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_hugeint = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_UHUGEINT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_uhugeint(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_uhugeint {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_uhugeint = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_DECIMAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_decimal(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_decimal {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_decimal = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_UINT8: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_uint8(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> u8 {
+    let function_ptr = __DUCKDB_VALUE_UINT8.load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> u8 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_UINT16: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_uint16(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> u16 {
+    let function_ptr = __DUCKDB_VALUE_UINT16
+        .load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> u16 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_UINT32: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_uint32(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> u32 {
+    let function_ptr = __DUCKDB_VALUE_UINT32
+        .load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> u32 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_UINT64: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_uint64(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> u64 {
+    let function_ptr = __DUCKDB_VALUE_UINT64
+        .load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> u64 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_FLOAT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_float(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> f32 {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> f32 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_DOUBLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_double(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> f64 {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> f64 = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_DATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_date(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_date {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_date = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_TIME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_time(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_time {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_time = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_TIMESTAMP: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_timestamp(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_timestamp {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_timestamp = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_INTERVAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_interval(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_interval {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_interval = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_VARCHAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_varchar(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_STRING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_string(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_string {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_string = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_VARCHAR_INTERNAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_varchar_internal(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_VALUE_VARCHAR_INTERNAL
+        .load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_STRING_INTERNAL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_string_internal(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_string {
+    let function_ptr = __DUCKDB_VALUE_STRING_INTERNAL
+        .load(::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_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_string = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_BLOB: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_blob(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_blob {
+    let function_ptr = __DUCKDB_VALUE_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_blob = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_VALUE_IS_NULL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_is_null(
+    result: *mut duckdb_result,
+    col: idx_t,
+    row: idx_t,
+) -> bool {
+    let function_ptr = __DUCKDB_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(
+        result: *mut duckdb_result,
+        col: idx_t,
+        row: idx_t,
+    ) -> bool = ::std::mem::transmute(function_ptr);
+    (fun)(result, col, row)
+}
+
+static __DUCKDB_EXECUTE_PREPARED_STREAMING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_execute_prepared_streaming(
+    prepared_statement: duckdb_prepared_statement,
+    out_result: *mut duckdb_result,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_EXECUTE_PREPARED_STREAMING
+        .load(::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_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_result,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, out_result)
+}
+
+static __DUCKDB_PENDING_PREPARED_STREAMING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_pending_prepared_streaming(
+    prepared_statement: duckdb_prepared_statement,
+    out_result: *mut duckdb_pending_result,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_PENDING_PREPARED_STREAMING
+        .load(::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_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_pending_result,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, out_result)
+}
+
+static __DUCKDB_QUERY_ARROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_query_arrow(
+    connection: duckdb_connection,
+    query: *const ::std::os::raw::c_char,
+    out_result: *mut duckdb_arrow,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_QUERY_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(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        out_result: *mut duckdb_arrow,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, query, out_result)
+}
+
+static __DUCKDB_QUERY_ARROW_SCHEMA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_query_arrow_schema(
+    result: duckdb_arrow,
+    out_schema: *mut duckdb_arrow_schema,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_QUERY_ARROW_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_arrow,
+        out_schema: *mut duckdb_arrow_schema,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(result, out_schema)
+}
+
+static __DUCKDB_PREPARED_ARROW_SCHEMA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_prepared_arrow_schema(
+    prepared: duckdb_prepared_statement,
+    out_schema: *mut duckdb_arrow_schema,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_PREPARED_ARROW_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(
+        prepared: duckdb_prepared_statement,
+        out_schema: *mut duckdb_arrow_schema,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared, out_schema)
+}
+
+static __DUCKDB_RESULT_ARROW_ARRAY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_arrow_array(
+    result: duckdb_result,
+    chunk: duckdb_data_chunk,
+    out_array: *mut duckdb_arrow_array,
+) {
+    let function_ptr = __DUCKDB_RESULT_ARROW_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_result,
+        chunk: duckdb_data_chunk,
+        out_array: *mut duckdb_arrow_array,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(result, chunk, out_array)
+}
+
+static __DUCKDB_QUERY_ARROW_ARRAY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_query_arrow_array(
+    result: duckdb_arrow,
+    out_array: *mut duckdb_arrow_array,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_QUERY_ARROW_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_arrow,
+        out_array: *mut duckdb_arrow_array,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(result, out_array)
+}
+
+static __DUCKDB_ARROW_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_arrow_column_count(result: duckdb_arrow) -> idx_t {
+    let function_ptr = __DUCKDB_ARROW_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(result: duckdb_arrow) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_ARROW_ROW_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_arrow_row_count(result: duckdb_arrow) -> idx_t {
+    let function_ptr = __DUCKDB_ARROW_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(result: duckdb_arrow) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_ARROW_ROWS_CHANGED: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_arrow_rows_changed(result: duckdb_arrow) -> idx_t {
+    let function_ptr = __DUCKDB_ARROW_ROWS_CHANGED
+        .load(::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_arrow) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_QUERY_ARROW_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_query_arrow_error(
+    result: duckdb_arrow,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_QUERY_ARROW_ERROR
+        .load(::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_arrow,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(result)
+}
+
+static __DUCKDB_DESTROY_ARROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_arrow(result: *mut duckdb_arrow) {
+    let function_ptr = __DUCKDB_DESTROY_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(result: *mut duckdb_arrow) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_DESTROY_ARROW_STREAM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_arrow_stream(stream_p: *mut duckdb_arrow_stream) {
+    let function_ptr = __DUCKDB_DESTROY_ARROW_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(stream_p: *mut duckdb_arrow_stream) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(stream_p)
+}
+
+static __DUCKDB_EXECUTE_PREPARED_ARROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_execute_prepared_arrow(
+    prepared_statement: duckdb_prepared_statement,
+    out_result: *mut duckdb_arrow,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_EXECUTE_PREPARED_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_statement: duckdb_prepared_statement,
+        out_result: *mut duckdb_arrow,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, out_result)
+}
+
+static __DUCKDB_ARROW_SCAN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_arrow_scan(
+    connection: duckdb_connection,
+    table_name: *const ::std::os::raw::c_char,
+    arrow: duckdb_arrow_stream,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_ARROW_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(
+        connection: duckdb_connection,
+        table_name: *const ::std::os::raw::c_char,
+        arrow: duckdb_arrow_stream,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, table_name, arrow)
+}
+
+static __DUCKDB_ARROW_ARRAY_SCAN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_arrow_array_scan(
+    connection: duckdb_connection,
+    table_name: *const ::std::os::raw::c_char,
+    arrow_schema: duckdb_arrow_schema,
+    arrow_array: duckdb_arrow_array,
+    out_stream: *mut duckdb_arrow_stream,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_ARROW_ARRAY_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(
+        connection: duckdb_connection,
+        table_name: *const ::std::os::raw::c_char,
+        arrow_schema: duckdb_arrow_schema,
+        arrow_array: duckdb_arrow_array,
+        out_stream: *mut duckdb_arrow_stream,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, table_name, arrow_schema, arrow_array, out_stream)
+}
+
+static __DUCKDB_STREAM_FETCH_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_stream_fetch_chunk(result: duckdb_result) -> duckdb_data_chunk {
+    let function_ptr = __DUCKDB_STREAM_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_result) -> duckdb_data_chunk = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_CREATE_INSTANCE_CACHE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_instance_cache() -> duckdb_instance_cache {
+    let function_ptr = __DUCKDB_CREATE_INSTANCE_CACHE
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn() -> duckdb_instance_cache = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_GET_OR_CREATE_FROM_CACHE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_or_create_from_cache(
+    instance_cache: duckdb_instance_cache,
+    path: *const ::std::os::raw::c_char,
+    out_database: *mut duckdb_database,
+    config: duckdb_config,
+    out_error: *mut *mut ::std::os::raw::c_char,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_GET_OR_CREATE_FROM_CACHE
+        .load(::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_cache: duckdb_instance_cache,
+        path: *const ::std::os::raw::c_char,
+        out_database: *mut duckdb_database,
+        config: duckdb_config,
+        out_error: *mut *mut ::std::os::raw::c_char,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(instance_cache, path, out_database, config, out_error)
+}
+
+static __DUCKDB_DESTROY_INSTANCE_CACHE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_instance_cache(instance_cache: *mut duckdb_instance_cache) {
+    let function_ptr = __DUCKDB_DESTROY_INSTANCE_CACHE
+        .load(::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_cache: *mut duckdb_instance_cache) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(instance_cache)
+}
+
+static __DUCKDB_APPEND_DEFAULT_TO_CHUNK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_append_default_to_chunk(
+    appender: duckdb_appender,
+    chunk: duckdb_data_chunk,
+    col: idx_t,
+    row: idx_t,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPEND_DEFAULT_TO_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(
+        appender: duckdb_appender,
+        chunk: duckdb_data_chunk,
+        col: idx_t,
+        row: idx_t,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(appender, chunk, col, row)
+}
+
+static __DUCKDB_APPENDER_ERROR_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_error_data(
+    appender: duckdb_appender,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_APPENDER_ERROR_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(appender: duckdb_appender) -> duckdb_error_data = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_APPENDER_CREATE_QUERY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_create_query(
+    connection: duckdb_connection,
+    query: *const ::std::os::raw::c_char,
+    column_count: idx_t,
+    types: *mut duckdb_logical_type,
+    table_name: *const ::std::os::raw::c_char,
+    column_names: *mut *const ::std::os::raw::c_char,
+    out_appender: *mut duckdb_appender,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_CREATE_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(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        column_count: idx_t,
+        types: *mut duckdb_logical_type,
+        table_name: *const ::std::os::raw::c_char,
+        column_names: *mut *const ::std::os::raw::c_char,
+        out_appender: *mut duckdb_appender,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, query, column_count, types, table_name, column_names, out_appender)
+}
+
+static __DUCKDB_APPENDER_CLEAR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_appender_clear(appender: duckdb_appender) -> duckdb_state {
+    let function_ptr = __DUCKDB_APPENDER_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(appender: duckdb_appender) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(appender)
+}
+
+static __DUCKDB_TO_ARROW_SCHEMA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_to_arrow_schema(
+    arrow_options: duckdb_arrow_options,
+    types: *mut duckdb_logical_type,
+    names: *mut *const ::std::os::raw::c_char,
+    column_count: idx_t,
+    out_schema: *mut ArrowSchema,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_TO_ARROW_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(
+        arrow_options: duckdb_arrow_options,
+        types: *mut duckdb_logical_type,
+        names: *mut *const ::std::os::raw::c_char,
+        column_count: idx_t,
+        out_schema: *mut ArrowSchema,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(arrow_options, types, names, column_count, out_schema)
+}
+
+static __DUCKDB_DATA_CHUNK_TO_ARROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_data_chunk_to_arrow(
+    arrow_options: duckdb_arrow_options,
+    chunk: duckdb_data_chunk,
+    out_arrow_array: *mut ArrowArray,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_DATA_CHUNK_TO_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(
+        arrow_options: duckdb_arrow_options,
+        chunk: duckdb_data_chunk,
+        out_arrow_array: *mut ArrowArray,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(arrow_options, chunk, out_arrow_array)
+}
+
+static __DUCKDB_SCHEMA_FROM_ARROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_schema_from_arrow(
+    connection: duckdb_connection,
+    schema: *mut ArrowSchema,
+    out_types: *mut duckdb_arrow_converted_schema,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_SCHEMA_FROM_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(
+        connection: duckdb_connection,
+        schema: *mut ArrowSchema,
+        out_types: *mut duckdb_arrow_converted_schema,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(connection, schema, out_types)
+}
+
+static __DUCKDB_DATA_CHUNK_FROM_ARROW: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_data_chunk_from_arrow(
+    connection: duckdb_connection,
+    arrow_array: *mut ArrowArray,
+    converted_schema: duckdb_arrow_converted_schema,
+    out_chunk: *mut duckdb_data_chunk,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_DATA_CHUNK_FROM_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(
+        connection: duckdb_connection,
+        arrow_array: *mut ArrowArray,
+        converted_schema: duckdb_arrow_converted_schema,
+        out_chunk: *mut duckdb_data_chunk,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(connection, arrow_array, converted_schema, out_chunk)
+}
+
+static __DUCKDB_DESTROY_ARROW_CONVERTED_SCHEMA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_arrow_converted_schema(
+    arrow_converted_schema: *mut duckdb_arrow_converted_schema,
+) {
+    let function_ptr = __DUCKDB_DESTROY_ARROW_CONVERTED_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(
+        arrow_converted_schema: *mut duckdb_arrow_converted_schema,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(arrow_converted_schema)
+}
+
+static __DUCKDB_CLIENT_CONTEXT_GET_CATALOG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_client_context_get_catalog(
+    context: duckdb_client_context,
+    catalog_name: *const ::std::os::raw::c_char,
+) -> duckdb_catalog {
+    let function_ptr = __DUCKDB_CLIENT_CONTEXT_GET_CATALOG
+        .load(::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_client_context,
+        catalog_name: *const ::std::os::raw::c_char,
+    ) -> duckdb_catalog = ::std::mem::transmute(function_ptr);
+    (fun)(context, catalog_name)
+}
+
+static __DUCKDB_CATALOG_GET_TYPE_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_catalog_get_type_name(
+    catalog: duckdb_catalog,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_CATALOG_GET_TYPE_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(
+        catalog: duckdb_catalog,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(catalog)
+}
+
+static __DUCKDB_CATALOG_GET_ENTRY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_catalog_get_entry(
+    catalog: duckdb_catalog,
+    context: duckdb_client_context,
+    entry_type: duckdb_catalog_entry_type,
+    schema_name: *const ::std::os::raw::c_char,
+    entry_name: *const ::std::os::raw::c_char,
+) -> duckdb_catalog_entry {
+    let function_ptr = __DUCKDB_CATALOG_GET_ENTRY
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        catalog: duckdb_catalog,
+        context: duckdb_client_context,
+        entry_type: duckdb_catalog_entry_type,
+        schema_name: *const ::std::os::raw::c_char,
+        entry_name: *const ::std::os::raw::c_char,
+    ) -> duckdb_catalog_entry = ::std::mem::transmute(function_ptr);
+    (fun)(catalog, context, entry_type, schema_name, entry_name)
+}
+
+static __DUCKDB_DESTROY_CATALOG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_catalog(catalog: *mut duckdb_catalog) {
+    let function_ptr = __DUCKDB_DESTROY_CATALOG
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(catalog: *mut duckdb_catalog) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(catalog)
+}
+
+static __DUCKDB_CATALOG_ENTRY_GET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_catalog_entry_get_type(
+    entry: duckdb_catalog_entry,
+) -> duckdb_catalog_entry_type {
+    let function_ptr = __DUCKDB_CATALOG_ENTRY_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(
+        entry: duckdb_catalog_entry,
+    ) -> duckdb_catalog_entry_type = ::std::mem::transmute(function_ptr);
+    (fun)(entry)
+}
+
+static __DUCKDB_CATALOG_ENTRY_GET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_catalog_entry_get_name(
+    entry: duckdb_catalog_entry,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_CATALOG_ENTRY_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(
+        entry: duckdb_catalog_entry,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(entry)
+}
+
+static __DUCKDB_DESTROY_CATALOG_ENTRY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_catalog_entry(entry: *mut duckdb_catalog_entry) {
+    let function_ptr = __DUCKDB_DESTROY_CATALOG_ENTRY
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(entry: *mut duckdb_catalog_entry) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(entry)
+}
+
+static __DUCKDB_CREATE_CONFIG_OPTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_config_option() -> duckdb_config_option {
+    let function_ptr = __DUCKDB_CREATE_CONFIG_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() -> duckdb_config_option = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_DESTROY_CONFIG_OPTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_config_option(option: *mut duckdb_config_option) {
+    let function_ptr = __DUCKDB_DESTROY_CONFIG_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(option: *mut duckdb_config_option) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(option)
+}
+
+static __DUCKDB_CONFIG_OPTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_config_option_set_name(
+    option: duckdb_config_option,
+    name: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_CONFIG_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_config_option,
+        name: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(option, name)
+}
+
+static __DUCKDB_CONFIG_OPTION_SET_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_config_option_set_type(
+    option: duckdb_config_option,
+    type_: duckdb_logical_type,
+) {
+    let function_ptr = __DUCKDB_CONFIG_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_config_option,
+        type_: duckdb_logical_type,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(option, type_)
+}
+
+static __DUCKDB_CONFIG_OPTION_SET_DEFAULT_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_config_option_set_default_value(
+    option: duckdb_config_option,
+    default_value: duckdb_value,
+) {
+    let function_ptr = __DUCKDB_CONFIG_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_config_option,
+        default_value: duckdb_value,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(option, default_value)
+}
+
+static __DUCKDB_CONFIG_OPTION_SET_DEFAULT_SCOPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_config_option_set_default_scope(
+    option: duckdb_config_option,
+    default_scope: duckdb_config_option_scope,
+) {
+    let function_ptr = __DUCKDB_CONFIG_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_config_option,
+        default_scope: duckdb_config_option_scope,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(option, default_scope)
+}
+
+static __DUCKDB_CONFIG_OPTION_SET_DESCRIPTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_config_option_set_description(
+    option: duckdb_config_option,
+    description: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_CONFIG_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_config_option,
+        description: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(option, description)
+}
+
+static __DUCKDB_REGISTER_CONFIG_OPTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_config_option(
+    connection: duckdb_connection,
+    option: duckdb_config_option,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_REGISTER_CONFIG_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(
+        connection: duckdb_connection,
+        option: duckdb_config_option,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, option)
+}
+
+static __DUCKDB_CLIENT_CONTEXT_GET_CONFIG_OPTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_client_context_get_config_option(
+    context: duckdb_client_context,
+    name: *const ::std::os::raw::c_char,
+    out_scope: *mut duckdb_config_option_scope,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_CLIENT_CONTEXT_GET_CONFIG_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(
+        context: duckdb_client_context,
+        name: *const ::std::os::raw::c_char,
+        out_scope: *mut duckdb_config_option_scope,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(context, name, out_scope)
+}
+
+static __DUCKDB_CREATE_COPY_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_copy_function() -> duckdb_copy_function {
+    let function_ptr = __DUCKDB_CREATE_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() -> duckdb_copy_function = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_COPY_FUNCTION_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_set_name(
+    copy_function: duckdb_copy_function,
+    name: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_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(
+        copy_function: duckdb_copy_function,
+        name: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(copy_function, name)
+}
+
+static __DUCKDB_COPY_FUNCTION_SET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_set_extra_info(
+    copy_function: duckdb_copy_function,
+    extra_info: *mut ::std::os::raw::c_void,
+    destructor: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SET_EXTRA_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(
+        copy_function: duckdb_copy_function,
+        extra_info: *mut ::std::os::raw::c_void,
+        destructor: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(copy_function, extra_info, destructor)
+}
+
+static __DUCKDB_REGISTER_COPY_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_copy_function(
+    connection: duckdb_connection,
+    copy_function: duckdb_copy_function,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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(
+        connection: duckdb_connection,
+        copy_function: duckdb_copy_function,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(connection, copy_function)
+}
+
+static __DUCKDB_DESTROY_COPY_FUNCTION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_copy_function(copy_function: *mut duckdb_copy_function) {
+    let function_ptr = __DUCKDB_DESTROY_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(copy_function: *mut duckdb_copy_function) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(copy_function)
+}
+
+static __DUCKDB_COPY_FUNCTION_SET_BIND: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_set_bind(
+    copy_function: duckdb_copy_function,
+    bind: duckdb_copy_function_bind_t,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SET_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(
+        copy_function: duckdb_copy_function,
+        bind: duckdb_copy_function_bind_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(copy_function, bind)
+}
+
+static __DUCKDB_COPY_FUNCTION_BIND_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_bind_set_error(
+    info: duckdb_copy_function_bind_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_BIND_SET_ERROR
+        .load(::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_copy_function_bind_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_COPY_FUNCTION_BIND_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_bind_get_extra_info(
+    info: duckdb_copy_function_bind_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_BIND_GET_EXTRA_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_copy_function_bind_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_BIND_GET_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_bind_get_client_context(
+    info: duckdb_copy_function_bind_info,
+) -> duckdb_client_context {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_BIND_GET_CLIENT_CONTEXT
+        .load(::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_copy_function_bind_info,
+    ) -> duckdb_client_context = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_BIND_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_bind_get_column_count(
+    info: duckdb_copy_function_bind_info,
+) -> idx_t {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_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_copy_function_bind_info) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_BIND_GET_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_bind_get_column_type(
+    info: duckdb_copy_function_bind_info,
+    col_idx: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_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_copy_function_bind_info,
+        col_idx: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(info, col_idx)
+}
+
+static __DUCKDB_COPY_FUNCTION_BIND_GET_OPTIONS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_bind_get_options(
+    info: duckdb_copy_function_bind_info,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_BIND_GET_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(
+        info: duckdb_copy_function_bind_info,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_BIND_SET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_bind_set_bind_data(
+    info: duckdb_copy_function_bind_info,
+    bind_data: *mut ::std::os::raw::c_void,
+    destructor: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_COPY_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_copy_function_bind_info,
+        bind_data: *mut ::std::os::raw::c_void,
+        destructor: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, bind_data, destructor)
+}
+
+static __DUCKDB_COPY_FUNCTION_SET_GLOBAL_INIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_set_global_init(
+    copy_function: duckdb_copy_function,
+    init: duckdb_copy_function_global_init_t,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SET_GLOBAL_INIT
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        copy_function: duckdb_copy_function,
+        init: duckdb_copy_function_global_init_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(copy_function, init)
+}
+
+static __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_SET_ERROR: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_global_init_set_error(
+    info: duckdb_copy_function_global_init_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_SET_ERROR
+        .load(::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_copy_function_global_init_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_global_init_get_extra_info(
+    info: duckdb_copy_function_global_init_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_EXTRA_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_copy_function_global_init_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_global_init_get_client_context(
+    info: duckdb_copy_function_global_init_info,
+) -> duckdb_client_context {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_CLIENT_CONTEXT
+        .load(::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_copy_function_global_init_info,
+    ) -> duckdb_client_context = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_global_init_get_bind_data(
+    info: duckdb_copy_function_global_init_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_GLOBAL_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_copy_function_global_init_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_SET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_global_init_set_global_state(
+    info: duckdb_copy_function_global_init_info,
+    global_state: *mut ::std::os::raw::c_void,
+    destructor: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_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_copy_function_global_init_info,
+        global_state: *mut ::std::os::raw::c_void,
+        destructor: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, global_state, destructor)
+}
+
+static __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_FILE_PATH: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_global_init_get_file_path(
+    info: duckdb_copy_function_global_init_info,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_GLOBAL_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_copy_function_global_init_info,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_SET_SINK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_set_sink(
+    copy_function: duckdb_copy_function,
+    function: duckdb_copy_function_sink_t,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SET_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(
+        copy_function: duckdb_copy_function,
+        function: duckdb_copy_function_sink_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(copy_function, function)
+}
+
+static __DUCKDB_COPY_FUNCTION_SINK_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_sink_set_error(
+    info: duckdb_copy_function_sink_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SINK_SET_ERROR
+        .load(::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_copy_function_sink_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_COPY_FUNCTION_SINK_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_sink_get_extra_info(
+    info: duckdb_copy_function_sink_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SINK_GET_EXTRA_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_copy_function_sink_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_SINK_GET_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_sink_get_client_context(
+    info: duckdb_copy_function_sink_info,
+) -> duckdb_client_context {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SINK_GET_CLIENT_CONTEXT
+        .load(::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_copy_function_sink_info,
+    ) -> duckdb_client_context = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_SINK_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_sink_get_bind_data(
+    info: duckdb_copy_function_sink_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SINK_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_copy_function_sink_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_SINK_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_sink_get_global_state(
+    info: duckdb_copy_function_sink_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SINK_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_copy_function_sink_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_SET_FINALIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_set_finalize(
+    copy_function: duckdb_copy_function,
+    finalize: duckdb_copy_function_finalize_t,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SET_FINALIZE
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        copy_function: duckdb_copy_function,
+        finalize: duckdb_copy_function_finalize_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(copy_function, finalize)
+}
+
+static __DUCKDB_COPY_FUNCTION_FINALIZE_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_copy_function_finalize_set_error(
+    info: duckdb_copy_function_finalize_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_FINALIZE_SET_ERROR
+        .load(::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_copy_function_finalize_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_COPY_FUNCTION_FINALIZE_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_finalize_get_extra_info(
+    info: duckdb_copy_function_finalize_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_FINALIZE_GET_EXTRA_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_copy_function_finalize_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_FINALIZE_GET_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_finalize_get_client_context(
+    info: duckdb_copy_function_finalize_info,
+) -> duckdb_client_context {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_FINALIZE_GET_CLIENT_CONTEXT
+        .load(::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_copy_function_finalize_info,
+    ) -> duckdb_client_context = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_FINALIZE_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_finalize_get_bind_data(
+    info: duckdb_copy_function_finalize_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_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_copy_function_finalize_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_FINALIZE_GET_GLOBAL_STATE: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_finalize_get_global_state(
+    info: duckdb_copy_function_finalize_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_FINALIZE_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_copy_function_finalize_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_COPY_FUNCTION_SET_COPY_FROM_FUNCTION: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_copy_function_set_copy_from_function(
+    copy_function: duckdb_copy_function,
+    table_function: duckdb_table_function,
+) {
+    let function_ptr = __DUCKDB_COPY_FUNCTION_SET_COPY_FROM_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(
+        copy_function: duckdb_copy_function,
+        table_function: duckdb_table_function,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(copy_function, table_function)
+}
+
+static __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_table_function_bind_get_result_column_count(
+    info: duckdb_bind_info,
+) -> idx_t {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_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_bind_info) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info)
+}
+
+static __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_COLUMN_NAME: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_table_function_bind_get_result_column_name(
+    info: duckdb_bind_info,
+    col_idx: idx_t,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_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_bind_info,
+        col_idx: idx_t,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(info, col_idx)
+}
+
+static __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_table_function_bind_get_result_column_type(
+    info: duckdb_bind_info,
+    col_idx: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_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_bind_info,
+        col_idx: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(info, col_idx)
+}
+
+static __DUCKDB_CREATE_ERROR_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_error_data(
+    type_: duckdb_error_type,
+    message: *const ::std::os::raw::c_char,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_CREATE_ERROR_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(
+        type_: duckdb_error_type,
+        message: *const ::std::os::raw::c_char,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(type_, message)
+}
+
+static __DUCKDB_DESTROY_ERROR_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_error_data(error_data: *mut duckdb_error_data) {
+    let function_ptr = __DUCKDB_DESTROY_ERROR_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(error_data: *mut duckdb_error_data) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(error_data)
+}
+
+static __DUCKDB_ERROR_DATA_ERROR_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_error_data_error_type(
+    error_data: duckdb_error_data,
+) -> duckdb_error_type {
+    let function_ptr = __DUCKDB_ERROR_DATA_ERROR_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(error_data: duckdb_error_data) -> duckdb_error_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(error_data)
+}
+
+static __DUCKDB_ERROR_DATA_MESSAGE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_error_data_message(
+    error_data: duckdb_error_data,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_ERROR_DATA_MESSAGE
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        error_data: duckdb_error_data,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(error_data)
+}
+
+static __DUCKDB_ERROR_DATA_HAS_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_error_data_has_error(error_data: duckdb_error_data) -> bool {
+    let function_ptr = __DUCKDB_ERROR_DATA_HAS_ERROR
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(error_data: duckdb_error_data) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(error_data)
+}
+
+static __DUCKDB_DESTROY_EXPRESSION: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_expression(expr: *mut duckdb_expression) {
+    let function_ptr = __DUCKDB_DESTROY_EXPRESSION
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(expr: *mut duckdb_expression) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(expr)
+}
+
+static __DUCKDB_EXPRESSION_RETURN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_expression_return_type(
+    expr: duckdb_expression,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_EXPRESSION_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(expr: duckdb_expression) -> duckdb_logical_type = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(expr)
+}
+
+static __DUCKDB_EXPRESSION_IS_FOLDABLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_expression_is_foldable(expr: duckdb_expression) -> bool {
+    let function_ptr = __DUCKDB_EXPRESSION_IS_FOLDABLE
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(expr: duckdb_expression) -> bool = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(expr)
+}
+
+static __DUCKDB_EXPRESSION_FOLD: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_expression_fold(
+    context: duckdb_client_context,
+    expr: duckdb_expression,
+    out_value: *mut duckdb_value,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_EXPRESSION_FOLD
+        .load(::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_client_context,
+        expr: duckdb_expression,
+        out_value: *mut duckdb_value,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(context, expr, out_value)
+}
+
+static __DUCKDB_CLIENT_CONTEXT_GET_FILE_SYSTEM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_client_context_get_file_system(
+    context: duckdb_client_context,
+) -> duckdb_file_system {
+    let function_ptr = __DUCKDB_CLIENT_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_client_context,
+    ) -> duckdb_file_system = ::std::mem::transmute(function_ptr);
+    (fun)(context)
+}
+
+static __DUCKDB_DESTROY_FILE_SYSTEM: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_file_system(file_system: *mut duckdb_file_system) {
+    let function_ptr = __DUCKDB_DESTROY_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(file_system: *mut duckdb_file_system) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(file_system)
+}
+
+static __DUCKDB_FILE_SYSTEM_OPEN: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_system_open(
+    file_system: duckdb_file_system,
+    path: *const ::std::os::raw::c_char,
+    options: duckdb_file_open_options,
+    out_file: *mut duckdb_file_handle,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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_file_system,
+        path: *const ::std::os::raw::c_char,
+        options: duckdb_file_open_options,
+        out_file: *mut duckdb_file_handle,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(file_system, path, options, out_file)
+}
+
+static __DUCKDB_FILE_SYSTEM_ERROR_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_system_error_data(
+    file_system: duckdb_file_system,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_FILE_SYSTEM_ERROR_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(
+        file_system: duckdb_file_system,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(file_system)
+}
+
+static __DUCKDB_CREATE_FILE_OPEN_OPTIONS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_file_open_options() -> duckdb_file_open_options {
+    let function_ptr = __DUCKDB_CREATE_FILE_OPEN_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() -> duckdb_file_open_options = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_FILE_OPEN_OPTIONS_SET_FLAG: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_open_options_set_flag(
+    options: duckdb_file_open_options,
+    flag: duckdb_file_flag,
+    value: bool,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_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_file_open_options,
+        flag: duckdb_file_flag,
+        value: bool,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(options, flag, value)
+}
+
+static __DUCKDB_DESTROY_FILE_OPEN_OPTIONS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_file_open_options(options: *mut duckdb_file_open_options) {
+    let function_ptr = __DUCKDB_DESTROY_FILE_OPEN_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(options: *mut duckdb_file_open_options) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(options)
+}
+
+static __DUCKDB_DESTROY_FILE_HANDLE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_file_handle(file_handle: *mut duckdb_file_handle) {
+    let function_ptr = __DUCKDB_DESTROY_FILE_HANDLE
+        .load(::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_handle: *mut duckdb_file_handle) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(file_handle)
+}
+
+static __DUCKDB_FILE_HANDLE_ERROR_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_handle_error_data(
+    file_handle: duckdb_file_handle,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_FILE_HANDLE_ERROR_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(
+        file_handle: duckdb_file_handle,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(file_handle)
+}
+
+static __DUCKDB_FILE_HANDLE_CLOSE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_handle_close(file_handle: duckdb_file_handle) -> duckdb_state {
+    let function_ptr = __DUCKDB_FILE_HANDLE_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_handle: duckdb_file_handle) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(file_handle)
+}
+
+static __DUCKDB_FILE_HANDLE_READ: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_handle_read(
+    file_handle: duckdb_file_handle,
+    buffer: *mut ::std::os::raw::c_void,
+    size: i64,
+) -> i64 {
+    let function_ptr = __DUCKDB_FILE_HANDLE_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_handle: duckdb_file_handle,
+        buffer: *mut ::std::os::raw::c_void,
+        size: i64,
+    ) -> i64 = ::std::mem::transmute(function_ptr);
+    (fun)(file_handle, buffer, size)
+}
+
+static __DUCKDB_FILE_HANDLE_WRITE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_handle_write(
+    file_handle: duckdb_file_handle,
+    buffer: *const ::std::os::raw::c_void,
+    size: i64,
+) -> i64 {
+    let function_ptr = __DUCKDB_FILE_HANDLE_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_handle: duckdb_file_handle,
+        buffer: *const ::std::os::raw::c_void,
+        size: i64,
+    ) -> i64 = ::std::mem::transmute(function_ptr);
+    (fun)(file_handle, buffer, size)
+}
+
+static __DUCKDB_FILE_HANDLE_SEEK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_handle_seek(
+    file_handle: duckdb_file_handle,
+    position: i64,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_FILE_HANDLE_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_handle: duckdb_file_handle,
+        position: i64,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(file_handle, position)
+}
+
+static __DUCKDB_FILE_HANDLE_TELL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_handle_tell(file_handle: duckdb_file_handle) -> i64 {
+    let function_ptr = __DUCKDB_FILE_HANDLE_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_handle: duckdb_file_handle) -> i64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(file_handle)
+}
+
+static __DUCKDB_FILE_HANDLE_SYNC: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_handle_sync(file_handle: duckdb_file_handle) -> duckdb_state {
+    let function_ptr = __DUCKDB_FILE_HANDLE_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_handle: duckdb_file_handle) -> duckdb_state = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(file_handle)
+}
+
+static __DUCKDB_FILE_HANDLE_SIZE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_file_handle_size(file_handle: duckdb_file_handle) -> i64 {
+    let function_ptr = __DUCKDB_FILE_HANDLE_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_handle: duckdb_file_handle) -> i64 = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(file_handle)
+}
+
+static __DUCKDB_GEOMETRY_TYPE_GET_CRS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_geometry_type_get_crs(
+    type_: duckdb_logical_type,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_GEOMETRY_TYPE_GET_CRS
+        .load(::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_logical_type,
+    ) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(type_)
+}
+
+static __DUCKDB_CREATE_LOG_STORAGE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_log_storage() -> duckdb_log_storage {
+    let function_ptr = __DUCKDB_CREATE_LOG_STORAGE
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn() -> duckdb_log_storage = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)()
+}
+
+static __DUCKDB_DESTROY_LOG_STORAGE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_log_storage(log_storage: *mut duckdb_log_storage) {
+    let function_ptr = __DUCKDB_DESTROY_LOG_STORAGE
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(log_storage: *mut duckdb_log_storage) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(log_storage)
+}
+
+static __DUCKDB_LOG_STORAGE_SET_WRITE_LOG_ENTRY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_log_storage_set_write_log_entry(
+    log_storage: duckdb_log_storage,
+    function: duckdb_logger_write_log_entry_t,
+) {
+    let function_ptr = __DUCKDB_LOG_STORAGE_SET_WRITE_LOG_ENTRY
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        log_storage: duckdb_log_storage,
+        function: duckdb_logger_write_log_entry_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(log_storage, function)
+}
+
+static __DUCKDB_LOG_STORAGE_SET_EXTRA_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_log_storage_set_extra_data(
+    log_storage: duckdb_log_storage,
+    extra_data: *mut ::std::os::raw::c_void,
+    delete_callback: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_LOG_STORAGE_SET_EXTRA_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(
+        log_storage: duckdb_log_storage,
+        extra_data: *mut ::std::os::raw::c_void,
+        delete_callback: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(log_storage, extra_data, delete_callback)
+}
+
+static __DUCKDB_LOG_STORAGE_SET_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_log_storage_set_name(
+    log_storage: duckdb_log_storage,
+    name: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_LOG_STORAGE_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(
+        log_storage: duckdb_log_storage,
+        name: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(log_storage, name)
+}
+
+static __DUCKDB_REGISTER_LOG_STORAGE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_register_log_storage(
+    database: duckdb_database,
+    log_storage: duckdb_log_storage,
+) -> duckdb_state {
+    let function_ptr = __DUCKDB_REGISTER_LOG_STORAGE
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        database: duckdb_database,
+        log_storage: duckdb_log_storage,
+    ) -> duckdb_state = ::std::mem::transmute(function_ptr);
+    (fun)(database, log_storage)
+}
+
+static __DUCKDB_CLIENT_CONTEXT_GET_CONNECTION_ID: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_client_context_get_connection_id(
+    context: duckdb_client_context,
+) -> idx_t {
+    let function_ptr = __DUCKDB_CLIENT_CONTEXT_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(context: duckdb_client_context) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(context)
+}
+
+static __DUCKDB_DESTROY_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_client_context(context: *mut duckdb_client_context) {
+    let function_ptr = __DUCKDB_DESTROY_CLIENT_CONTEXT
+        .load(::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: *mut duckdb_client_context) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(context)
+}
+
+static __DUCKDB_CONNECTION_GET_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_connection_get_client_context(
+    connection: duckdb_connection,
+    out_context: *mut duckdb_client_context,
+) {
+    let function_ptr = __DUCKDB_CONNECTION_GET_CLIENT_CONTEXT
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        connection: duckdb_connection,
+        out_context: *mut duckdb_client_context,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(connection, out_context)
+}
+
+static __DUCKDB_GET_TABLE_NAMES: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_table_names(
+    connection: duckdb_connection,
+    query: *const ::std::os::raw::c_char,
+    qualified: bool,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_GET_TABLE_NAMES
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        connection: duckdb_connection,
+        query: *const ::std::os::raw::c_char,
+        qualified: bool,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(connection, query, qualified)
+}
+
+static __DUCKDB_CONNECTION_GET_ARROW_OPTIONS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_connection_get_arrow_options(
+    connection: duckdb_connection,
+    out_arrow_options: *mut duckdb_arrow_options,
+) {
+    let function_ptr = __DUCKDB_CONNECTION_GET_ARROW_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(
+        connection: duckdb_connection,
+        out_arrow_options: *mut duckdb_arrow_options,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(connection, out_arrow_options)
+}
+
+static __DUCKDB_DESTROY_ARROW_OPTIONS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_arrow_options(arrow_options: *mut duckdb_arrow_options) {
+    let function_ptr = __DUCKDB_DESTROY_ARROW_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(arrow_options: *mut duckdb_arrow_options) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(arrow_options)
+}
+
+static __DUCKDB_PREPARED_STATEMENT_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_prepared_statement_column_count(
+    prepared_statement: duckdb_prepared_statement,
+) -> idx_t {
+    let function_ptr = __DUCKDB_PREPARED_STATEMENT_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(
+        prepared_statement: duckdb_prepared_statement,
+    ) -> idx_t = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement)
+}
+
+static __DUCKDB_PREPARED_STATEMENT_COLUMN_NAME: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_prepared_statement_column_name(
+    prepared_statement: duckdb_prepared_statement,
+    col_idx: idx_t,
+) -> *const ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_PREPARED_STATEMENT_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(
+        prepared_statement: duckdb_prepared_statement,
+        col_idx: idx_t,
+    ) -> *const ::std::os::raw::c_char = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, col_idx)
+}
+
+static __DUCKDB_PREPARED_STATEMENT_COLUMN_LOGICAL_TYPE: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_prepared_statement_column_logical_type(
+    prepared_statement: duckdb_prepared_statement,
+    col_idx: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_PREPARED_STATEMENT_COLUMN_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(
+        prepared_statement: duckdb_prepared_statement,
+        col_idx: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, col_idx)
+}
+
+static __DUCKDB_PREPARED_STATEMENT_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_prepared_statement_column_type(
+    prepared_statement: duckdb_prepared_statement,
+    col_idx: idx_t,
+) -> duckdb_type {
+    let function_ptr = __DUCKDB_PREPARED_STATEMENT_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(
+        prepared_statement: duckdb_prepared_statement,
+        col_idx: idx_t,
+    ) -> duckdb_type = ::std::mem::transmute(function_ptr);
+    (fun)(prepared_statement, col_idx)
+}
+
+static __DUCKDB_RESULT_GET_ARROW_OPTIONS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_result_get_arrow_options(
+    result: *mut duckdb_result,
+) -> duckdb_arrow_options {
+    let function_ptr = __DUCKDB_RESULT_GET_ARROW_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(result: *mut duckdb_result) -> duckdb_arrow_options = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(result)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_BIND: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_bind(
+    scalar_function: duckdb_scalar_function,
+    bind: duckdb_scalar_function_bind_t,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_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(
+        scalar_function: duckdb_scalar_function,
+        bind: duckdb_scalar_function_bind_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function, bind)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_BIND_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_bind_set_error(
+    info: duckdb_bind_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_BIND_SET_ERROR
+        .load(::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_bind_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_GET_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_get_client_context(
+    info: duckdb_bind_info,
+    out_context: *mut duckdb_client_context,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_GET_CLIENT_CONTEXT
+        .load(::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_bind_info,
+        out_context: *mut duckdb_client_context,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, out_context)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_bind_data(
+    info: duckdb_bind_info,
+    bind_data: *mut ::std::os::raw::c_void,
+    destroy: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_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_bind_info,
+        bind_data: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, bind_data, destroy)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_get_bind_data(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_BIND_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_scalar_function_bind_get_extra_info(
+    info: duckdb_bind_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_BIND_GET_EXTRA_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_bind_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_BIND_GET_ARGUMENT_COUNT: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_scalar_function_bind_get_argument_count(
+    info: duckdb_bind_info,
+) -> idx_t {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_BIND_GET_ARGUMENT_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_bind_info) -> idx_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(info)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_BIND_GET_ARGUMENT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_bind_get_argument(
+    info: duckdb_bind_info,
+    index: idx_t,
+) -> duckdb_expression {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_BIND_GET_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_bind_info,
+        index: idx_t,
+    ) -> duckdb_expression = ::std::mem::transmute(function_ptr);
+    (fun)(info, index)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_BIND_DATA_COPY: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_bind_data_copy(
+    info: duckdb_bind_info,
+    copy: duckdb_copy_callback_t,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_BIND_DATA_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(
+        info: duckdb_bind_info,
+        copy: duckdb_copy_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, copy)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_GET_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_get_state(
+    info: duckdb_function_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_GET_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_function_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_SET_INIT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_set_init(
+    scalar_function: duckdb_scalar_function,
+    init: duckdb_scalar_function_init_t,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_SET_INIT
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        scalar_function: duckdb_scalar_function,
+        init: duckdb_scalar_function_init_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(scalar_function, init)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_INIT_SET_ERROR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_init_set_error(
+    info: duckdb_init_info,
+    error: *const ::std::os::raw::c_char,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_INIT_SET_ERROR
+        .load(::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_init_info,
+        error: *const ::std::os::raw::c_char,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, error)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_INIT_SET_STATE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_init_set_state(
+    info: duckdb_init_info,
+    state: *mut ::std::os::raw::c_void,
+    destroy: duckdb_delete_callback_t,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_INIT_SET_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_init_info,
+        state: *mut ::std::os::raw::c_void,
+        destroy: duckdb_delete_callback_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, state, destroy)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_INIT_GET_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_scalar_function_init_get_client_context(
+    info: duckdb_init_info,
+    out_context: *mut duckdb_client_context,
+) {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_INIT_GET_CLIENT_CONTEXT
+        .load(::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_init_info,
+        out_context: *mut duckdb_client_context,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, out_context)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_INIT_GET_BIND_DATA: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_scalar_function_init_get_bind_data(
+    info: duckdb_init_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_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_init_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_SCALAR_FUNCTION_INIT_GET_EXTRA_INFO: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_scalar_function_init_get_extra_info(
+    info: duckdb_init_info,
+) -> *mut ::std::os::raw::c_void {
+    let function_ptr = __DUCKDB_SCALAR_FUNCTION_INIT_GET_EXTRA_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_init_info,
+    ) -> *mut ::std::os::raw::c_void = ::std::mem::transmute(function_ptr);
+    (fun)(info)
+}
+
+static __DUCKDB_VALUE_TO_STRING: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_value_to_string(
+    value: duckdb_value,
+) -> *mut ::std::os::raw::c_char {
+    let function_ptr = __DUCKDB_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_value) -> *mut ::std::os::raw::c_char = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(value)
+}
+
+static __DUCKDB_VALID_UTF8_CHECK: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_valid_utf8_check(
+    str_: *const ::std::os::raw::c_char,
+    len: idx_t,
+) -> duckdb_error_data {
+    let function_ptr = __DUCKDB_VALID_UTF8_CHECK
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        str_: *const ::std::os::raw::c_char,
+        len: idx_t,
+    ) -> duckdb_error_data = ::std::mem::transmute(function_ptr);
+    (fun)(str_, len)
+}
+
+static __DUCKDB_TABLE_DESCRIPTION_GET_COLUMN_COUNT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_description_get_column_count(
+    table_description: duckdb_table_description,
+) -> idx_t {
+    let function_ptr = __DUCKDB_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(
+        table_description: duckdb_table_description,
+    ) -> idx_t = ::std::mem::transmute(function_ptr);
+    (fun)(table_description)
+}
+
+static __DUCKDB_TABLE_DESCRIPTION_GET_COLUMN_TYPE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_description_get_column_type(
+    table_description: duckdb_table_description,
+    index: idx_t,
+) -> duckdb_logical_type {
+    let function_ptr = __DUCKDB_TABLE_DESCRIPTION_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(
+        table_description: duckdb_table_description,
+        index: idx_t,
+    ) -> duckdb_logical_type = ::std::mem::transmute(function_ptr);
+    (fun)(table_description, index)
+}
+
+static __DUCKDB_TABLE_FUNCTION_GET_CLIENT_CONTEXT: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_table_function_get_client_context(
+    info: duckdb_bind_info,
+    out_context: *mut duckdb_client_context,
+) {
+    let function_ptr = __DUCKDB_TABLE_FUNCTION_GET_CLIENT_CONTEXT
+        .load(::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_bind_info,
+        out_context: *mut duckdb_client_context,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(info, out_context)
+}
+
+static __DUCKDB_CREATE_MAP_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_map_value(
+    map_type: duckdb_logical_type,
+    keys: *mut duckdb_value,
+    values: *mut duckdb_value,
+    entry_count: idx_t,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_MAP_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(
+        map_type: duckdb_logical_type,
+        keys: *mut duckdb_value,
+        values: *mut duckdb_value,
+        entry_count: idx_t,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(map_type, keys, values, entry_count)
+}
+
+static __DUCKDB_CREATE_UNION_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_union_value(
+    union_type: duckdb_logical_type,
+    tag_index: idx_t,
+    value: duckdb_value,
+) -> duckdb_value {
+    let function_ptr = __DUCKDB_CREATE_UNION_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(
+        union_type: duckdb_logical_type,
+        tag_index: idx_t,
+        value: duckdb_value,
+    ) -> duckdb_value = ::std::mem::transmute(function_ptr);
+    (fun)(union_type, tag_index, value)
+}
+
+static __DUCKDB_CREATE_TIME_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_time_ns(input: duckdb_time_ns) -> duckdb_value {
+    let function_ptr = __DUCKDB_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(input: duckdb_time_ns) -> duckdb_value = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(input)
+}
+
+static __DUCKDB_GET_TIME_NS: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_get_time_ns(val: duckdb_value) -> duckdb_time_ns {
+    let function_ptr = __DUCKDB_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(val: duckdb_value) -> duckdb_time_ns = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(val)
+}
+
+static __DUCKDB_CREATE_VECTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_vector(
+    type_: duckdb_logical_type,
+    capacity: idx_t,
+) -> duckdb_vector {
+    let function_ptr = __DUCKDB_CREATE_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(
+        type_: duckdb_logical_type,
+        capacity: idx_t,
+    ) -> duckdb_vector = ::std::mem::transmute(function_ptr);
+    (fun)(type_, capacity)
+}
+
+static __DUCKDB_DESTROY_VECTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_vector(vector: *mut duckdb_vector) {
+    let function_ptr = __DUCKDB_DESTROY_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(vector: *mut duckdb_vector) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector)
+}
+
+static __DUCKDB_SLICE_VECTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_slice_vector(
+    vector: duckdb_vector,
+    sel: duckdb_selection_vector,
+    len: idx_t,
+) {
+    let function_ptr = __DUCKDB_SLICE_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(
+        vector: duckdb_vector,
+        sel: duckdb_selection_vector,
+        len: idx_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(vector, sel, len)
+}
+
+static __DUCKDB_VECTOR_REFERENCE_VALUE: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_reference_value(vector: duckdb_vector, value: duckdb_value) {
+    let function_ptr = __DUCKDB_VECTOR_REFERENCE_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_vector, value: duckdb_value) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(vector, value)
+}
+
+static __DUCKDB_VECTOR_REFERENCE_VECTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_reference_vector(
+    to_vector: duckdb_vector,
+    from_vector: duckdb_vector,
+) {
+    let function_ptr = __DUCKDB_VECTOR_REFERENCE_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(
+        to_vector: duckdb_vector,
+        from_vector: duckdb_vector,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(to_vector, from_vector)
+}
+
+static __DUCKDB_CREATE_SELECTION_VECTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_create_selection_vector(size: idx_t) -> duckdb_selection_vector {
+    let function_ptr = __DUCKDB_CREATE_SELECTION_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(size: idx_t) -> duckdb_selection_vector = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(size)
+}
+
+static __DUCKDB_DESTROY_SELECTION_VECTOR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_destroy_selection_vector(sel: duckdb_selection_vector) {
+    let function_ptr = __DUCKDB_DESTROY_SELECTION_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(sel: duckdb_selection_vector) = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(sel)
+}
+
+static __DUCKDB_SELECTION_VECTOR_GET_DATA_PTR: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_selection_vector_get_data_ptr(
+    sel: duckdb_selection_vector,
+) -> *mut sel_t {
+    let function_ptr = __DUCKDB_SELECTION_VECTOR_GET_DATA_PTR
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(sel: duckdb_selection_vector) -> *mut sel_t = ::std::mem::transmute(
+        function_ptr,
+    );
+    (fun)(sel)
+}
+
+static __DUCKDB_VECTOR_COPY_SEL: ::std::sync::atomic::AtomicPtr<()> = ::std::sync::atomic::AtomicPtr::new(
+    ::std::ptr::null_mut(),
+);
+pub unsafe fn duckdb_vector_copy_sel(
+    src: duckdb_vector,
+    dst: duckdb_vector,
+    sel: duckdb_selection_vector,
+    src_count: idx_t,
+    src_offset: idx_t,
+    dst_offset: idx_t,
+) {
+    let function_ptr = __DUCKDB_VECTOR_COPY_SEL
+        .load(::std::sync::atomic::Ordering::Acquire);
+    assert!(
+        ! function_ptr.is_null(), "DuckDB API not initialized or DuckDB feature omitted"
+    );
+    let fun: unsafe extern "C" fn(
+        src: duckdb_vector,
+        dst: duckdb_vector,
+        sel: duckdb_selection_vector,
+        src_count: idx_t,
+        src_offset: idx_t,
+        dst_offset: idx_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(src, dst, sel, src_count, src_offset, dst_offset)
+}
+
+static __DUCKDB_UNSAFE_VECTOR_ASSIGN_STRING_ELEMENT_LEN: ::std::sync::atomic::AtomicPtr<
+    (),
+> = ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut());
+pub unsafe fn duckdb_unsafe_vector_assign_string_element_len(
+    vector: duckdb_vector,
+    index: idx_t,
+    str_: *const ::std::os::raw::c_char,
+    str_len: idx_t,
+) {
+    let function_ptr = __DUCKDB_UNSAFE_VECTOR_ASSIGN_STRING_ELEMENT_LEN
+        .load(::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_vector,
+        index: idx_t,
+        str_: *const ::std::os::raw::c_char,
+        str_len: idx_t,
+    ) = ::std::mem::transmute(function_ptr);
+    (fun)(vector, index, str_, str_len)
+}
+
+/// Like DUCKDB_EXTENSION_API_INIT macro
+pub unsafe fn duckdb_rs_extension_api_init(
+    info: duckdb_extension_info,
+    access: *const duckdb_extension_access,
+    version: &str,
+) -> ::std::result::Result<bool, &'static str> {
+    let version_c_string = std::ffi::CString::new(version).unwrap();
+    let p_api = (*access).get_api.unwrap()(info, version_c_string.as_ptr())
+        as *const duckdb_ext_api_v1;
+    if p_api.is_null() {
+        return Ok(false);
+    }
+    if let Some(fun) = (*p_api).duckdb_open {
+        __DUCKDB_OPEN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_open_ext {
+        __DUCKDB_OPEN_EXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_close {
+        __DUCKDB_CLOSE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_connect {
+        __DUCKDB_CONNECT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_interrupt {
+        __DUCKDB_INTERRUPT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_query_progress {
+        __DUCKDB_QUERY_PROGRESS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_disconnect {
+        __DUCKDB_DISCONNECT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_library_version {
+        __DUCKDB_LIBRARY_VERSION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_config {
+        __DUCKDB_CREATE_CONFIG
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_config_count {
+        __DUCKDB_CONFIG_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_config_flag {
+        __DUCKDB_GET_CONFIG_FLAG
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_set_config {
+        __DUCKDB_SET_CONFIG
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_config {
+        __DUCKDB_DESTROY_CONFIG
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_query {
+        __DUCKDB_QUERY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_result {
+        __DUCKDB_DESTROY_RESULT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_column_name {
+        __DUCKDB_COLUMN_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_column_type {
+        __DUCKDB_COLUMN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_statement_type {
+        __DUCKDB_RESULT_STATEMENT_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_column_logical_type {
+        __DUCKDB_COLUMN_LOGICAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_column_count {
+        __DUCKDB_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_rows_changed {
+        __DUCKDB_ROWS_CHANGED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_error {
+        __DUCKDB_RESULT_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_error_type {
+        __DUCKDB_RESULT_ERROR_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_return_type {
+        __DUCKDB_RESULT_RETURN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_malloc {
+        __DUCKDB_MALLOC
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_free {
+        __DUCKDB_FREE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_size {
+        __DUCKDB_VECTOR_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_string_is_inlined {
+        __DUCKDB_STRING_IS_INLINED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_string_t_length {
+        __DUCKDB_STRING_T_LENGTH
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_string_t_data {
+        __DUCKDB_STRING_T_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_from_date {
+        __DUCKDB_FROM_DATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_to_date {
+        __DUCKDB_TO_DATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_is_finite_date {
+        __DUCKDB_IS_FINITE_DATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_from_time {
+        __DUCKDB_FROM_TIME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_time_tz {
+        __DUCKDB_CREATE_TIME_TZ
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_from_time_tz {
+        __DUCKDB_FROM_TIME_TZ
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_to_time {
+        __DUCKDB_TO_TIME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_from_timestamp {
+        __DUCKDB_FROM_TIMESTAMP
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_to_timestamp {
+        __DUCKDB_TO_TIMESTAMP
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_is_finite_timestamp {
+        __DUCKDB_IS_FINITE_TIMESTAMP
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_hugeint_to_double {
+        __DUCKDB_HUGEINT_TO_DOUBLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_double_to_hugeint {
+        __DUCKDB_DOUBLE_TO_HUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_uhugeint_to_double {
+        __DUCKDB_UHUGEINT_TO_DOUBLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_double_to_uhugeint {
+        __DUCKDB_DOUBLE_TO_UHUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_double_to_decimal {
+        __DUCKDB_DOUBLE_TO_DECIMAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_decimal_to_double {
+        __DUCKDB_DECIMAL_TO_DOUBLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepare {
+        __DUCKDB_PREPARE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_prepare {
+        __DUCKDB_DESTROY_PREPARE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepare_error {
+        __DUCKDB_PREPARE_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_nparams {
+        __DUCKDB_NPARAMS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_parameter_name {
+        __DUCKDB_PARAMETER_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_param_type {
+        __DUCKDB_PARAM_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_param_logical_type {
+        __DUCKDB_PARAM_LOGICAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_clear_bindings {
+        __DUCKDB_CLEAR_BINDINGS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepared_statement_type {
+        __DUCKDB_PREPARED_STATEMENT_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_value {
+        __DUCKDB_BIND_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_parameter_index {
+        __DUCKDB_BIND_PARAMETER_INDEX
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_boolean {
+        __DUCKDB_BIND_BOOLEAN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_int8 {
+        __DUCKDB_BIND_INT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_int16 {
+        __DUCKDB_BIND_INT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_int32 {
+        __DUCKDB_BIND_INT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_int64 {
+        __DUCKDB_BIND_INT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_hugeint {
+        __DUCKDB_BIND_HUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_uhugeint {
+        __DUCKDB_BIND_UHUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_decimal {
+        __DUCKDB_BIND_DECIMAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_uint8 {
+        __DUCKDB_BIND_UINT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_uint16 {
+        __DUCKDB_BIND_UINT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_uint32 {
+        __DUCKDB_BIND_UINT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_uint64 {
+        __DUCKDB_BIND_UINT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_float {
+        __DUCKDB_BIND_FLOAT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_double {
+        __DUCKDB_BIND_DOUBLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_date {
+        __DUCKDB_BIND_DATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_time {
+        __DUCKDB_BIND_TIME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_timestamp {
+        __DUCKDB_BIND_TIMESTAMP
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_timestamp_tz {
+        __DUCKDB_BIND_TIMESTAMP_TZ
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_interval {
+        __DUCKDB_BIND_INTERVAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_varchar {
+        __DUCKDB_BIND_VARCHAR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_varchar_length {
+        __DUCKDB_BIND_VARCHAR_LENGTH
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_blob {
+        __DUCKDB_BIND_BLOB
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_null {
+        __DUCKDB_BIND_NULL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_execute_prepared {
+        __DUCKDB_EXECUTE_PREPARED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_extract_statements {
+        __DUCKDB_EXTRACT_STATEMENTS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepare_extracted_statement {
+        __DUCKDB_PREPARE_EXTRACTED_STATEMENT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_extract_statements_error {
+        __DUCKDB_EXTRACT_STATEMENTS_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_extracted {
+        __DUCKDB_DESTROY_EXTRACTED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_pending_prepared {
+        __DUCKDB_PENDING_PREPARED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_pending {
+        __DUCKDB_DESTROY_PENDING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_pending_error {
+        __DUCKDB_PENDING_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_pending_execute_task {
+        __DUCKDB_PENDING_EXECUTE_TASK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_pending_execute_check_state {
+        __DUCKDB_PENDING_EXECUTE_CHECK_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_execute_pending {
+        __DUCKDB_EXECUTE_PENDING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_pending_execution_is_finished {
+        __DUCKDB_PENDING_EXECUTION_IS_FINISHED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_value {
+        __DUCKDB_DESTROY_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_varchar {
+        __DUCKDB_CREATE_VARCHAR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_varchar_length {
+        __DUCKDB_CREATE_VARCHAR_LENGTH
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_bool {
+        __DUCKDB_CREATE_BOOL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_int8 {
+        __DUCKDB_CREATE_INT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_uint8 {
+        __DUCKDB_CREATE_UINT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_int16 {
+        __DUCKDB_CREATE_INT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_uint16 {
+        __DUCKDB_CREATE_UINT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_int32 {
+        __DUCKDB_CREATE_INT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_uint32 {
+        __DUCKDB_CREATE_UINT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_uint64 {
+        __DUCKDB_CREATE_UINT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_int64 {
+        __DUCKDB_CREATE_INT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_hugeint {
+        __DUCKDB_CREATE_HUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_uhugeint {
+        __DUCKDB_CREATE_UHUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_float {
+        __DUCKDB_CREATE_FLOAT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_double {
+        __DUCKDB_CREATE_DOUBLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_date {
+        __DUCKDB_CREATE_DATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_time {
+        __DUCKDB_CREATE_TIME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_time_tz_value {
+        __DUCKDB_CREATE_TIME_TZ_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_timestamp {
+        __DUCKDB_CREATE_TIMESTAMP
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_interval {
+        __DUCKDB_CREATE_INTERVAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_blob {
+        __DUCKDB_CREATE_BLOB
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_bignum {
+        __DUCKDB_CREATE_BIGNUM
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_decimal {
+        __DUCKDB_CREATE_DECIMAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_bit {
+        __DUCKDB_CREATE_BIT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_uuid {
+        __DUCKDB_CREATE_UUID
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_bool {
+        __DUCKDB_GET_BOOL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_int8 {
+        __DUCKDB_GET_INT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_uint8 {
+        __DUCKDB_GET_UINT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_int16 {
+        __DUCKDB_GET_INT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_uint16 {
+        __DUCKDB_GET_UINT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_int32 {
+        __DUCKDB_GET_INT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_uint32 {
+        __DUCKDB_GET_UINT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_int64 {
+        __DUCKDB_GET_INT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_uint64 {
+        __DUCKDB_GET_UINT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_hugeint {
+        __DUCKDB_GET_HUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_uhugeint {
+        __DUCKDB_GET_UHUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_float {
+        __DUCKDB_GET_FLOAT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_double {
+        __DUCKDB_GET_DOUBLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_date {
+        __DUCKDB_GET_DATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_time {
+        __DUCKDB_GET_TIME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_time_tz {
+        __DUCKDB_GET_TIME_TZ
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_timestamp {
+        __DUCKDB_GET_TIMESTAMP
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_interval {
+        __DUCKDB_GET_INTERVAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_value_type {
+        __DUCKDB_GET_VALUE_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_blob {
+        __DUCKDB_GET_BLOB
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_bignum {
+        __DUCKDB_GET_BIGNUM
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_decimal {
+        __DUCKDB_GET_DECIMAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_bit {
+        __DUCKDB_GET_BIT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_uuid {
+        __DUCKDB_GET_UUID
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_varchar {
+        __DUCKDB_GET_VARCHAR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_struct_value {
+        __DUCKDB_CREATE_STRUCT_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_list_value {
+        __DUCKDB_CREATE_LIST_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_array_value {
+        __DUCKDB_CREATE_ARRAY_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_map_size {
+        __DUCKDB_GET_MAP_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_map_key {
+        __DUCKDB_GET_MAP_KEY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_map_value {
+        __DUCKDB_GET_MAP_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_is_null_value {
+        __DUCKDB_IS_NULL_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_null_value {
+        __DUCKDB_CREATE_NULL_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_list_size {
+        __DUCKDB_GET_LIST_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_list_child {
+        __DUCKDB_GET_LIST_CHILD
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_enum_value {
+        __DUCKDB_CREATE_ENUM_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_enum_value {
+        __DUCKDB_GET_ENUM_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_struct_child {
+        __DUCKDB_GET_STRUCT_CHILD
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_logical_type {
+        __DUCKDB_CREATE_LOGICAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_logical_type_get_alias {
+        __DUCKDB_LOGICAL_TYPE_GET_ALIAS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_logical_type_set_alias {
+        __DUCKDB_LOGICAL_TYPE_SET_ALIAS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_list_type {
+        __DUCKDB_CREATE_LIST_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_array_type {
+        __DUCKDB_CREATE_ARRAY_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_map_type {
+        __DUCKDB_CREATE_MAP_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_union_type {
+        __DUCKDB_CREATE_UNION_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_struct_type {
+        __DUCKDB_CREATE_STRUCT_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_enum_type {
+        __DUCKDB_CREATE_ENUM_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_decimal_type {
+        __DUCKDB_CREATE_DECIMAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_type_id {
+        __DUCKDB_GET_TYPE_ID
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_decimal_width {
+        __DUCKDB_DECIMAL_WIDTH
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_decimal_scale {
+        __DUCKDB_DECIMAL_SCALE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_decimal_internal_type {
+        __DUCKDB_DECIMAL_INTERNAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_enum_internal_type {
+        __DUCKDB_ENUM_INTERNAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_enum_dictionary_size {
+        __DUCKDB_ENUM_DICTIONARY_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_enum_dictionary_value {
+        __DUCKDB_ENUM_DICTIONARY_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_list_type_child_type {
+        __DUCKDB_LIST_TYPE_CHILD_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_array_type_child_type {
+        __DUCKDB_ARRAY_TYPE_CHILD_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_array_type_array_size {
+        __DUCKDB_ARRAY_TYPE_ARRAY_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_map_type_key_type {
+        __DUCKDB_MAP_TYPE_KEY_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_map_type_value_type {
+        __DUCKDB_MAP_TYPE_VALUE_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_struct_type_child_count {
+        __DUCKDB_STRUCT_TYPE_CHILD_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_struct_type_child_name {
+        __DUCKDB_STRUCT_TYPE_CHILD_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_struct_type_child_type {
+        __DUCKDB_STRUCT_TYPE_CHILD_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_union_type_member_count {
+        __DUCKDB_UNION_TYPE_MEMBER_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_union_type_member_name {
+        __DUCKDB_UNION_TYPE_MEMBER_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_union_type_member_type {
+        __DUCKDB_UNION_TYPE_MEMBER_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_logical_type {
+        __DUCKDB_DESTROY_LOGICAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_logical_type {
+        __DUCKDB_REGISTER_LOGICAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_data_chunk {
+        __DUCKDB_CREATE_DATA_CHUNK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_data_chunk {
+        __DUCKDB_DESTROY_DATA_CHUNK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_data_chunk_reset {
+        __DUCKDB_DATA_CHUNK_RESET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_data_chunk_get_column_count {
+        __DUCKDB_DATA_CHUNK_GET_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_data_chunk_get_vector {
+        __DUCKDB_DATA_CHUNK_GET_VECTOR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_data_chunk_get_size {
+        __DUCKDB_DATA_CHUNK_GET_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_data_chunk_set_size {
+        __DUCKDB_DATA_CHUNK_SET_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_get_column_type {
+        __DUCKDB_VECTOR_GET_COLUMN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_get_data {
+        __DUCKDB_VECTOR_GET_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_get_validity {
+        __DUCKDB_VECTOR_GET_VALIDITY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_ensure_validity_writable {
+        __DUCKDB_VECTOR_ENSURE_VALIDITY_WRITABLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_assign_string_element {
+        __DUCKDB_VECTOR_ASSIGN_STRING_ELEMENT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_assign_string_element_len {
+        __DUCKDB_VECTOR_ASSIGN_STRING_ELEMENT_LEN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_list_vector_get_child {
+        __DUCKDB_LIST_VECTOR_GET_CHILD
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_list_vector_get_size {
+        __DUCKDB_LIST_VECTOR_GET_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_list_vector_set_size {
+        __DUCKDB_LIST_VECTOR_SET_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_list_vector_reserve {
+        __DUCKDB_LIST_VECTOR_RESERVE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_struct_vector_get_child {
+        __DUCKDB_STRUCT_VECTOR_GET_CHILD
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_array_vector_get_child {
+        __DUCKDB_ARRAY_VECTOR_GET_CHILD
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_validity_row_is_valid {
+        __DUCKDB_VALIDITY_ROW_IS_VALID
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_validity_set_row_validity {
+        __DUCKDB_VALIDITY_SET_ROW_VALIDITY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_validity_set_row_invalid {
+        __DUCKDB_VALIDITY_SET_ROW_INVALID
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_validity_set_row_valid {
+        __DUCKDB_VALIDITY_SET_ROW_VALID
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_scalar_function {
+        __DUCKDB_CREATE_SCALAR_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_scalar_function {
+        __DUCKDB_DESTROY_SCALAR_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_name {
+        __DUCKDB_SCALAR_FUNCTION_SET_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_varargs {
+        __DUCKDB_SCALAR_FUNCTION_SET_VARARGS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_special_handling {
+        __DUCKDB_SCALAR_FUNCTION_SET_SPECIAL_HANDLING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_volatile {
+        __DUCKDB_SCALAR_FUNCTION_SET_VOLATILE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_add_parameter {
+        __DUCKDB_SCALAR_FUNCTION_ADD_PARAMETER
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_return_type {
+        __DUCKDB_SCALAR_FUNCTION_SET_RETURN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_extra_info {
+        __DUCKDB_SCALAR_FUNCTION_SET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_function {
+        __DUCKDB_SCALAR_FUNCTION_SET_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_scalar_function {
+        __DUCKDB_REGISTER_SCALAR_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_get_extra_info {
+        __DUCKDB_SCALAR_FUNCTION_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_error {
+        __DUCKDB_SCALAR_FUNCTION_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_scalar_function_set {
+        __DUCKDB_CREATE_SCALAR_FUNCTION_SET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_scalar_function_set {
+        __DUCKDB_DESTROY_SCALAR_FUNCTION_SET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_add_scalar_function_to_set {
+        __DUCKDB_ADD_SCALAR_FUNCTION_TO_SET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_scalar_function_set {
+        __DUCKDB_REGISTER_SCALAR_FUNCTION_SET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_aggregate_function {
+        __DUCKDB_CREATE_AGGREGATE_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_aggregate_function {
+        __DUCKDB_DESTROY_AGGREGATE_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_set_name {
+        __DUCKDB_AGGREGATE_FUNCTION_SET_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_add_parameter {
+        __DUCKDB_AGGREGATE_FUNCTION_ADD_PARAMETER
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_set_return_type {
+        __DUCKDB_AGGREGATE_FUNCTION_SET_RETURN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_set_functions {
+        __DUCKDB_AGGREGATE_FUNCTION_SET_FUNCTIONS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_set_destructor {
+        __DUCKDB_AGGREGATE_FUNCTION_SET_DESTRUCTOR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_aggregate_function {
+        __DUCKDB_REGISTER_AGGREGATE_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_set_special_handling {
+        __DUCKDB_AGGREGATE_FUNCTION_SET_SPECIAL_HANDLING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_set_extra_info {
+        __DUCKDB_AGGREGATE_FUNCTION_SET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_get_extra_info {
+        __DUCKDB_AGGREGATE_FUNCTION_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_aggregate_function_set_error {
+        __DUCKDB_AGGREGATE_FUNCTION_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_aggregate_function_set {
+        __DUCKDB_CREATE_AGGREGATE_FUNCTION_SET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_aggregate_function_set {
+        __DUCKDB_DESTROY_AGGREGATE_FUNCTION_SET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_add_aggregate_function_to_set {
+        __DUCKDB_ADD_AGGREGATE_FUNCTION_TO_SET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_aggregate_function_set {
+        __DUCKDB_REGISTER_AGGREGATE_FUNCTION_SET
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_table_function {
+        __DUCKDB_CREATE_TABLE_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_table_function {
+        __DUCKDB_DESTROY_TABLE_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_set_name {
+        __DUCKDB_TABLE_FUNCTION_SET_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_add_parameter {
+        __DUCKDB_TABLE_FUNCTION_ADD_PARAMETER
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_add_named_parameter {
+        __DUCKDB_TABLE_FUNCTION_ADD_NAMED_PARAMETER
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_set_extra_info {
+        __DUCKDB_TABLE_FUNCTION_SET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_set_bind {
+        __DUCKDB_TABLE_FUNCTION_SET_BIND
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_set_init {
+        __DUCKDB_TABLE_FUNCTION_SET_INIT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_set_local_init {
+        __DUCKDB_TABLE_FUNCTION_SET_LOCAL_INIT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_set_function {
+        __DUCKDB_TABLE_FUNCTION_SET_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_supports_projection_pushdown {
+        __DUCKDB_TABLE_FUNCTION_SUPPORTS_PROJECTION_PUSHDOWN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_table_function {
+        __DUCKDB_REGISTER_TABLE_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_get_extra_info {
+        __DUCKDB_BIND_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_add_result_column {
+        __DUCKDB_BIND_ADD_RESULT_COLUMN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_get_parameter_count {
+        __DUCKDB_BIND_GET_PARAMETER_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_get_parameter {
+        __DUCKDB_BIND_GET_PARAMETER
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_get_named_parameter {
+        __DUCKDB_BIND_GET_NAMED_PARAMETER
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_set_bind_data {
+        __DUCKDB_BIND_SET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_set_cardinality {
+        __DUCKDB_BIND_SET_CARDINALITY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_bind_set_error {
+        __DUCKDB_BIND_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_init_get_extra_info {
+        __DUCKDB_INIT_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_init_get_bind_data {
+        __DUCKDB_INIT_GET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_init_set_init_data {
+        __DUCKDB_INIT_SET_INIT_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_init_get_column_count {
+        __DUCKDB_INIT_GET_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_init_get_column_index {
+        __DUCKDB_INIT_GET_COLUMN_INDEX
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_init_set_max_threads {
+        __DUCKDB_INIT_SET_MAX_THREADS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_init_set_error {
+        __DUCKDB_INIT_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_function_get_extra_info {
+        __DUCKDB_FUNCTION_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_function_get_bind_data {
+        __DUCKDB_FUNCTION_GET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_function_get_init_data {
+        __DUCKDB_FUNCTION_GET_INIT_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_function_get_local_init_data {
+        __DUCKDB_FUNCTION_GET_LOCAL_INIT_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_function_set_error {
+        __DUCKDB_FUNCTION_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_add_replacement_scan {
+        __DUCKDB_ADD_REPLACEMENT_SCAN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_replacement_scan_set_function_name {
+        __DUCKDB_REPLACEMENT_SCAN_SET_FUNCTION_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_replacement_scan_add_parameter {
+        __DUCKDB_REPLACEMENT_SCAN_ADD_PARAMETER
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_replacement_scan_set_error {
+        __DUCKDB_REPLACEMENT_SCAN_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_profiling_info_get_metrics {
+        __DUCKDB_PROFILING_INFO_GET_METRICS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_profiling_info_get_child_count {
+        __DUCKDB_PROFILING_INFO_GET_CHILD_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_profiling_info_get_child {
+        __DUCKDB_PROFILING_INFO_GET_CHILD
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_create {
+        __DUCKDB_APPENDER_CREATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_create_ext {
+        __DUCKDB_APPENDER_CREATE_EXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_column_count {
+        __DUCKDB_APPENDER_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_column_type {
+        __DUCKDB_APPENDER_COLUMN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_error {
+        __DUCKDB_APPENDER_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_flush {
+        __DUCKDB_APPENDER_FLUSH
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_close {
+        __DUCKDB_APPENDER_CLOSE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_destroy {
+        __DUCKDB_APPENDER_DESTROY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_add_column {
+        __DUCKDB_APPENDER_ADD_COLUMN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_clear_columns {
+        __DUCKDB_APPENDER_CLEAR_COLUMNS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_data_chunk {
+        __DUCKDB_APPEND_DATA_CHUNK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_description_create {
+        __DUCKDB_TABLE_DESCRIPTION_CREATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_description_create_ext {
+        __DUCKDB_TABLE_DESCRIPTION_CREATE_EXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_description_destroy {
+        __DUCKDB_TABLE_DESCRIPTION_DESTROY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_description_error {
+        __DUCKDB_TABLE_DESCRIPTION_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_column_has_default {
+        __DUCKDB_COLUMN_HAS_DEFAULT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_description_get_column_name {
+        __DUCKDB_TABLE_DESCRIPTION_GET_COLUMN_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_execute_tasks {
+        __DUCKDB_EXECUTE_TASKS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_task_state {
+        __DUCKDB_CREATE_TASK_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_execute_tasks_state {
+        __DUCKDB_EXECUTE_TASKS_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_execute_n_tasks_state {
+        __DUCKDB_EXECUTE_N_TASKS_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_finish_execution {
+        __DUCKDB_FINISH_EXECUTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_task_state_is_finished {
+        __DUCKDB_TASK_STATE_IS_FINISHED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_task_state {
+        __DUCKDB_DESTROY_TASK_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_execution_is_finished {
+        __DUCKDB_EXECUTION_IS_FINISHED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_fetch_chunk {
+        __DUCKDB_FETCH_CHUNK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_cast_function {
+        __DUCKDB_CREATE_CAST_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_set_source_type {
+        __DUCKDB_CAST_FUNCTION_SET_SOURCE_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_set_target_type {
+        __DUCKDB_CAST_FUNCTION_SET_TARGET_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_set_implicit_cast_cost {
+        __DUCKDB_CAST_FUNCTION_SET_IMPLICIT_CAST_COST
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_set_function {
+        __DUCKDB_CAST_FUNCTION_SET_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_set_extra_info {
+        __DUCKDB_CAST_FUNCTION_SET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_get_extra_info {
+        __DUCKDB_CAST_FUNCTION_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_get_cast_mode {
+        __DUCKDB_CAST_FUNCTION_GET_CAST_MODE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_set_error {
+        __DUCKDB_CAST_FUNCTION_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_cast_function_set_row_error {
+        __DUCKDB_CAST_FUNCTION_SET_ROW_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_cast_function {
+        __DUCKDB_REGISTER_CAST_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_cast_function {
+        __DUCKDB_DESTROY_CAST_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_is_finite_timestamp_s {
+        __DUCKDB_IS_FINITE_TIMESTAMP_S
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_is_finite_timestamp_ms {
+        __DUCKDB_IS_FINITE_TIMESTAMP_MS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_is_finite_timestamp_ns {
+        __DUCKDB_IS_FINITE_TIMESTAMP_NS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_timestamp_tz {
+        __DUCKDB_CREATE_TIMESTAMP_TZ
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_timestamp_s {
+        __DUCKDB_CREATE_TIMESTAMP_S
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_timestamp_ms {
+        __DUCKDB_CREATE_TIMESTAMP_MS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_timestamp_ns {
+        __DUCKDB_CREATE_TIMESTAMP_NS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_timestamp_tz {
+        __DUCKDB_GET_TIMESTAMP_TZ
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_timestamp_s {
+        __DUCKDB_GET_TIMESTAMP_S
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_timestamp_ms {
+        __DUCKDB_GET_TIMESTAMP_MS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_timestamp_ns {
+        __DUCKDB_GET_TIMESTAMP_NS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_value {
+        __DUCKDB_APPEND_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_profiling_info {
+        __DUCKDB_GET_PROFILING_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_profiling_info_get_value {
+        __DUCKDB_PROFILING_INFO_GET_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_begin_row {
+        __DUCKDB_APPENDER_BEGIN_ROW
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_end_row {
+        __DUCKDB_APPENDER_END_ROW
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_default {
+        __DUCKDB_APPEND_DEFAULT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_bool {
+        __DUCKDB_APPEND_BOOL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_int8 {
+        __DUCKDB_APPEND_INT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_int16 {
+        __DUCKDB_APPEND_INT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_int32 {
+        __DUCKDB_APPEND_INT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_int64 {
+        __DUCKDB_APPEND_INT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_hugeint {
+        __DUCKDB_APPEND_HUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_uint8 {
+        __DUCKDB_APPEND_UINT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_uint16 {
+        __DUCKDB_APPEND_UINT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_uint32 {
+        __DUCKDB_APPEND_UINT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_uint64 {
+        __DUCKDB_APPEND_UINT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_uhugeint {
+        __DUCKDB_APPEND_UHUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_float {
+        __DUCKDB_APPEND_FLOAT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_double {
+        __DUCKDB_APPEND_DOUBLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_date {
+        __DUCKDB_APPEND_DATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_time {
+        __DUCKDB_APPEND_TIME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_timestamp {
+        __DUCKDB_APPEND_TIMESTAMP
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_interval {
+        __DUCKDB_APPEND_INTERVAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_varchar {
+        __DUCKDB_APPEND_VARCHAR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_varchar_length {
+        __DUCKDB_APPEND_VARCHAR_LENGTH
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_blob {
+        __DUCKDB_APPEND_BLOB
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_null {
+        __DUCKDB_APPEND_NULL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_row_count {
+        __DUCKDB_ROW_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_column_data {
+        __DUCKDB_COLUMN_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_nullmask_data {
+        __DUCKDB_NULLMASK_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_get_chunk {
+        __DUCKDB_RESULT_GET_CHUNK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_is_streaming {
+        __DUCKDB_RESULT_IS_STREAMING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_chunk_count {
+        __DUCKDB_RESULT_CHUNK_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_boolean {
+        __DUCKDB_VALUE_BOOLEAN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_int8 {
+        __DUCKDB_VALUE_INT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_int16 {
+        __DUCKDB_VALUE_INT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_int32 {
+        __DUCKDB_VALUE_INT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_int64 {
+        __DUCKDB_VALUE_INT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_hugeint {
+        __DUCKDB_VALUE_HUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_uhugeint {
+        __DUCKDB_VALUE_UHUGEINT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_decimal {
+        __DUCKDB_VALUE_DECIMAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_uint8 {
+        __DUCKDB_VALUE_UINT8
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_uint16 {
+        __DUCKDB_VALUE_UINT16
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_uint32 {
+        __DUCKDB_VALUE_UINT32
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_uint64 {
+        __DUCKDB_VALUE_UINT64
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_float {
+        __DUCKDB_VALUE_FLOAT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_double {
+        __DUCKDB_VALUE_DOUBLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_date {
+        __DUCKDB_VALUE_DATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_time {
+        __DUCKDB_VALUE_TIME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_timestamp {
+        __DUCKDB_VALUE_TIMESTAMP
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_interval {
+        __DUCKDB_VALUE_INTERVAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_varchar {
+        __DUCKDB_VALUE_VARCHAR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_string {
+        __DUCKDB_VALUE_STRING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_varchar_internal {
+        __DUCKDB_VALUE_VARCHAR_INTERNAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_string_internal {
+        __DUCKDB_VALUE_STRING_INTERNAL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_blob {
+        __DUCKDB_VALUE_BLOB
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_is_null {
+        __DUCKDB_VALUE_IS_NULL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_execute_prepared_streaming {
+        __DUCKDB_EXECUTE_PREPARED_STREAMING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_pending_prepared_streaming {
+        __DUCKDB_PENDING_PREPARED_STREAMING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_query_arrow {
+        __DUCKDB_QUERY_ARROW
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_query_arrow_schema {
+        __DUCKDB_QUERY_ARROW_SCHEMA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepared_arrow_schema {
+        __DUCKDB_PREPARED_ARROW_SCHEMA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_arrow_array {
+        __DUCKDB_RESULT_ARROW_ARRAY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_query_arrow_array {
+        __DUCKDB_QUERY_ARROW_ARRAY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_arrow_column_count {
+        __DUCKDB_ARROW_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_arrow_row_count {
+        __DUCKDB_ARROW_ROW_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_arrow_rows_changed {
+        __DUCKDB_ARROW_ROWS_CHANGED
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_query_arrow_error {
+        __DUCKDB_QUERY_ARROW_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_arrow {
+        __DUCKDB_DESTROY_ARROW
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_arrow_stream {
+        __DUCKDB_DESTROY_ARROW_STREAM
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_execute_prepared_arrow {
+        __DUCKDB_EXECUTE_PREPARED_ARROW
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_arrow_scan {
+        __DUCKDB_ARROW_SCAN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_arrow_array_scan {
+        __DUCKDB_ARROW_ARRAY_SCAN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_stream_fetch_chunk {
+        __DUCKDB_STREAM_FETCH_CHUNK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_instance_cache {
+        __DUCKDB_CREATE_INSTANCE_CACHE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_or_create_from_cache {
+        __DUCKDB_GET_OR_CREATE_FROM_CACHE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_instance_cache {
+        __DUCKDB_DESTROY_INSTANCE_CACHE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_append_default_to_chunk {
+        __DUCKDB_APPEND_DEFAULT_TO_CHUNK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_error_data {
+        __DUCKDB_APPENDER_ERROR_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_create_query {
+        __DUCKDB_APPENDER_CREATE_QUERY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_appender_clear {
+        __DUCKDB_APPENDER_CLEAR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_to_arrow_schema {
+        __DUCKDB_TO_ARROW_SCHEMA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_data_chunk_to_arrow {
+        __DUCKDB_DATA_CHUNK_TO_ARROW
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_schema_from_arrow {
+        __DUCKDB_SCHEMA_FROM_ARROW
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_data_chunk_from_arrow {
+        __DUCKDB_DATA_CHUNK_FROM_ARROW
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_arrow_converted_schema {
+        __DUCKDB_DESTROY_ARROW_CONVERTED_SCHEMA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_client_context_get_catalog {
+        __DUCKDB_CLIENT_CONTEXT_GET_CATALOG
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_catalog_get_type_name {
+        __DUCKDB_CATALOG_GET_TYPE_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_catalog_get_entry {
+        __DUCKDB_CATALOG_GET_ENTRY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_catalog {
+        __DUCKDB_DESTROY_CATALOG
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_catalog_entry_get_type {
+        __DUCKDB_CATALOG_ENTRY_GET_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_catalog_entry_get_name {
+        __DUCKDB_CATALOG_ENTRY_GET_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_catalog_entry {
+        __DUCKDB_DESTROY_CATALOG_ENTRY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_config_option {
+        __DUCKDB_CREATE_CONFIG_OPTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_config_option {
+        __DUCKDB_DESTROY_CONFIG_OPTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_config_option_set_name {
+        __DUCKDB_CONFIG_OPTION_SET_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_config_option_set_type {
+        __DUCKDB_CONFIG_OPTION_SET_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_config_option_set_default_value {
+        __DUCKDB_CONFIG_OPTION_SET_DEFAULT_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_config_option_set_default_scope {
+        __DUCKDB_CONFIG_OPTION_SET_DEFAULT_SCOPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_config_option_set_description {
+        __DUCKDB_CONFIG_OPTION_SET_DESCRIPTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_config_option {
+        __DUCKDB_REGISTER_CONFIG_OPTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_client_context_get_config_option {
+        __DUCKDB_CLIENT_CONTEXT_GET_CONFIG_OPTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_copy_function {
+        __DUCKDB_CREATE_COPY_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_set_name {
+        __DUCKDB_COPY_FUNCTION_SET_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_set_extra_info {
+        __DUCKDB_COPY_FUNCTION_SET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_copy_function {
+        __DUCKDB_REGISTER_COPY_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_copy_function {
+        __DUCKDB_DESTROY_COPY_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_set_bind {
+        __DUCKDB_COPY_FUNCTION_SET_BIND
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_bind_set_error {
+        __DUCKDB_COPY_FUNCTION_BIND_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_bind_get_extra_info {
+        __DUCKDB_COPY_FUNCTION_BIND_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_bind_get_client_context {
+        __DUCKDB_COPY_FUNCTION_BIND_GET_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_bind_get_column_count {
+        __DUCKDB_COPY_FUNCTION_BIND_GET_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_bind_get_column_type {
+        __DUCKDB_COPY_FUNCTION_BIND_GET_COLUMN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_bind_get_options {
+        __DUCKDB_COPY_FUNCTION_BIND_GET_OPTIONS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_bind_set_bind_data {
+        __DUCKDB_COPY_FUNCTION_BIND_SET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_set_global_init {
+        __DUCKDB_COPY_FUNCTION_SET_GLOBAL_INIT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_global_init_set_error {
+        __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_global_init_get_extra_info {
+        __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_global_init_get_client_context {
+        __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_global_init_get_bind_data {
+        __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_global_init_set_global_state {
+        __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_SET_GLOBAL_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_global_init_get_file_path {
+        __DUCKDB_COPY_FUNCTION_GLOBAL_INIT_GET_FILE_PATH
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_set_sink {
+        __DUCKDB_COPY_FUNCTION_SET_SINK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_sink_set_error {
+        __DUCKDB_COPY_FUNCTION_SINK_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_sink_get_extra_info {
+        __DUCKDB_COPY_FUNCTION_SINK_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_sink_get_client_context {
+        __DUCKDB_COPY_FUNCTION_SINK_GET_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_sink_get_bind_data {
+        __DUCKDB_COPY_FUNCTION_SINK_GET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_sink_get_global_state {
+        __DUCKDB_COPY_FUNCTION_SINK_GET_GLOBAL_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_set_finalize {
+        __DUCKDB_COPY_FUNCTION_SET_FINALIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_finalize_set_error {
+        __DUCKDB_COPY_FUNCTION_FINALIZE_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_finalize_get_extra_info {
+        __DUCKDB_COPY_FUNCTION_FINALIZE_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_finalize_get_client_context {
+        __DUCKDB_COPY_FUNCTION_FINALIZE_GET_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_finalize_get_bind_data {
+        __DUCKDB_COPY_FUNCTION_FINALIZE_GET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_finalize_get_global_state {
+        __DUCKDB_COPY_FUNCTION_FINALIZE_GET_GLOBAL_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_copy_function_set_copy_from_function {
+        __DUCKDB_COPY_FUNCTION_SET_COPY_FROM_FUNCTION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_bind_get_result_column_count {
+        __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_bind_get_result_column_name {
+        __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_COLUMN_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_bind_get_result_column_type {
+        __DUCKDB_TABLE_FUNCTION_BIND_GET_RESULT_COLUMN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_error_data {
+        __DUCKDB_CREATE_ERROR_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_error_data {
+        __DUCKDB_DESTROY_ERROR_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_error_data_error_type {
+        __DUCKDB_ERROR_DATA_ERROR_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_error_data_message {
+        __DUCKDB_ERROR_DATA_MESSAGE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_error_data_has_error {
+        __DUCKDB_ERROR_DATA_HAS_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_expression {
+        __DUCKDB_DESTROY_EXPRESSION
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_expression_return_type {
+        __DUCKDB_EXPRESSION_RETURN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_expression_is_foldable {
+        __DUCKDB_EXPRESSION_IS_FOLDABLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_expression_fold {
+        __DUCKDB_EXPRESSION_FOLD
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_client_context_get_file_system {
+        __DUCKDB_CLIENT_CONTEXT_GET_FILE_SYSTEM
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_file_system {
+        __DUCKDB_DESTROY_FILE_SYSTEM
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_system_open {
+        __DUCKDB_FILE_SYSTEM_OPEN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_system_error_data {
+        __DUCKDB_FILE_SYSTEM_ERROR_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_file_open_options {
+        __DUCKDB_CREATE_FILE_OPEN_OPTIONS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_open_options_set_flag {
+        __DUCKDB_FILE_OPEN_OPTIONS_SET_FLAG
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_file_open_options {
+        __DUCKDB_DESTROY_FILE_OPEN_OPTIONS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_file_handle {
+        __DUCKDB_DESTROY_FILE_HANDLE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_handle_error_data {
+        __DUCKDB_FILE_HANDLE_ERROR_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_handle_close {
+        __DUCKDB_FILE_HANDLE_CLOSE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_handle_read {
+        __DUCKDB_FILE_HANDLE_READ
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_handle_write {
+        __DUCKDB_FILE_HANDLE_WRITE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_handle_seek {
+        __DUCKDB_FILE_HANDLE_SEEK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_handle_tell {
+        __DUCKDB_FILE_HANDLE_TELL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_handle_sync {
+        __DUCKDB_FILE_HANDLE_SYNC
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_file_handle_size {
+        __DUCKDB_FILE_HANDLE_SIZE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_geometry_type_get_crs {
+        __DUCKDB_GEOMETRY_TYPE_GET_CRS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_log_storage {
+        __DUCKDB_CREATE_LOG_STORAGE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_log_storage {
+        __DUCKDB_DESTROY_LOG_STORAGE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_log_storage_set_write_log_entry {
+        __DUCKDB_LOG_STORAGE_SET_WRITE_LOG_ENTRY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_log_storage_set_extra_data {
+        __DUCKDB_LOG_STORAGE_SET_EXTRA_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_log_storage_set_name {
+        __DUCKDB_LOG_STORAGE_SET_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_register_log_storage {
+        __DUCKDB_REGISTER_LOG_STORAGE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_client_context_get_connection_id {
+        __DUCKDB_CLIENT_CONTEXT_GET_CONNECTION_ID
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_client_context {
+        __DUCKDB_DESTROY_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_connection_get_client_context {
+        __DUCKDB_CONNECTION_GET_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_table_names {
+        __DUCKDB_GET_TABLE_NAMES
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_connection_get_arrow_options {
+        __DUCKDB_CONNECTION_GET_ARROW_OPTIONS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_arrow_options {
+        __DUCKDB_DESTROY_ARROW_OPTIONS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepared_statement_column_count {
+        __DUCKDB_PREPARED_STATEMENT_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepared_statement_column_name {
+        __DUCKDB_PREPARED_STATEMENT_COLUMN_NAME
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepared_statement_column_logical_type {
+        __DUCKDB_PREPARED_STATEMENT_COLUMN_LOGICAL_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_prepared_statement_column_type {
+        __DUCKDB_PREPARED_STATEMENT_COLUMN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_result_get_arrow_options {
+        __DUCKDB_RESULT_GET_ARROW_OPTIONS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_bind {
+        __DUCKDB_SCALAR_FUNCTION_SET_BIND
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_bind_set_error {
+        __DUCKDB_SCALAR_FUNCTION_BIND_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_get_client_context {
+        __DUCKDB_SCALAR_FUNCTION_GET_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_bind_data {
+        __DUCKDB_SCALAR_FUNCTION_SET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_get_bind_data {
+        __DUCKDB_SCALAR_FUNCTION_GET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_bind_get_extra_info {
+        __DUCKDB_SCALAR_FUNCTION_BIND_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_bind_get_argument_count {
+        __DUCKDB_SCALAR_FUNCTION_BIND_GET_ARGUMENT_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_bind_get_argument {
+        __DUCKDB_SCALAR_FUNCTION_BIND_GET_ARGUMENT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_bind_data_copy {
+        __DUCKDB_SCALAR_FUNCTION_SET_BIND_DATA_COPY
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_get_state {
+        __DUCKDB_SCALAR_FUNCTION_GET_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_set_init {
+        __DUCKDB_SCALAR_FUNCTION_SET_INIT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_init_set_error {
+        __DUCKDB_SCALAR_FUNCTION_INIT_SET_ERROR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_init_set_state {
+        __DUCKDB_SCALAR_FUNCTION_INIT_SET_STATE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_init_get_client_context {
+        __DUCKDB_SCALAR_FUNCTION_INIT_GET_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_init_get_bind_data {
+        __DUCKDB_SCALAR_FUNCTION_INIT_GET_BIND_DATA
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_scalar_function_init_get_extra_info {
+        __DUCKDB_SCALAR_FUNCTION_INIT_GET_EXTRA_INFO
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_value_to_string {
+        __DUCKDB_VALUE_TO_STRING
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_valid_utf8_check {
+        __DUCKDB_VALID_UTF8_CHECK
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_description_get_column_count {
+        __DUCKDB_TABLE_DESCRIPTION_GET_COLUMN_COUNT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_description_get_column_type {
+        __DUCKDB_TABLE_DESCRIPTION_GET_COLUMN_TYPE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_table_function_get_client_context {
+        __DUCKDB_TABLE_FUNCTION_GET_CLIENT_CONTEXT
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_map_value {
+        __DUCKDB_CREATE_MAP_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_union_value {
+        __DUCKDB_CREATE_UNION_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_time_ns {
+        __DUCKDB_CREATE_TIME_NS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_get_time_ns {
+        __DUCKDB_GET_TIME_NS
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_vector {
+        __DUCKDB_CREATE_VECTOR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_vector {
+        __DUCKDB_DESTROY_VECTOR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_slice_vector {
+        __DUCKDB_SLICE_VECTOR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_reference_value {
+        __DUCKDB_VECTOR_REFERENCE_VALUE
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_reference_vector {
+        __DUCKDB_VECTOR_REFERENCE_VECTOR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_create_selection_vector {
+        __DUCKDB_CREATE_SELECTION_VECTOR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_destroy_selection_vector {
+        __DUCKDB_DESTROY_SELECTION_VECTOR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_selection_vector_get_data_ptr {
+        __DUCKDB_SELECTION_VECTOR_GET_DATA_PTR
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_vector_copy_sel {
+        __DUCKDB_VECTOR_COPY_SEL
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    if let Some(fun) = (*p_api).duckdb_unsafe_vector_assign_string_element_len {
+        __DUCKDB_UNSAFE_VECTOR_ASSIGN_STRING_ELEMENT_LEN
+            .store(fun as usize as *mut (), ::std::sync::atomic::Ordering::Release);
+    }
+    Ok(true)
+}
diff --git a/rust_hft/native/libduckdb-sys/src/error.rs b/rust_hft/native/libduckdb-sys/src/error.rs
new file mode 100644
index 000000000..adf2b07d0
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/src/error.rs
@@ -0,0 +1,92 @@
+use crate::duckdb_state;
+use std::{error, fmt};
+
+/// Error Codes
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ErrorCode {
+    /// Internal logic error in SQLite
+    InternalMalfunction,
+    /// Access permission denied
+    PermissionDenied,
+    /// Callback routine requested an abort
+    OperationAborted,
+    /// The database file is locked
+    DatabaseBusy,
+    /// A table in the database is locked
+    DatabaseLocked,
+    /// A malloc() failed
+    OutOfMemory,
+    /// Attempt to write a readonly database
+    ReadOnly,
+    /// Operation terminated by sqlite3_interrupt()
+    OperationInterrupted,
+    /// Some kind of disk I/O error occurred
+    SystemIoFailure,
+    /// The database disk image is malformed
+    DatabaseCorrupt,
+    /// Unknown opcode in sqlite3_file_control()
+    NotFound,
+    /// Insertion failed because database is full
+    DiskFull,
+    /// Unable to open the database file
+    CannotOpen,
+    /// Database lock protocol error
+    FileLockingProtocolFailed,
+    /// The database schema changed
+    SchemaChanged,
+    /// String or BLOB exceeds size limit
+    TooBig,
+    /// Abort due to constraint violation
+    ConstraintViolation,
+    /// Data type mismatch
+    TypeMismatch,
+    /// Library used incorrectly
+    ApiMisuse,
+    /// Uses OS features not supported on host
+    NoLargeFileSupport,
+    /// Authorization denied
+    AuthorizationForStatementDenied,
+    /// 2nd parameter to sqlite3_bind out of range
+    ParameterOutOfRange,
+    /// File opened that is not a database file
+    NotADatabase,
+    /// SQL error or missing database
+    Unknown,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Error {
+    pub code: ErrorCode,
+    pub extended_code: duckdb_state,
+}
+
+impl Error {
+    pub fn new(result_code: duckdb_state) -> Self {
+        Self {
+            code: ErrorCode::Unknown,
+            extended_code: result_code,
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Error code {}: {}",
+            self.extended_code,
+            code_to_str(self.extended_code)
+        )
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        code_to_str(self.extended_code)
+    }
+}
+
+pub fn code_to_str(_: duckdb_state) -> &'static str {
+    "Unknown error code"
+}
diff --git a/rust_hft/native/libduckdb-sys/src/lib.rs b/rust_hft/native/libduckdb-sys/src/lib.rs
new file mode 100644
index 000000000..d1c267410
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/src/lib.rs
@@ -0,0 +1,212 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(deref_nullptr)]
+#![allow(improper_ctypes)]
+
+/// Dependency-free Arrow C Data Interface structs used by DuckDB Arrow APIs.
+mod arrow_c_data;
+pub use arrow_c_data::{ArrowArray, ArrowSchema};
+
+#[allow(clippy::all, unsafe_op_in_unsafe_fn)]
+mod bindings {
+    // Bindgen references these blocklisted forward declarations unqualified.
+    use crate::arrow_c_data::{ArrowArray, ArrowSchema};
+
+    include!(concat!(env!("OUT_DIR"), "/bindgen.rs"));
+}
+#[allow(clippy::all)]
+pub use bindings::*;
+
+mod string;
+pub use string::*;
+
+pub const DuckDBError: duckdb_state = duckdb_state_DuckDBError;
+pub const DuckDBSuccess: duckdb_state = duckdb_state_DuckDBSuccess;
+
+pub use self::error::*;
+mod error;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::{
+        ffi::{CStr, CString},
+        mem,
+        os::raw::c_char,
+        ptr,
+    };
+
+    use arrow::{
+        array::{Array, Int32Array, StructArray},
+        datatypes::DataType,
+        ffi::{FFI_ArrowArray, FFI_ArrowSchema, from_ffi},
+    };
+
+    unsafe fn print_int_result(result: &mut duckdb_result) {
+        unsafe {
+            for i in 0..duckdb_column_count(result) {
+                print!("{} ", CStr::from_ptr(duckdb_column_name(result, i)).to_string_lossy());
+            }
+            println!();
+            // print the data of the result
+            for row_idx in 0..duckdb_row_count(result) {
+                for col_idx in 0..duckdb_column_count(result) {
+                    let val = duckdb_value_int32(result, col_idx, row_idx);
+                    print!("{val} ");
+                }
+                println!();
+            }
+        }
+    }
+
+    #[test]
+    fn test_query_arrow() {
+        unsafe {
+            // open db
+            let mut db: duckdb_database = ptr::null_mut();
+            let mut con: duckdb_connection = ptr::null_mut();
+            if duckdb_open(ptr::null_mut(), &mut db) != duckdb_state_DuckDBSuccess {
+                panic!("duckdb_open error")
+            }
+            if duckdb_connect(db, &mut con) != duckdb_state_DuckDBSuccess {
+                panic!("duckdb_connect error")
+            }
+            // create a table
+            let sql = CString::new("CREATE TABLE integers(i INTEGER, j INTEGER);").unwrap();
+            if duckdb_query(con, sql.as_ptr() as *const c_char, ptr::null_mut()) != duckdb_state_DuckDBSuccess {
+                panic!("CREATE TABLE error")
+            }
+
+            // insert three rows into the table
+            let sql = CString::new("INSERT INTO integers VALUES (3, 4), (5, 6), (7, NULL);").unwrap();
+            let mut result: duckdb_arrow = ptr::null_mut();
+            if duckdb_query_arrow(con, sql.as_ptr() as *const c_char, &mut result) != duckdb_state_DuckDBSuccess {
+                panic!("INSERT error")
+            }
+            assert_eq!(duckdb_arrow_rows_changed(result), 3);
+            duckdb_destroy_arrow(&mut result);
+
+            // query rows again
+            let mut result: duckdb_arrow = ptr::null_mut();
+            let sql = CString::new("select i, j from integers order by i desc").unwrap();
+            if duckdb_query_arrow(con, sql.as_ptr() as *const c_char, &mut result) != duckdb_state_DuckDBSuccess {
+                panic!("SELECT error")
+            }
+            assert_eq!(duckdb_arrow_row_count(result), 3);
+            assert_eq!(duckdb_arrow_column_count(result), 2);
+
+            let mut arrays = FFI_ArrowArray::empty();
+            let mut schema = FFI_ArrowSchema::empty();
+            if duckdb_query_arrow_schema(
+                result,
+                &mut std::ptr::addr_of_mut!(schema) as *mut _ as *mut duckdb_arrow_schema,
+            ) != duckdb_state_DuckDBSuccess
+            {
+                panic!("SELECT error")
+            }
+            if duckdb_query_arrow_array(
+                result,
+                &mut std::ptr::addr_of_mut!(arrays) as *mut _ as *mut duckdb_arrow_array,
+            ) != duckdb_state_DuckDBSuccess
+            {
+                panic!("SELECT error")
+            }
+            let array_data = from_ffi(arrays, &schema).expect("ok");
+            let struct_array = StructArray::from(array_data);
+            assert_eq!(struct_array.len(), 3);
+            assert_eq!(struct_array.columns().len(), 2);
+            assert_eq!(struct_array.column(0).data_type(), &DataType::Int32);
+            assert_eq!(struct_array.column(1).data_type(), &DataType::Int32);
+            let arr_i = struct_array.column(0).as_any().downcast_ref::<Int32Array>().unwrap();
+            assert_eq!(arr_i.value(0), 7);
+            assert_eq!(arr_i.value(1), 5);
+            assert_eq!(arr_i.value(2), 3);
+            let arr_j = struct_array.column(1).as_any().downcast_ref::<Int32Array>().unwrap();
+            assert!(arr_j.is_null(0));
+            assert_eq!(arr_j.value(1), 6);
+            assert_eq!(arr_j.value(2), 4);
+
+            let mut arrays: duckdb_arrow_array = ptr::null_mut();
+            if duckdb_query_arrow_array(result, &mut arrays) != duckdb_state_DuckDBSuccess {
+                panic!("SELECT error")
+            }
+            assert!(arrays.is_null());
+            duckdb_destroy_arrow(&mut result);
+            duckdb_disconnect(&mut con);
+            duckdb_close(&mut db);
+        }
+    }
+
+    #[test]
+    fn basic_api_usage() {
+        unsafe {
+            // open db
+            let mut db: duckdb_database = ptr::null_mut();
+            let mut con: duckdb_connection = ptr::null_mut();
+            if duckdb_open(ptr::null_mut(), &mut db) != duckdb_state_DuckDBSuccess {
+                panic!("duckdb_open error")
+            }
+            if duckdb_connect(db, &mut con) != duckdb_state_DuckDBSuccess {
+                panic!("duckdb_connect error")
+            }
+            // create a table
+            let sql = CString::new("CREATE TABLE integers(i INTEGER, j INTEGER);").unwrap();
+            if duckdb_query(con, sql.as_ptr() as *const c_char, ptr::null_mut()) != duckdb_state_DuckDBSuccess {
+                panic!("CREATE TABLE error")
+            }
+            // insert three rows into the table
+            let sql = CString::new("INSERT INTO integers VALUES (3, 4), (5, 6), (7, NULL);").unwrap();
+            if duckdb_query(con, sql.as_ptr() as *const c_char, ptr::null_mut()) != duckdb_state_DuckDBSuccess {
+                panic!("INSERT error")
+            }
+            // query rows again
+            let mut result: duckdb_result = mem::zeroed();
+            let sql = CString::new("select * from integers").unwrap();
+            if duckdb_query(con, sql.as_ptr() as *const c_char, &mut result) != duckdb_state_DuckDBSuccess {
+                panic!(
+                    "SELECT error: {}",
+                    CStr::from_ptr(duckdb_result_error(&mut result)).to_string_lossy()
+                )
+            }
+            assert_eq!(duckdb_row_count(&mut result), 3);
+            assert_eq!(duckdb_column_count(&mut result), 2);
+            print_int_result(&mut result);
+            duckdb_destroy_result(&mut result);
+
+            // test prepare
+            let mut stmt: duckdb_prepared_statement = ptr::null_mut();
+            let sql = CString::new("select * from integers where i>?").unwrap();
+            if duckdb_prepare(con, sql.as_ptr() as *const c_char, &mut stmt) != duckdb_state_DuckDBSuccess {
+                panic!("Prepare error");
+            }
+            if duckdb_bind_int32(stmt, 1, 4) != duckdb_state_DuckDBSuccess {
+                panic!("Bind params error");
+            }
+            if duckdb_execute_prepared(stmt, &mut result) != duckdb_state_DuckDBSuccess {
+                panic!("Execute prepared error");
+            }
+            assert_eq!(duckdb_row_count(&mut result), 2);
+            assert_eq!(duckdb_column_count(&mut result), 2);
+            print_int_result(&mut result);
+            duckdb_destroy_result(&mut result);
+
+            // test bind params again
+            if duckdb_bind_int32(stmt, 1, 5) != duckdb_state_DuckDBSuccess {
+                panic!("Bind params error");
+            }
+            if duckdb_execute_prepared(stmt, &mut result) != duckdb_state_DuckDBSuccess {
+                panic!("Execute prepared error");
+            }
+            assert_eq!(duckdb_row_count(&mut result), 1);
+            assert_eq!(duckdb_column_count(&mut result), 2);
+            print_int_result(&mut result);
+            duckdb_destroy_result(&mut result);
+            duckdb_destroy_prepare(&mut stmt);
+
+            // clean up
+            duckdb_disconnect(&mut con);
+            duckdb_close(&mut db);
+        }
+    }
+}
diff --git a/rust_hft/native/libduckdb-sys/src/string.rs b/rust_hft/native/libduckdb-sys/src/string.rs
new file mode 100644
index 000000000..36a671690
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/src/string.rs
@@ -0,0 +1,93 @@
+use std::{
+    ffi::{CStr, c_char},
+    ops::Deref,
+};
+
+use crate::duckdb_free;
+
+pub struct DuckDbString {
+    // Invariant: ptr[0..len+1] is valid C string, i.e. ptr[len] is NUL byte.
+    ptr: core::ptr::NonNull<c_char>,
+    len: usize,
+}
+
+impl DuckDbString {
+    /// Creates a `DuckDbString` from a raw pointer to a C string.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that:
+    /// - `ptr` is non-null and points to a null-terminated C string.
+    /// - `ptr` was allocated by DuckDB and must be released with `duckdb_free`.
+    /// - Ownership of `ptr` transfers to the returned `DuckDbString`. The caller must not reuse or free it.
+    pub unsafe fn from_ptr(ptr: *const c_char) -> Self {
+        assert!(!ptr.is_null(), "DuckDbString::from_ptr requires a non-null pointer");
+        let len = unsafe { CStr::from_ptr(ptr) }.to_bytes().len();
+        unsafe { Self::from_raw_parts(ptr, len) }
+    }
+
+    /// Creates a `DuckDbString` from a nullable raw pointer to a C string.
+    ///
+    /// Returns `None` if `ptr` is null.
+    ///
+    /// # Safety
+    ///
+    /// If `ptr` is non-null, the caller must ensure that:
+    /// - `ptr` points to a null-terminated C string.
+    /// - `ptr` was allocated by DuckDB and must be released with `duckdb_free`.
+    /// - Ownership of `ptr` transfers to the returned `DuckDbString`. The caller must not reuse or free it.
+    pub unsafe fn from_nullable_ptr(ptr: *const c_char) -> Option<Self> {
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { Self::from_ptr(ptr) })
+        }
+    }
+
+    /// Creates a `DuckDbString` from raw parts.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that:
+    /// - `ptr` is non-null and points to a null-terminated C string.
+    /// - `len` accurately represents the length of the string (excluding the null terminator).
+    /// - `ptr` was allocated by DuckDB and must be released with `duckdb_free`.
+    /// - Ownership of `ptr` transfers to the returned `DuckDbString`. The caller must not reuse or free it.
+    /// - The string data is not mutated for the lifetime of the returned `DuckDbString`.
+    pub unsafe fn from_raw_parts(ptr: *const c_char, len: usize) -> Self {
+        let ptr = core::ptr::NonNull::new(ptr as *mut c_char)
+            .expect("DuckDbString::from_raw_parts requires a non-null pointer");
+        Self { ptr, len }
+    }
+
+    fn to_bytes_with_nul(&self) -> &[u8] {
+        let ptr = self.ptr.as_ptr() as *const u8;
+        unsafe { core::slice::from_raw_parts(ptr, self.len + 1) }
+    }
+}
+
+impl Deref for DuckDbString {
+    type Target = std::ffi::CStr;
+
+    fn deref(&self) -> &Self::Target {
+        let bytes = self.to_bytes_with_nul();
+        unsafe { CStr::from_bytes_with_nul_unchecked(bytes) }
+    }
+}
+
+impl Drop for DuckDbString {
+    fn drop(&mut self) {
+        let ptr = self.ptr.as_ptr() as *mut core::ffi::c_void;
+        unsafe { duckdb_free(ptr) };
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DuckDbString;
+
+    #[test]
+    fn from_nullable_ptr_returns_none_for_null() {
+        assert!(unsafe { DuckDbString::from_nullable_ptr(std::ptr::null()) }.is_none());
+    }
+}
diff --git a/rust_hft/native/libduckdb-sys/wrapper.h b/rust_hft/native/libduckdb-sys/wrapper.h
new file mode 100644
index 000000000..bbeeb83f3
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/wrapper.h
@@ -0,0 +1 @@
+#include "duckdb/duckdb.h"
\ No newline at end of file
diff --git a/rust_hft/native/libduckdb-sys/wrapper_ext.h b/rust_hft/native/libduckdb-sys/wrapper_ext.h
new file mode 100644
index 000000000..760fea160
--- /dev/null
+++ b/rust_hft/native/libduckdb-sys/wrapper_ext.h
@@ -0,0 +1,6 @@
+// FIXME: remove this once C EXTENSION API is stable (expected for DuckDB v1.2.0 release)
+#define DUCKDB_EXTENSION_API_VERSION_DEV 1
+
+// We need to allow unstable API for now to get the deprecated arrow functions
+#define DUCKDB_EXTENSION_API_VERSION_UNSTABLE
+#include "duckdb/duckdb_extension.h"
\ No newline at end of file
diff --git a/rust_hft/prediction-markets/crates/ploy-research/prediction-policy-dependencies.linux.sha256 b/rust_hft/prediction-markets/crates/ploy-research/prediction-policy-dependencies.linux.sha256
index fdc5c4c49..b41c72f5c 100644
--- a/rust_hft/prediction-markets/crates/ploy-research/prediction-policy-dependencies.linux.sha256
+++ b/rust_hft/prediction-markets/crates/ploy-research/prediction-policy-dependencies.linux.sha256
@@ -1 +1 @@
-sha256:f95dffef9ef5f81c99e002c1995124cec8db0351c815889d2b79a42fa95b17ab
+sha256:28a788275d1fb7a58004d3487054e7de1161a4447a5ed48f28eadd8b5ba79cb8
diff --git a/rust_hft/prediction-markets/crates/ploy-research/prediction-policy-dependencies.linux.txt b/rust_hft/prediction-markets/crates/ploy-research/prediction-policy-dependencies.linux.txt
index 735895d26..e7ef2acba 100644
--- a/rust_hft/prediction-markets/crates/ploy-research/prediction-policy-dependencies.linux.txt
+++ b/rust_hft/prediction-markets/crates/ploy-research/prediction-policy-dependencies.linux.txt
@@ -15,8 +15,8 @@ input:../market-core/snapshot/Cargo.toml=sha256:2531e664d3e1fb98777215393126c056
 input:../risk-control/oms-core/Cargo.toml=sha256:62ddf714dfdd4870c2dd2b194ebaa61e3a72e01263a1fceea0cef2f50758f7d9
 input:../risk-control/portfolio-core/Cargo.toml=sha256:7aa5c2f8524cf8007bb84733a2d90280915a74f74ba22020a42745360629c2fe
 input:../shared/Cargo.toml=sha256:acc7f47aecfd4f37350958bee832cc13a99ba75431574859ed2fc8b2d5259a0c
-input:../data-pipelines/Cargo.toml=sha256:824f49e94e14686a599537aa7742623795a488079b8883f9ca9ebc3c5ce30177
-input:../research-core/Cargo.toml=sha256:42af47970d26ef34632ca7536648250209b17f8230fa4eb4b8cd6a603c3f5787
+input:../data-pipelines/Cargo.toml=sha256:fd3d96e893d4af02bc1d6a1e8b2dc132b785738ae344a7f2101c41856c431415
+input:../research-core/Cargo.toml=sha256:df9d5a0a6e16012d6e7dfa1f51b1dd119a7c190cabec2866beb28c3c0db0fb82
 input:../runtime/Cargo.toml=sha256:11b6cae8ef4fe0019c778a0767016b4cfc0c92fb30e0bea5f051e00522a52cbf
 input:../research-core/search-kernel/Cargo.toml=sha256:d5a4731c11fce22c0e358097bd38fb05a674659ac2afbd7c72112285093bdec6
 input:../research-core/manifest/Cargo.toml=sha256:4f363d2986d847f42cf4191bcb0bafe09af97a173a1fea5f81354ae217bcd1dc
diff --git a/rust_hft/research-core/Cargo.lock b/rust_hft/research-core/Cargo.lock
index 2ac7907e7..328d93648 100644
--- a/rust_hft/research-core/Cargo.lock
+++ b/rust_hft/research-core/Cargo.lock
@@ -3755,18 +3755,14 @@ checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 [[package]]
 name = "libduckdb-sys"
 version = "1.10504.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94e67523a40ee3da30411e00e243990b3760d91877202ab2f39c03ab34f8dbfc"
 dependencies = [
  "cc",
  "flate2",
  "pkg-config",
- "reqwest",
  "serde",
  "serde_json",
  "tar",
  "vcpkg",
- "zip 6.0.0",
 ]
 
 [[package]]
diff --git a/rust_hft/research-core/Cargo.toml b/rust_hft/research-core/Cargo.toml
index 090a5d7ba..c94619250 100644
--- a/rust_hft/research-core/Cargo.toml
+++ b/rust_hft/research-core/Cargo.toml
@@ -56,4 +56,5 @@ codegen-units = 1
 debug = false
 
 [patch.crates-io]
+libduckdb-sys = { path = "../native/libduckdb-sys" }
 rust_decimal = { git = "https://github.com/proerror77/monday-rust-decimal-security-694", rev = "4f7bc6f02d7920b6416988914ae86d25f6670b22" }
diff --git a/rust_hft/research-core/platform/src/release_publisher.rs b/rust_hft/research-core/platform/src/release_publisher.rs
index 443c77732..47fe6248e 100644
--- a/rust_hft/research-core/platform/src/release_publisher.rs
+++ b/rust_hft/research-core/platform/src/release_publisher.rs
@@ -2638,7 +2638,7 @@ mod tests {
         };
         let mut calls = 0;
         for (product, programs, build_count, expected_calls) in [
-            ("cex-runner", 9, 6, 90),
+            ("cex-runner", 8, 5, 78),
             ("controller", 1, 1, 21),
             ("prediction-runner", 5, 3, 51),
         ] {
@@ -2668,7 +2668,7 @@ mod tests {
                 assert_eq!(object.sha256, sha256(&bytes));
             }
         }
-        assert_eq!(calls, 162);
+        assert_eq!(calls, 150);
         let names = BTreeSet::from(["alpha-harness".into()]);
         let builds = project_builds(&source(), &manifest.build_inputs, &names)?;
         std::fs::write(