[ { "path": ".gitignore", "content": ".DS_Store\nzig-out/\n.zig-cache/\nlib/libduckdb.dylib\nzig-pkg/\n" }, { "path": ".vscode/settings.json", "content": "{\n \"zig.testArgs\": [\"build\", \"test\", \"-Dtest-filter=${filter}\"]\n}\n" }, { "path": "LICENSE", "content": "Copyright (c) 2024 Karl Seguin.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n" }, { "path": "Makefile", "content": "F=\n.PHONY: t\nt:\n\tTEST_FILTER=\"${F}\" zig build -Dsystem_libduckdb=false test --summary all -freference-trace\n" }, { "path": "build.zig", "content": "const std = @import(\"std\");\n\nconst LazyPath = std.Build.LazyPath;\n\npub fn build(b: *std.Build) !void {\n const target = b.standardTargetOptions(.{});\n const optimize = b.standardOptimizeOption(.{});\n const system_libduckdb = b.option(bool, \"system_libduckdb\", \"link with system libduckdb\") orelse true;\n const debug_duckdb = b.option(bool, \"debug_duckdb\", \"compile duckdb with DUCKDB_DEBUG_STACKTRACE\") orelse false;\n\n const zuckdb = b.addModule(\"zuckdb\", .{\n .root_source_file = b.path(\"src/zuckdb.zig\"),\n .target = target,\n .optimize = optimize,\n });\n\n const c_header: LazyPath, const lib = blk: {\n if (system_libduckdb) {\n const lib_path = b.path(\"lib\");\n zuckdb.addIncludePath(lib_path);\n zuckdb.linkSystemLibrary(\"duckdb\", .{});\n break :blk .{ b.path(\"lib/duckdb.h\"), null };\n } else {\n const c_dep = b.lazyDependency(\"duckdb\", .{}) orelse return;\n const root_module = b.createModule(.{\n .target = target,\n .optimize = optimize,\n .link_libcpp = true,\n });\n\n const c_lib = b.addLibrary(.{\n .name = \"duckdb\",\n .root_module = root_module,\n });\n\n root_module.addIncludePath(c_dep.path(\"\"));\n root_module.addCSourceFiles(.{\n .files = &.{\"duckdb.cpp\"},\n .root = c_dep.path(\"\"),\n .flags = &.{\"-Wno-date-time\"},\n });\n if (debug_duckdb) {\n root_module.addCMacro(\"DUCKDB_DEBUG_STACKTRACE\", \"\");\n }\n root_module.addCMacro(\"DUCKDB_STATIC_BUILD\", \"\");\n // json tests fail because extension loading does not work\n // on the self built version. TODO: statically link core extensions:\n // c_lib.root_module.addCMacro(\"DUCKDB_EXTENSION_JSON_LINKED\", \"true\");\n b.installArtifact(c_lib);\n b.default_step.dependOn(&b.addInstallHeaderFile(\n c_dep.path(\"duckdb.h\"),\n \"duckdb.h\",\n ).step);\n\n zuckdb.linkLibrary(c_lib);\n break :blk .{ c_dep.path(\"duckdb.h\"), c_lib };\n }\n };\n\n zuckdb.addImport(\"duckdb_clib\", b.addTranslateC(.{\n .root_source_file = c_header,\n .target = target,\n .optimize = optimize,\n }).createModule());\n\n {\n // Setup Tests\n const lib_test = b.addTest(.{\n .root_module = zuckdb,\n .test_runner = .{ .path = b.path(\"test_runner.zig\"), .mode = .simple },\n });\n lib_test.root_module.addIncludePath(b.path(\"lib\"));\n lib_test.root_module.addLibraryPath(b.path(\"lib\"));\n _ = lib;\n // if (system_libduckdb) {\n // lib_test.root_module.linkSystemLibrary(\"duckdb\", .{});\n // } else {\n // lib_test.root_module.linkLibrary(lib.?);\n // }\n\n const run_test = b.addRunArtifact(lib_test);\n run_test.has_side_effects = true;\n\n const test_step = b.step(\"test\", \"Run unit tests\");\n test_step.dependOn(&run_test.step);\n }\n}\n" }, { "path": "build.zig.zon", "content": ".{\n .name = .zuckdb,\n .paths = .{\n \"LICENSE\",\n \"build.zig\",\n \"build.zig.zon\",\n \"lib\",\n \"readme.md\",\n \"src\",\n },\n .version = \"0.0.0\",\n .fingerprint = 0xe57532405497940e,\n .dependencies = .{\n .duckdb = .{\n .lazy = true,\n .url = \"https://github.com/duckdb/duckdb/releases/download/v1.5.2/libduckdb-src.zip\",\n .hash = \"N-V-__8AAP82qgEMw9wCzbQ-rD5uvO-o3X6PyzWA3zsoeIIS\",\n },\n },\n}\n" }, { "path": "lib/duckdb.h", "content": "//===----------------------------------------------------------------------===//\n//\n// DuckDB\n//\n// duckdb.h\n//\n//\n//===----------------------------------------------------------------------===//\n//\n// !!!!!!!\n// WARNING: this file is autogenerated by scripts/generate_c_api.py, manual changes will be overwritten\n// !!!!!!!\n\n#pragma once\n\n#ifndef DUCKDB_C_API\n#ifdef _WIN32\n#ifdef DUCKDB_STATIC_BUILD\n#define DUCKDB_C_API\n#else\n#if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)\n#define DUCKDB_C_API __declspec(dllexport)\n#else\n#define DUCKDB_C_API __declspec(dllimport)\n#endif\n#endif\n#else\n#define DUCKDB_C_API\n#endif\n#endif\n\n//! duplicate of duckdb/main/winapi.hpp\n#ifndef DUCKDB_EXTENSION_API\n#ifdef _WIN32\n#ifdef DUCKDB_STATIC_BUILD\n#define DUCKDB_EXTENSION_API\n#else\n#define DUCKDB_EXTENSION_API __declspec(dllexport)\n#endif\n#else\n#define DUCKDB_EXTENSION_API __attribute__((visibility(\"default\")))\n#endif\n#endif\n\n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n//===--------------------------------------------------------------------===//\n// Enums\n//===--------------------------------------------------------------------===//\n\n//! WARNING: The numbers of these enums should not be changed, as changing the numbers breaks ABI compatibility.\n//! Always add enums at the END of the enum\n\n//! An enum over DuckDB's internal types.\ntypedef enum DUCKDB_TYPE {\n\tDUCKDB_TYPE_INVALID = 0,\n\t// bool\n\tDUCKDB_TYPE_BOOLEAN = 1,\n\t// int8_t\n\tDUCKDB_TYPE_TINYINT = 2,\n\t// int16_t\n\tDUCKDB_TYPE_SMALLINT = 3,\n\t// int32_t\n\tDUCKDB_TYPE_INTEGER = 4,\n\t// int64_t\n\tDUCKDB_TYPE_BIGINT = 5,\n\t// uint8_t\n\tDUCKDB_TYPE_UTINYINT = 6,\n\t// uint16_t\n\tDUCKDB_TYPE_USMALLINT = 7,\n\t// uint32_t\n\tDUCKDB_TYPE_UINTEGER = 8,\n\t// uint64_t\n\tDUCKDB_TYPE_UBIGINT = 9,\n\t// float\n\tDUCKDB_TYPE_FLOAT = 10,\n\t// double\n\tDUCKDB_TYPE_DOUBLE = 11,\n\t// duckdb_timestamp (microseconds)\n\tDUCKDB_TYPE_TIMESTAMP = 12,\n\t// duckdb_date\n\tDUCKDB_TYPE_DATE = 13,\n\t// duckdb_time\n\tDUCKDB_TYPE_TIME = 14,\n\t// duckdb_interval\n\tDUCKDB_TYPE_INTERVAL = 15,\n\t// duckdb_hugeint\n\tDUCKDB_TYPE_HUGEINT = 16,\n\t// duckdb_uhugeint\n\tDUCKDB_TYPE_UHUGEINT = 32,\n\t// const char*\n\tDUCKDB_TYPE_VARCHAR = 17,\n\t// duckdb_blob\n\tDUCKDB_TYPE_BLOB = 18,\n\t// duckdb_decimal\n\tDUCKDB_TYPE_DECIMAL = 19,\n\t// duckdb_timestamp_s (seconds)\n\tDUCKDB_TYPE_TIMESTAMP_S = 20,\n\t// duckdb_timestamp_ms (milliseconds)\n\tDUCKDB_TYPE_TIMESTAMP_MS = 21,\n\t// duckdb_timestamp_ns (nanoseconds)\n\tDUCKDB_TYPE_TIMESTAMP_NS = 22,\n\t// enum type, only useful as logical type\n\tDUCKDB_TYPE_ENUM = 23,\n\t// list type, only useful as logical type\n\tDUCKDB_TYPE_LIST = 24,\n\t// struct type, only useful as logical type\n\tDUCKDB_TYPE_STRUCT = 25,\n\t// map type, only useful as logical type\n\tDUCKDB_TYPE_MAP = 26,\n\t// duckdb_array, only useful as logical type\n\tDUCKDB_TYPE_ARRAY = 33,\n\t// duckdb_hugeint\n\tDUCKDB_TYPE_UUID = 27,\n\t// union type, only useful as logical type\n\tDUCKDB_TYPE_UNION = 28,\n\t// duckdb_bit\n\tDUCKDB_TYPE_BIT = 29,\n\t// duckdb_time_tz\n\tDUCKDB_TYPE_TIME_TZ = 30,\n\t// duckdb_timestamp (microseconds)\n\tDUCKDB_TYPE_TIMESTAMP_TZ = 31,\n\t// enum type, only useful as logical type\n\tDUCKDB_TYPE_ANY = 34,\n\t// duckdb_bignum\n\tDUCKDB_TYPE_BIGNUM = 35,\n\t// enum type, only useful as logical type\n\tDUCKDB_TYPE_SQLNULL = 36,\n\t// enum type, only useful as logical type\n\tDUCKDB_TYPE_STRING_LITERAL = 37,\n\t// enum type, only useful as logical type\n\tDUCKDB_TYPE_INTEGER_LITERAL = 38,\n\t// duckdb_time_ns (nanoseconds)\n\tDUCKDB_TYPE_TIME_NS = 39,\n\t// GEOMETRY type, WKB blob\n\tDUCKDB_TYPE_GEOMETRY = 40,\n} duckdb_type;\n\n//! An enum over the returned state of different functions.\ntypedef enum duckdb_state { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;\n\n//! An enum over the pending state of a pending query result.\ntypedef enum duckdb_pending_state {\n\tDUCKDB_PENDING_RESULT_READY = 0,\n\tDUCKDB_PENDING_RESULT_NOT_READY = 1,\n\tDUCKDB_PENDING_ERROR = 2,\n\tDUCKDB_PENDING_NO_TASKS_AVAILABLE = 3\n} duckdb_pending_state;\n\n//! An enum over DuckDB's different result types.\ntypedef enum duckdb_result_type {\n\tDUCKDB_RESULT_TYPE_INVALID = 0,\n\tDUCKDB_RESULT_TYPE_CHANGED_ROWS = 1,\n\tDUCKDB_RESULT_TYPE_NOTHING = 2,\n\tDUCKDB_RESULT_TYPE_QUERY_RESULT = 3,\n} duckdb_result_type;\n\n//! An enum over DuckDB's different statement types.\ntypedef enum duckdb_statement_type {\n\tDUCKDB_STATEMENT_TYPE_INVALID = 0,\n\tDUCKDB_STATEMENT_TYPE_SELECT = 1,\n\tDUCKDB_STATEMENT_TYPE_INSERT = 2,\n\tDUCKDB_STATEMENT_TYPE_UPDATE = 3,\n\tDUCKDB_STATEMENT_TYPE_EXPLAIN = 4,\n\tDUCKDB_STATEMENT_TYPE_DELETE = 5,\n\tDUCKDB_STATEMENT_TYPE_PREPARE = 6,\n\tDUCKDB_STATEMENT_TYPE_CREATE = 7,\n\tDUCKDB_STATEMENT_TYPE_EXECUTE = 8,\n\tDUCKDB_STATEMENT_TYPE_ALTER = 9,\n\tDUCKDB_STATEMENT_TYPE_TRANSACTION = 10,\n\tDUCKDB_STATEMENT_TYPE_COPY = 11,\n\tDUCKDB_STATEMENT_TYPE_ANALYZE = 12,\n\tDUCKDB_STATEMENT_TYPE_VARIABLE_SET = 13,\n\tDUCKDB_STATEMENT_TYPE_CREATE_FUNC = 14,\n\tDUCKDB_STATEMENT_TYPE_DROP = 15,\n\tDUCKDB_STATEMENT_TYPE_EXPORT = 16,\n\tDUCKDB_STATEMENT_TYPE_PRAGMA = 17,\n\tDUCKDB_STATEMENT_TYPE_VACUUM = 18,\n\tDUCKDB_STATEMENT_TYPE_CALL = 19,\n\tDUCKDB_STATEMENT_TYPE_SET = 20,\n\tDUCKDB_STATEMENT_TYPE_LOAD = 21,\n\tDUCKDB_STATEMENT_TYPE_RELATION = 22,\n\tDUCKDB_STATEMENT_TYPE_EXTENSION = 23,\n\tDUCKDB_STATEMENT_TYPE_LOGICAL_PLAN = 24,\n\tDUCKDB_STATEMENT_TYPE_ATTACH = 25,\n\tDUCKDB_STATEMENT_TYPE_DETACH = 26,\n\tDUCKDB_STATEMENT_TYPE_MULTI = 27,\n} duckdb_statement_type;\n\n//! An enum over DuckDB's different error types.\ntypedef enum duckdb_error_type {\n\tDUCKDB_ERROR_INVALID = 0,\n\tDUCKDB_ERROR_OUT_OF_RANGE = 1,\n\tDUCKDB_ERROR_CONVERSION = 2,\n\tDUCKDB_ERROR_UNKNOWN_TYPE = 3,\n\tDUCKDB_ERROR_DECIMAL = 4,\n\tDUCKDB_ERROR_MISMATCH_TYPE = 5,\n\tDUCKDB_ERROR_DIVIDE_BY_ZERO = 6,\n\tDUCKDB_ERROR_OBJECT_SIZE = 7,\n\tDUCKDB_ERROR_INVALID_TYPE = 8,\n\tDUCKDB_ERROR_SERIALIZATION = 9,\n\tDUCKDB_ERROR_TRANSACTION = 10,\n\tDUCKDB_ERROR_NOT_IMPLEMENTED = 11,\n\tDUCKDB_ERROR_EXPRESSION = 12,\n\tDUCKDB_ERROR_CATALOG = 13,\n\tDUCKDB_ERROR_PARSER = 14,\n\tDUCKDB_ERROR_PLANNER = 15,\n\tDUCKDB_ERROR_SCHEDULER = 16,\n\tDUCKDB_ERROR_EXECUTOR = 17,\n\tDUCKDB_ERROR_CONSTRAINT = 18,\n\tDUCKDB_ERROR_INDEX = 19,\n\tDUCKDB_ERROR_STAT = 20,\n\tDUCKDB_ERROR_CONNECTION = 21,\n\tDUCKDB_ERROR_SYNTAX = 22,\n\tDUCKDB_ERROR_SETTINGS = 23,\n\tDUCKDB_ERROR_BINDER = 24,\n\tDUCKDB_ERROR_NETWORK = 25,\n\tDUCKDB_ERROR_OPTIMIZER = 26,\n\tDUCKDB_ERROR_NULL_POINTER = 27,\n\tDUCKDB_ERROR_IO = 28,\n\tDUCKDB_ERROR_INTERRUPT = 29,\n\tDUCKDB_ERROR_FATAL = 30,\n\tDUCKDB_ERROR_INTERNAL = 31,\n\tDUCKDB_ERROR_INVALID_INPUT = 32,\n\tDUCKDB_ERROR_OUT_OF_MEMORY = 33,\n\tDUCKDB_ERROR_PERMISSION = 34,\n\tDUCKDB_ERROR_PARAMETER_NOT_RESOLVED = 35,\n\tDUCKDB_ERROR_PARAMETER_NOT_ALLOWED = 36,\n\tDUCKDB_ERROR_DEPENDENCY = 37,\n\tDUCKDB_ERROR_HTTP = 38,\n\tDUCKDB_ERROR_MISSING_EXTENSION = 39,\n\tDUCKDB_ERROR_AUTOLOAD = 40,\n\tDUCKDB_ERROR_SEQUENCE = 41,\n\tDUCKDB_INVALID_CONFIGURATION = 42\n} duckdb_error_type;\n\n//! An enum over DuckDB's different cast modes.\ntypedef enum duckdb_cast_mode { DUCKDB_CAST_NORMAL = 0, DUCKDB_CAST_TRY = 1 } duckdb_cast_mode;\n\ntypedef enum duckdb_file_flag {\n\tDUCKDB_FILE_FLAG_INVALID = 0,\n\t// Open the file with \"read\" capabilities.\n\tDUCKDB_FILE_FLAG_READ = 1,\n\t// Open the file with \"write\" capabilities.\n\tDUCKDB_FILE_FLAG_WRITE = 2,\n\t// Create a new file, or open if it already exists.\n\tDUCKDB_FILE_FLAG_CREATE = 3,\n\t// Create a new file, or fail if it already exists.\n\tDUCKDB_FILE_FLAG_CREATE_NEW = 4,\n\t// Open the file in \"append\" mode.\n\tDUCKDB_FILE_FLAG_APPEND = 5,\n} duckdb_file_flag;\n\n//! 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.\ntypedef enum duckdb_config_option_scope {\n\tDUCKDB_CONFIG_OPTION_SCOPE_INVALID = 0,\n\t// The option is set for the duration of the current transaction only.\n\t// !! CURRENTLY NOT IMPLEMENTED !!\n\tDUCKDB_CONFIG_OPTION_SCOPE_LOCAL = 1,\n\t// The option is set for the current session/connection only.\n\tDUCKDB_CONFIG_OPTION_SCOPE_SESSION = 2,\n\t// Set the option globally for all sessions/connections.\n\tDUCKDB_CONFIG_OPTION_SCOPE_GLOBAL = 3,\n} duckdb_config_option_scope;\n\n//! An enum over DuckDB's catalog entry types.\ntypedef enum duckdb_catalog_entry_type {\n\tDUCKDB_CATALOG_ENTRY_TYPE_INVALID = 0,\n\tDUCKDB_CATALOG_ENTRY_TYPE_TABLE = 1,\n\tDUCKDB_CATALOG_ENTRY_TYPE_SCHEMA = 2,\n\tDUCKDB_CATALOG_ENTRY_TYPE_VIEW = 3,\n\tDUCKDB_CATALOG_ENTRY_TYPE_INDEX = 4,\n\tDUCKDB_CATALOG_ENTRY_TYPE_PREPARED_STATEMENT = 5,\n\tDUCKDB_CATALOG_ENTRY_TYPE_SEQUENCE = 6,\n\tDUCKDB_CATALOG_ENTRY_TYPE_COLLATION = 7,\n\tDUCKDB_CATALOG_ENTRY_TYPE_TYPE = 8,\n\tDUCKDB_CATALOG_ENTRY_TYPE_DATABASE = 9,\n} duckdb_catalog_entry_type;\n\n//===--------------------------------------------------------------------===//\n// General type definitions\n//===--------------------------------------------------------------------===//\n\n//! DuckDB's index type.\ntypedef uint64_t idx_t;\n\n//! Type definition for the data pointers of selection vectors.\ntypedef uint32_t sel_t;\n\n//! The callback to destroy data, e.g.,\n//! bind data (if any), init data (if any), extra data for replacement scans (if any), etc.\ntypedef void (*duckdb_delete_callback_t)(void *data);\n\n//! The callback to copy data, e.g., bind data (if any).\ntypedef void *(*duckdb_copy_callback_t)(void *data);\n\n//! Used for threading, contains a task state.\n//! Must be destroyed with `duckdb_destroy_task_state`.\ntypedef void *duckdb_task_state;\n\n//===--------------------------------------------------------------------===//\n// Types (no explicit freeing)\n//===--------------------------------------------------------------------===//\n\n//! DATE is stored as days since 1970-01-01.\n//! Use the `duckdb_from_date` and `duckdb_to_date` functions to extract individual information.\ntypedef struct {\n\tint32_t days;\n} duckdb_date;\n\ntypedef struct {\n\tint32_t year;\n\tint8_t month;\n\tint8_t day;\n} duckdb_date_struct;\n\n//! TIME is stored as microseconds since 00:00:00.\n//! Use the `duckdb_from_time` and `duckdb_to_time` functions to extract individual information.\ntypedef struct {\n\tint64_t micros;\n} duckdb_time;\n\ntypedef struct {\n\tint8_t hour;\n\tint8_t min;\n\tint8_t sec;\n\tint32_t micros;\n} duckdb_time_struct;\n\n//! TIME_NS is stored as nanoseconds since 00:00:00.\ntypedef struct {\n\tint64_t nanos;\n} duckdb_time_ns;\n\n//! 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.\ntypedef struct {\n\tuint64_t bits;\n} duckdb_time_tz;\n\ntypedef struct {\n\tduckdb_time_struct time;\n\tint32_t offset;\n} duckdb_time_tz_struct;\n\n//! TIMESTAMP is stored as microseconds since 1970-01-01.\n//! Use the `duckdb_from_timestamp` and `duckdb_to_timestamp` functions to extract individual information.\ntypedef struct {\n\tint64_t micros;\n} duckdb_timestamp;\n\ntypedef struct {\n\tduckdb_date_struct date;\n\tduckdb_time_struct time;\n} duckdb_timestamp_struct;\n\n//! TIMESTAMP_S is stored as seconds since 1970-01-01.\ntypedef struct {\n\tint64_t seconds;\n} duckdb_timestamp_s;\n\n//! TIMESTAMP_MS is stored as milliseconds since 1970-01-01.\ntypedef struct {\n\tint64_t millis;\n} duckdb_timestamp_ms;\n\n//! TIMESTAMP_NS is stored as nanoseconds since 1970-01-01.\ntypedef struct {\n\tint64_t nanos;\n} duckdb_timestamp_ns;\n\n//! INTERVAL is stored in months, days, and micros.\ntypedef struct {\n\tint32_t months;\n\tint32_t days;\n\tint64_t micros;\n} duckdb_interval;\n\n//! 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`.\ntypedef struct {\n\tuint64_t lower;\n\tint64_t upper;\n} duckdb_hugeint;\n\n//! 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`.\ntypedef struct {\n\tuint64_t lower;\n\tuint64_t upper;\n} duckdb_uhugeint;\n\n//! DECIMAL is composed of a width and a scale.\n//! Their value is stored in a HUGEINT.\ntypedef struct {\n\tuint8_t width;\n\tuint8_t scale;\n\tduckdb_hugeint value;\n} duckdb_decimal;\n\n//! A type holding information about the query execution progress.\ntypedef struct {\n\tdouble percentage;\n\tuint64_t rows_processed;\n\tuint64_t total_rows_to_process;\n} duckdb_query_progress_type;\n\n//! 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.\ntypedef struct {\n\tunion {\n\t\tstruct {\n\t\t\tuint32_t length;\n\t\t\tchar prefix[4];\n\t\t\tchar *ptr;\n\t\t} pointer;\n\t\tstruct {\n\t\t\tuint32_t length;\n\t\t\tchar inlined[12];\n\t\t} inlined;\n\t} value;\n} duckdb_string_t;\n\n//! 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.\ntypedef struct {\n\tuint64_t offset;\n\tuint64_t length;\n} duckdb_list_entry;\n\n//! 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`.\ntypedef struct {\n\t// Deprecated, use `duckdb_column_data`.\n\tvoid *deprecated_data;\n\t// Deprecated, use `duckdb_nullmask_data`.\n\tbool *deprecated_nullmask;\n\t// Deprecated, use `duckdb_column_type`.\n\tduckdb_type deprecated_type;\n\t// Deprecated, use `duckdb_column_name`.\n\tchar *deprecated_name;\n\tvoid *internal_data;\n} duckdb_column;\n\n//! 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.\ntypedef struct _duckdb_vector {\n\tvoid *internal_ptr;\n} * duckdb_vector;\n\n//! 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.\ntypedef struct _duckdb_selection_vector {\n\tvoid *internal_ptr;\n} * duckdb_selection_vector;\n\n//===--------------------------------------------------------------------===//\n// Types (explicit freeing/destroying)\n//===--------------------------------------------------------------------===//\n\n//! Strings are composed of a `char` pointer and a size.\n//! You must free `string.data` with `duckdb_free`.\ntypedef struct {\n\tchar *data;\n\tidx_t size;\n} duckdb_string;\n\n//! BLOBs are composed of a byte pointer and a size.\n//! You must free `blob.data` with `duckdb_free`.\ntypedef struct {\n\tvoid *data;\n\tidx_t size;\n} duckdb_blob;\n\n//! 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`.\ntypedef struct {\n\tuint8_t *data;\n\tidx_t size;\n} duckdb_bit;\n\n//! 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 little endian format.\n//! You must free `data` with `duckdb_free`.\ntypedef struct {\n\tuint8_t *data;\n\tidx_t size;\n\tbool is_negative;\n} duckdb_bignum;\n\n//! A query result consists of a pointer to its internal data.\n//! Must be freed with 'duckdb_destroy_result'.\ntypedef struct {\n\t// Deprecated, use `duckdb_column_count`.\n\tidx_t deprecated_column_count;\n\t// Deprecated, use `duckdb_row_count`.\n\tidx_t deprecated_row_count;\n\t// Deprecated, use `duckdb_rows_changed`.\n\tidx_t deprecated_rows_changed;\n\t// Deprecated, use `duckdb_column_*`-family of functions.\n\tduckdb_column *deprecated_columns;\n\t// Deprecated, use `duckdb_result_error`.\n\tchar *deprecated_error_message;\n\tvoid *internal_data;\n} duckdb_result;\n\n//! A database instance cache object. Must be destroyed with `duckdb_destroy_instance_cache`.\ntypedef struct _duckdb_instance_cache {\n\tvoid *internal_ptr;\n} * duckdb_instance_cache;\n\n//! A database object. Must be closed with `duckdb_close`.\ntypedef struct _duckdb_database {\n\tvoid *internal_ptr;\n} * duckdb_database;\n\n//! A connection to a duckdb database. Must be closed with `duckdb_disconnect`.\ntypedef struct _duckdb_connection {\n\tvoid *internal_ptr;\n} * duckdb_connection;\n\n//! A client context of a duckdb connection. Must be destroyed with `duckdb_destroy_context`.\ntypedef struct _duckdb_client_context {\n\tvoid *internal_ptr;\n} * duckdb_client_context;\n\n//! A prepared statement is a parameterized query that allows you to bind parameters to it.\n//! Must be destroyed with `duckdb_destroy_prepare`.\ntypedef struct _duckdb_prepared_statement {\n\tvoid *internal_ptr;\n} * duckdb_prepared_statement;\n\n//! Extracted statements. Must be destroyed with `duckdb_destroy_extracted`.\ntypedef struct _duckdb_extracted_statements {\n\tvoid *internal_ptr;\n} * duckdb_extracted_statements;\n\n//! The pending result represents an intermediate structure for a query that is not yet fully executed.\n//! Must be destroyed with `duckdb_destroy_pending`.\ntypedef struct _duckdb_pending_result {\n\tvoid *internal_ptr;\n} * duckdb_pending_result;\n\n//! The appender enables fast data loading into DuckDB.\n//! Must be destroyed with `duckdb_appender_destroy`.\ntypedef struct _duckdb_appender {\n\tvoid *internal_ptr;\n} * duckdb_appender;\n\n//! The table description allows querying information about the table.\n//! Must be destroyed with `duckdb_table_description_destroy`.\ntypedef struct _duckdb_table_description {\n\tvoid *internal_ptr;\n} * duckdb_table_description;\n\n//! The configuration can be used to provide start-up options for a database.\n//! Must be destroyed with `duckdb_destroy_config`.\ntypedef struct _duckdb_config {\n\tvoid *internal_ptr;\n} * duckdb_config;\n\n//! 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 = `.\ntypedef struct _duckdb_config_option {\n\tvoid *internal_ptr;\n} * duckdb_config_option;\n\n//! A logical type.\n//! Must be destroyed with `duckdb_destroy_logical_type`.\ntypedef struct _duckdb_logical_type {\n\tvoid *internal_ptr;\n} * duckdb_logical_type;\n\n//! Holds extra information to register a custom logical type.\n//! Reserved for future use.\ntypedef struct _duckdb_create_type_info {\n\tvoid *internal_ptr;\n} * duckdb_create_type_info;\n\n//! Contains a data chunk of a duckdb_result.\n//! Must be destroyed with `duckdb_destroy_data_chunk`.\ntypedef struct _duckdb_data_chunk {\n\tvoid *internal_ptr;\n} * duckdb_data_chunk;\n\n//! A value of a logical type.\n//! Must be destroyed with `duckdb_destroy_value`.\ntypedef struct _duckdb_value {\n\tvoid *internal_ptr;\n} * duckdb_value;\n\n//! Holds a recursive tree containing profiling metrics.\n//! The tree matches the query plan, and has a top-level node.\ntypedef struct _duckdb_profiling_info {\n\tvoid *internal_ptr;\n} * duckdb_profiling_info;\n\n//! Holds error data.\n//! Must be destroyed with `duckdb_destroy_error_data`.\ntypedef struct _duckdb_error_data {\n\tvoid *internal_ptr;\n} * duckdb_error_data;\n\n//! Holds a bound expression.\n//! Must be destroyed with `duckdb_destroy_expression`.\ntypedef struct _duckdb_expression {\n\tvoid *internal_ptr;\n} * duckdb_expression;\n\n//===--------------------------------------------------------------------===//\n// C API extension information\n//===--------------------------------------------------------------------===//\n\n//! Holds the state of the C API extension initialization process.\ntypedef struct _duckdb_extension_info {\n\tvoid *internal_ptr;\n} * duckdb_extension_info;\n\n//===--------------------------------------------------------------------===//\n// Function types\n//===--------------------------------------------------------------------===//\n\n//! Additional function info.\n//! When setting this info, it is necessary to pass a destroy-callback function.\ntypedef struct _duckdb_function_info {\n\tvoid *internal_ptr;\n} * duckdb_function_info;\n\n//! The bind info of a function.\n//! When setting this info, it is necessary to pass a destroy-callback function.\ntypedef struct _duckdb_bind_info {\n\tvoid *internal_ptr;\n} * duckdb_bind_info;\n\n//! Additional function initialization info.\n//! When setting this info, it is necessary to pass a destroy-callback function.\ntypedef struct _duckdb_init_info {\n\tvoid *internal_ptr;\n} * duckdb_init_info;\n\n//===--------------------------------------------------------------------===//\n// Scalar function types\n//===--------------------------------------------------------------------===//\n\n//! A scalar function. Must be destroyed with `duckdb_destroy_scalar_function`.\ntypedef struct _duckdb_scalar_function {\n\tvoid *internal_ptr;\n} * duckdb_scalar_function;\n\n//! A scalar function set. Must be destroyed with `duckdb_destroy_scalar_function_set`.\ntypedef struct _duckdb_scalar_function_set {\n\tvoid *internal_ptr;\n} * duckdb_scalar_function_set;\n\n//! The bind function callback of the scalar function.\ntypedef void (*duckdb_scalar_function_bind_t)(duckdb_bind_info info);\n\n//! The thread-local initialization function of the scalar function.\ntypedef void (*duckdb_scalar_function_init_t)(duckdb_init_info info);\n\n//! The function to execute the scalar function on an input chunk.\ntypedef void (*duckdb_scalar_function_t)(duckdb_function_info info, duckdb_data_chunk input, duckdb_vector output);\n\n//===--------------------------------------------------------------------===//\n// Aggregate function types\n//===--------------------------------------------------------------------===//\n\n//! An aggregate function. Must be destroyed with `duckdb_destroy_aggregate_function`.\ntypedef struct _duckdb_aggregate_function {\n\tvoid *internal_ptr;\n} * duckdb_aggregate_function;\n\n//! A aggregate function set. Must be destroyed with `duckdb_destroy_aggregate_function_set`.\ntypedef struct _duckdb_aggregate_function_set {\n\tvoid *internal_ptr;\n} * duckdb_aggregate_function_set;\n\n//! The state of an aggregate function.\ntypedef struct _duckdb_aggregate_state {\n\tvoid *internal_ptr;\n} * duckdb_aggregate_state;\n\n//! A function to return the aggregate state's size.\ntypedef idx_t (*duckdb_aggregate_state_size)(duckdb_function_info info);\n\n//! A function to initialize an aggregate state.\ntypedef void (*duckdb_aggregate_init_t)(duckdb_function_info info, duckdb_aggregate_state state);\n\n//! An optional function to destroy an aggregate state.\ntypedef void (*duckdb_aggregate_destroy_t)(duckdb_aggregate_state *states, idx_t count);\n\n//! A function to update a set of aggregate states with new values.\ntypedef void (*duckdb_aggregate_update_t)(duckdb_function_info info, duckdb_data_chunk input,\n duckdb_aggregate_state *states);\n\n//! A function to combine aggregate states.\ntypedef void (*duckdb_aggregate_combine_t)(duckdb_function_info info, duckdb_aggregate_state *source,\n duckdb_aggregate_state *target, idx_t count);\n\n//! A function to finalize aggregate states into a result vector.\ntypedef void (*duckdb_aggregate_finalize_t)(duckdb_function_info info, duckdb_aggregate_state *source,\n duckdb_vector result, idx_t count, idx_t offset);\n\n//===--------------------------------------------------------------------===//\n// Table function types\n//===--------------------------------------------------------------------===//\n\n//! A table function. Must be destroyed with `duckdb_destroy_table_function`.\ntypedef struct _duckdb_table_function {\n\tvoid *internal_ptr;\n} * duckdb_table_function;\n\n//! The bind function of the table function.\ntypedef void (*duckdb_table_function_bind_t)(duckdb_bind_info info);\n\n//! The possibly thread-local initialization function of the table function.\ntypedef void (*duckdb_table_function_init_t)(duckdb_init_info info);\n\n//! The function to generate an output chunk during table function execution.\ntypedef void (*duckdb_table_function_t)(duckdb_function_info info, duckdb_data_chunk output);\n\n//===--------------------------------------------------------------------===//\n// Copy function types\n//===--------------------------------------------------------------------===//\n\n//! A COPY function. Must be destroyed with `duckdb_destroy_copy_function`.\ntypedef struct _duckdb_copy_function {\n\tvoid *internal_ptr;\n} * duckdb_copy_function;\n\n//! Info for the bind function of a COPY function.\ntypedef struct _duckdb_copy_function_bind_info {\n\tvoid *internal_ptr;\n} * duckdb_copy_function_bind_info;\n\n//! Info for the global initialization function of a COPY function.\ntypedef struct _duckdb_copy_function_global_init_info {\n\tvoid *internal_ptr;\n} * duckdb_copy_function_global_init_info;\n\n//! Info for the sink function of a COPY function.\ntypedef struct _duckdb_copy_function_sink_info {\n\tvoid *internal_ptr;\n} * duckdb_copy_function_sink_info;\n\n//! Info for the finalize function of a COPY function.\ntypedef struct _duckdb_copy_function_finalize_info {\n\tvoid *internal_ptr;\n} * duckdb_copy_function_finalize_info;\n\n//! The bind function to use when binding a COPY ... TO function.\ntypedef void (*duckdb_copy_function_bind_t)(duckdb_copy_function_bind_info info);\n\n//! The initialization function to use when initializing a COPY ... TO function.\ntypedef void (*duckdb_copy_function_global_init_t)(duckdb_copy_function_global_init_info info);\n\n//! The function to sink an input chunk into during execution of a COPY ... TO function.\ntypedef void (*duckdb_copy_function_sink_t)(duckdb_copy_function_sink_info info, duckdb_data_chunk input);\n\n//! The function to finalize the COPY ... TO function execution.\ntypedef void (*duckdb_copy_function_finalize_t)(duckdb_copy_function_finalize_info info);\n\n//===--------------------------------------------------------------------===//\n// Cast types\n//===--------------------------------------------------------------------===//\n\n//! A cast function. Must be destroyed with `duckdb_destroy_cast_function`.\ntypedef struct _duckdb_cast_function {\n\tvoid *internal_ptr;\n} * duckdb_cast_function;\n\n//! The function to cast from an input vector to an output vector.\ntypedef bool (*duckdb_cast_function_t)(duckdb_function_info info, idx_t count, duckdb_vector input,\n duckdb_vector output);\n\n//===--------------------------------------------------------------------===//\n// Replacement scan types\n//===--------------------------------------------------------------------===//\n\n//! Additional replacement scan info. When setting this info, it is necessary to pass a destroy-callback function.\ntypedef struct _duckdb_replacement_scan_info {\n\tvoid *internal_ptr;\n} * duckdb_replacement_scan_info;\n\n//! A replacement scan function.\ntypedef void (*duckdb_replacement_callback_t)(duckdb_replacement_scan_info info, const char *table_name, void *data);\n\n//===--------------------------------------------------------------------===//\n// Arrow-related types\n//===--------------------------------------------------------------------===//\n\n//! Forward declare Arrow structs\n//! It is important to notice that these structs are not defined by DuckDB but are actually Arrow external objects.\n//! They're defined by the C Data Interface Arrow spec: https://arrow.apache.org/docs/format/CDataInterface.html\n\nstruct ArrowArray;\n\nstruct ArrowSchema;\n\n//! Holds an arrow query result. Must be destroyed with `duckdb_destroy_arrow`.\ntypedef struct _duckdb_arrow {\n\tvoid *internal_ptr;\n} * duckdb_arrow;\n\n//! Holds an arrow array stream. Must be destroyed with `duckdb_destroy_arrow_stream`.\ntypedef struct _duckdb_arrow_stream {\n\tvoid *internal_ptr;\n} * duckdb_arrow_stream;\n\n//! Holds an arrow schema. Remember to release the respective ArrowSchema object.\ntypedef struct _duckdb_arrow_schema {\n\tvoid *internal_ptr;\n} * duckdb_arrow_schema;\n\n//! 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`\ntypedef struct _duckdb_arrow_converted_schema {\n\tvoid *internal_ptr;\n} * duckdb_arrow_converted_schema;\n\n//! Holds an arrow array. Remember to release the respective ArrowSchema object.\ntypedef struct _duckdb_arrow_array {\n\tvoid *internal_ptr;\n} * duckdb_arrow_array;\n\n//! 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`\ntypedef struct _duckdb_arrow_options {\n\tvoid *internal_ptr;\n} * duckdb_arrow_options;\n\n//===--------------------------------------------------------------------===//\n// Virtual File System Access\n//===--------------------------------------------------------------------===//\n\ntypedef struct _duckdb_file_open_options {\n\tvoid *internal_ptr;\n} * duckdb_file_open_options;\n\ntypedef struct _duckdb_file_system {\n\tvoid *internal_ptr;\n} * duckdb_file_system;\n\ntypedef struct _duckdb_file_handle {\n\tvoid *internal_ptr;\n} * duckdb_file_handle;\n\n//===--------------------------------------------------------------------===//\n// Catalog Interface\n//===--------------------------------------------------------------------===//\n\n//! A handle to a database catalog.\n//! Must be destroyed with `duckdb_destroy_catalog`.\ntypedef struct _duckdb_catalog {\n\tvoid *internal_ptr;\n} * duckdb_catalog;\n\n//! A handle to a catalog entry (e.g., table, view, index, etc.).\n//! Must be destroyed with `duckdb_destroy_catalog_entry`.\ntypedef struct _duckdb_catalog_entry {\n\tvoid *internal_ptr;\n} * duckdb_catalog_entry;\n\n//===--------------------------------------------------------------------===//\n// Logging Types\n//===--------------------------------------------------------------------===//\n\n//! Holds a log storage object.\ntypedef struct _duckdb_log_storage {\n\tvoid *internal_ptr;\n} * duckdb_log_storage;\n\n//! This function is missing the logging context, which will be added later.\ntypedef void (*duckdb_logger_write_log_entry_t)(void *extra_data, duckdb_timestamp *timestamp, const char *level,\n const char *log_type, const char *log_message);\n\n//===--------------------------------------------------------------------===//\n// DuckDB extension access\n//===--------------------------------------------------------------------===//\n\n//! Passed to C API extension as a parameter to the entrypoint.\nstruct duckdb_extension_access {\n\t//! Indicate that an error has occurred.\n\tvoid (*set_error)(duckdb_extension_info info, const char *error);\n\t//! Fetch the database on which to register the extension.\n\tduckdb_database *(*get_database)(duckdb_extension_info info);\n\t//! Fetch the API struct pointer.\n\tconst void *(*get_api)(duckdb_extension_info info, const char *version);\n};\n\n#ifndef DUCKDB_API_EXCLUDE_FUNCTIONS\n\n//===--------------------------------------------------------------------===//\n// Functions\n//===--------------------------------------------------------------------===//\n\n//----------------------------------------------------------------------------------------------------------------------\n// Open Connect\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to operate on the instance cache, databases, connections, as well as some metadata functions.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nCreates 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.\n*/\nDUCKDB_C_API duckdb_instance_cache duckdb_create_instance_cache();\n\n/*!\nCreates 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_get_or_create_from_cache(duckdb_instance_cache instance_cache, const char *path,\n duckdb_database *out_database, duckdb_config config,\n char **out_error);\n\n/*!\nDestroys an existing database instance cache and de-allocates its memory.\n\n* @param instance_cache The instance cache to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_instance_cache(duckdb_instance_cache *instance_cache);\n\n/*!\nCreates 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_open(const char *path, duckdb_database *out_database);\n\n/*!\nExtended 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_open_ext(const char *path, duckdb_database *out_database, duckdb_config config,\n char **out_error);\n\n/*!\nCloses 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.\n*/\nDUCKDB_C_API void duckdb_close(duckdb_database *database);\n\n/*!\nOpens 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);\n\n/*!\nInterrupt running query\n\n* @param connection The connection to interrupt\n*/\nDUCKDB_C_API void duckdb_interrupt(duckdb_connection connection);\n\n/*!\nGet the progress of the running query.\n\n* @param connection The connection running the query.\n* @return The query progress type containing progress information.\n*/\nDUCKDB_C_API duckdb_query_progress_type duckdb_query_progress(duckdb_connection connection);\n\n/*!\nCloses the specified connection and de-allocates all memory allocated for that connection.\n\n* @param connection The connection to close.\n*/\nDUCKDB_C_API void duckdb_disconnect(duckdb_connection *connection);\n\n/*!\nRetrieves 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`.\n*/\nDUCKDB_C_API void duckdb_connection_get_client_context(duckdb_connection connection,\n duckdb_client_context *out_context);\n\n/*!\nRetrieves the arrow options of the connection.\n\n* @param connection The connection.\n*/\nDUCKDB_C_API void duckdb_connection_get_arrow_options(duckdb_connection connection,\n duckdb_arrow_options *out_arrow_options);\n\n/*!\nReturns the connection id of the client context.\n\n* @param context The client context.\n* @return The connection id of the client context.\n*/\nDUCKDB_C_API idx_t duckdb_client_context_get_connection_id(duckdb_client_context context);\n\n/*!\nDestroys the client context and deallocates its memory.\n\n* @param context The client context to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_client_context(duckdb_client_context *context);\n\n/*!\nDestroys the arrow options and deallocates its memory.\n\n* @param arrow_options The arrow options to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_arrow_options(duckdb_arrow_options *arrow_options);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API const char *duckdb_library_version();\n\n/*!\nGet 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.\n*/\nDUCKDB_C_API duckdb_value duckdb_get_table_names(duckdb_connection connection, const char *query, bool qualified);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Configuration\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to interact with a `duckdb_config`, which is the configuration parameter for opening a database.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nInitializes 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_create_config(duckdb_config *out_config);\n\n/*!\nThis 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.\n*/\nDUCKDB_C_API size_t duckdb_config_count();\n\n/*!\nObtains 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description);\n\n/*!\nSets 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_set_config(duckdb_config config, const char *name, const char *option);\n\n/*!\nDestroys the specified configuration object and de-allocates all memory allocated for the object.\n\n* @param config The configuration object to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_config(duckdb_config *config);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Error Data\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to operate on `duckdb_error_data`, which contains, for example, the error type and message. Please use this\n// interface for all new C API functions, as it supersedes previous error handling approaches.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nCreates 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.\n*/\nDUCKDB_C_API duckdb_error_data duckdb_create_error_data(duckdb_error_type type, const char *message);\n\n/*!\nDestroys the error data and deallocates its memory.\n\n* @param error_data The error data to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_error_data(duckdb_error_data *error_data);\n\n/*!\nReturns the duckdb_error_type of the error data.\n\n* @param error_data The error data.\n* @return The error type.\n*/\nDUCKDB_C_API duckdb_error_type duckdb_error_data_error_type(duckdb_error_data error_data);\n\n/*!\nReturns the error message of the error data. Must not be freed.\n\n* @param error_data The error data.\n* @return The error message.\n*/\nDUCKDB_C_API const char *duckdb_error_data_message(duckdb_error_data error_data);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API bool duckdb_error_data_has_error(duckdb_error_data error_data);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Query Execution\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to obtain a `duckdb_result` and to retrieve metadata from it.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nExecutes 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out_result);\n\n/*!\nCloses the result and de-allocates all memory allocated for that result.\n\n* @param result The result to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_result(duckdb_result *result);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API const char *duckdb_column_name(duckdb_result *result, idx_t col);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API duckdb_type duckdb_column_type(duckdb_result *result, idx_t col);\n\n/*!\nReturns 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\n*/\nDUCKDB_C_API duckdb_statement_type duckdb_result_statement_type(duckdb_result result);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col);\n\n/*!\nReturns 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`.\n*/\nDUCKDB_C_API duckdb_arrow_options duckdb_result_get_arrow_options(duckdb_result *result);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API idx_t duckdb_column_count(duckdb_result *result);\n\n#ifndef DUCKDB_API_NO_DEPRECATED\n/*!\n**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.\n*/\nDUCKDB_C_API idx_t duckdb_row_count(duckdb_result *result);\n\n#endif\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API idx_t duckdb_rows_changed(duckdb_result *result);\n\n#ifndef DUCKDB_API_NO_DEPRECATED\n/*!\n**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.\n*/\nDUCKDB_C_API void *duckdb_column_data(duckdb_result *result, idx_t col);\n\n/*!\n**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]) {\n printf(\"Data for row %d: NULL\\n\", row);\n} else {\n printf(\"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.\n*/\nDUCKDB_C_API bool *duckdb_nullmask_data(duckdb_result *result, idx_t col);\n\n#endif\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API const char *duckdb_result_error(duckdb_result *result);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API duckdb_error_type duckdb_result_error_type(duckdb_result *result);\n\n#ifndef DUCKDB_API_NO_DEPRECATED\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_index);\n\n/*!\n**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\n*/\nDUCKDB_C_API bool duckdb_result_is_streaming(duckdb_result result);\n\n/*!\n**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.\n*/\nDUCKDB_C_API idx_t duckdb_result_chunk_count(duckdb_result result);\n\n#endif\n\n/*!\nReturns 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\n*/\nDUCKDB_C_API duckdb_result_type duckdb_result_return_type(duckdb_result result);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Safe Fetch Functions\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Deprecated functions to interact with a `duckdb_result`.\n//\n// DEPRECATION NOTICE:\n// This function group is deprecated and scheduled for removal.\n//\n// USE INSTEAD:\n// To access the values in a result, use `duckdb_fetch_chunk` repeatedly. For each chunk, use the `duckdb_data_chunk`\n// interface to access any columns and their values.\n//----------------------------------------------------------------------------------------------------------------------\n\n#ifndef DUCKDB_API_NO_DEPRECATED\n/*!\n**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.\n*/\nDUCKDB_C_API bool duckdb_value_boolean(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API int8_t duckdb_value_int8(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API int16_t duckdb_value_int16(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API int32_t duckdb_value_int32(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_uhugeint duckdb_value_uhugeint(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API uint8_t duckdb_value_uint8(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API uint16_t duckdb_value_uint16(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API uint32_t duckdb_value_uint32(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API uint64_t duckdb_value_uint64(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API float duckdb_value_float(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API double duckdb_value_double(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_date duckdb_value_date(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_time duckdb_value_time(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_timestamp duckdb_value_timestamp(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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`.\n*/\nDUCKDB_C_API char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_string duckdb_value_string(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_string duckdb_value_string_internal(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.`\n*/\nDUCKDB_C_API duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row);\n\n/*!\n**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.\n*/\nDUCKDB_C_API bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row);\n\n#endif\n\n//----------------------------------------------------------------------------------------------------------------------\n// Helpers\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Generic and `duckdb_string_t` helper functions.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nAllocate `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.\n*/\nDUCKDB_C_API void *duckdb_malloc(size_t size);\n\n/*!\nFree 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.\n*/\nDUCKDB_C_API void duckdb_free(void *ptr);\n\n/*!\nThe 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.\n*/\nDUCKDB_C_API idx_t duckdb_vector_size();\n\n/*!\nWhether or not the duckdb_string_t value is inlined.\nThis means that the data of the string does not have a separate allocation.\n\n*/\nDUCKDB_C_API bool duckdb_string_is_inlined(duckdb_string_t string);\n\n/*!\nGet the string length of a string_t\n\n* @param string The string to get the length of.\n* @return The length.\n*/\nDUCKDB_C_API uint32_t duckdb_string_t_length(duckdb_string_t string);\n\n/*!\nGet 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.\n*/\nDUCKDB_C_API const char *duckdb_string_t_data(duckdb_string_t *string);\n\n/*!\nChecks 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`.\n*/\nDUCKDB_C_API duckdb_error_data duckdb_valid_utf8_check(const char *str, idx_t len);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Date Time Timestamp Helpers\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to convert from and to `duckdb_[date, time, time_tz, timestamp]`.\n// `duckdb_is_finite_timestamp[_s, _ms, _ns]` helper functions.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nDecompose 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.\n*/\nDUCKDB_C_API duckdb_date_struct duckdb_from_date(duckdb_date date);\n\n/*!\nRe-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.\n*/\nDUCKDB_C_API duckdb_date duckdb_to_date(duckdb_date_struct date);\n\n/*!\nTest 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.\n*/\nDUCKDB_C_API bool duckdb_is_finite_date(duckdb_date date);\n\n/*!\nDecompose 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.\n*/\nDUCKDB_C_API duckdb_time_struct duckdb_from_time(duckdb_time time);\n\n/*!\nCreate 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.\n*/\nDUCKDB_C_API duckdb_time_tz duckdb_create_time_tz(int64_t micros, int32_t offset);\n\n/*!\nDecompose 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.\n*/\nDUCKDB_C_API duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz micros);\n\n/*!\nRe-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.\n*/\nDUCKDB_C_API duckdb_time duckdb_to_time(duckdb_time_struct time);\n\n/*!\nDecompose 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.\n*/\nDUCKDB_C_API duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts);\n\n/*!\nRe-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.\n*/\nDUCKDB_C_API duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts);\n\n/*!\nTest 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.\n*/\nDUCKDB_C_API bool duckdb_is_finite_timestamp(duckdb_timestamp ts);\n\n/*!\nTest 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.\n*/\nDUCKDB_C_API bool duckdb_is_finite_timestamp_s(duckdb_timestamp_s ts);\n\n/*!\nTest 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.\n*/\nDUCKDB_C_API bool duckdb_is_finite_timestamp_ms(duckdb_timestamp_ms ts);\n\n/*!\nTest 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.\n*/\nDUCKDB_C_API bool duckdb_is_finite_timestamp_ns(duckdb_timestamp_ns ts);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Hugeint and Uhugeint Helpers\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to convert from and to `duckdb_[hugeint, uhugeint]`.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nConverts 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.\n*/\nDUCKDB_C_API double duckdb_hugeint_to_double(duckdb_hugeint val);\n\n/*!\nConverts 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.\n*/\nDUCKDB_C_API duckdb_hugeint duckdb_double_to_hugeint(double val);\n\n/*!\nConverts 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.\n*/\nDUCKDB_C_API double duckdb_uhugeint_to_double(duckdb_uhugeint val);\n\n/*!\nConverts 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.\n*/\nDUCKDB_C_API duckdb_uhugeint duckdb_double_to_uhugeint(double val);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Decimal Helpers\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to convert from and to `duckdb_decimal`.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nConverts 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.\n*/\nDUCKDB_C_API duckdb_decimal duckdb_double_to_decimal(double val, uint8_t width, uint8_t scale);\n\n/*!\nConverts 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.\n*/\nDUCKDB_C_API double duckdb_decimal_to_double(duckdb_decimal val);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Prepared Statements\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// A prepared statement is a parameterized query, and you can bind parameters to it. Prepared statements are commonly\n// used to easily supply parameters to functions and avoid SQL injection attacks. They also speed up queries that are\n// executed repeatedly with different parameters. That is because the query is only parsed, bound, optimized and planned\n// once during the prepare stage, rather than once per execution, if it is possible to resolve all parameter types.\n//\n// For example:\n// SELECT * FROM tbl WHERE id = ?\n// Or a query with multiple parameters:\n// SELECT * FROM tbl WHERE id = $1 OR name = $2\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nCreate 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,\n duckdb_prepared_statement *out_prepared_statement);\n\n/*!\nCloses the prepared statement and de-allocates all memory allocated for the statement.\n\n* @param prepared_statement The prepared statement to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_prepare(duckdb_prepared_statement *prepared_statement);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index);\n\n/*!\nReturns 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\n*/\nDUCKDB_C_API duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx);\n\n/*!\nReturns 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\n*/\nDUCKDB_C_API duckdb_logical_type duckdb_param_logical_type(duckdb_prepared_statement prepared_statement,\n idx_t param_idx);\n\n/*!\nClear the params bind to the prepared statement.\n*/\nDUCKDB_C_API duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement);\n\n/*!\nReturns 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\n*/\nDUCKDB_C_API duckdb_statement_type duckdb_prepared_statement_type(duckdb_prepared_statement statement);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API idx_t duckdb_prepared_statement_column_count(duckdb_prepared_statement prepared_statement);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API const char *duckdb_prepared_statement_column_name(duckdb_prepared_statement prepared_statement,\n idx_t col_idx);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API duckdb_logical_type\nduckdb_prepared_statement_column_logical_type(duckdb_prepared_statement prepared_statement, idx_t col_idx);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API duckdb_type duckdb_prepared_statement_column_type(duckdb_prepared_statement prepared_statement,\n idx_t col_idx);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Bind Values to Prepared Statements\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to bind values to prepared statements. Try to use `duckdb_bind_value` and the `duckdb_create_...` interface\n// for all types.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nBinds 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.).\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_value val);\n\n/*!\nRetrieve the index of the parameter for the prepared statement, identified by name\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement,\n idx_t *param_idx_out, const char *name);\n\n/*!\nBinds a bool value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_boolean(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val);\n\n/*!\nBinds an int8_t value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_int8(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val);\n\n/*!\nBinds an int16_t value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_int16(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val);\n\n/*!\nBinds an int32_t value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_int32(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val);\n\n/*!\nBinds an int64_t value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val);\n\n/*!\nBinds a duckdb_hugeint value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_hugeint val);\n\n/*!\nBinds a duckdb_uhugeint value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_uhugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_uhugeint val);\n\n/*!\nBinds a duckdb_decimal value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_decimal val);\n\n/*!\nBinds a uint8_t value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val);\n\n/*!\nBinds a uint16_t value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_uint16(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n uint16_t val);\n\n/*!\nBinds a uint32_t value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_uint32(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n uint32_t val);\n\n/*!\nBinds a uint64_t value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n uint64_t val);\n\n/*!\nBinds a float value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val);\n\n/*!\nBinds a double value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val);\n\n/*!\nBinds a duckdb_date value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_date(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_date val);\n\n/*!\nBinds a duckdb_time value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_time(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_time val);\n\n/*!\nBinds a duckdb_timestamp value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_timestamp val);\n\n/*!\nBinds a duckdb_timestamp value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_timestamp_tz(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_timestamp val);\n\n/*!\nBinds a duckdb_interval value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n duckdb_interval val);\n\n/*!\nBinds a null-terminated varchar value to the prepared statement at the specified index.\n\nSuperseded by `duckdb_bind_value`.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n const char *val);\n\n/*!\nBinds a varchar value to the prepared statement at the specified index.\n\nSuperseded by `duckdb_bind_value`.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n const char *val, idx_t length);\n\n/*!\nBinds a blob value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx,\n const void *data, idx_t length);\n\n/*!\nBinds a NULL value to the prepared statement at the specified index.\n*/\nDUCKDB_C_API duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Execute Prepared Statements\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to execute a prepared statement.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nExecutes 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement,\n duckdb_result *out_result);\n\n#ifndef DUCKDB_API_NO_DEPRECATED\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepared_statement,\n duckdb_result *out_result);\n\n#endif\n\n//----------------------------------------------------------------------------------------------------------------------\n// Extract Statements\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// A query string can be extracted into multiple SQL statements. Each statement should be prepared and executed\n// separately.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nExtract 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.\n*/\nDUCKDB_C_API idx_t duckdb_extract_statements(duckdb_connection connection, const char *query,\n duckdb_extracted_statements *out_extracted_statements);\n\n/*!\nPrepare 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_prepare_extracted_statement(duckdb_connection connection,\n duckdb_extracted_statements extracted_statements,\n idx_t index,\n duckdb_prepared_statement *out_prepared_statement);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API const char *duckdb_extract_statements_error(duckdb_extracted_statements extracted_statements);\n\n/*!\nDe-allocates all memory allocated for the extracted statements.\n* @param extracted_statements The extracted statements to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_extracted(duckdb_extracted_statements *extracted_statements);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Pending Result Interface\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to interact with a pending result. First, prepare a pending result, and then execute it.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nExecutes 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement,\n duckdb_pending_result *out_result);\n\n#ifndef DUCKDB_API_NO_DEPRECATED\n/*!\n**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.\n*/\nDUCKDB_C_API duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,\n duckdb_pending_result *out_result);\n\n#endif\n\n/*!\nCloses the pending result and de-allocates all memory allocated for the result.\n\n* @param pending_result The pending result to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_pending(duckdb_pending_result *pending_result);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API const char *duckdb_pending_error(duckdb_pending_result pending_result);\n\n/*!\nExecutes 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.\n*/\nDUCKDB_C_API duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_result);\n\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_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.\n*/\nDUCKDB_C_API duckdb_pending_state duckdb_pending_execute_check_state(duckdb_pending_result pending_result);\n\n/*!\nFully 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.\n*/\nDUCKDB_C_API duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb_result *out_result);\n\n/*!\nReturns 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.\n*/\nDUCKDB_C_API bool duckdb_pending_execution_is_finished(duckdb_pending_state pending_state);\n\n//----------------------------------------------------------------------------------------------------------------------\n// Value Interface\n//----------------------------------------------------------------------------------------------------------------------\n// DESCRIPTION:\n// Functions to create a `duckdb_value` for each of DuckDB's supported data types, and to access the contents of a\n// `duckdb_value`. The `duckdb_value` wrapper allows handling of primitive and arbitrarily (nested) types through the\n// same interface.\n//----------------------------------------------------------------------------------------------------------------------\n\n/*!\nDestroys the value and de-allocates all memory allocated for that type.\n\n* @param value The value to destroy.\n*/\nDUCKDB_C_API void duckdb_destroy_value(duckdb_value *value);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_varchar(const char *text);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_varchar_length(const char *text, idx_t length);\n\n/*!\nCreates a value from a boolean\n\n* @param input The boolean value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_bool(bool input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_int8(int8_t input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_uint8(uint8_t input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_int16(int16_t input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_uint16(uint16_t input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_int32(int32_t input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_uint32(uint32_t input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_uint64(uint64_t input);\n\n/*!\nCreates a value from an int64\n\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_int64(int64_t val);\n\n/*!\nCreates a value from a hugeint\n\n* @param input The hugeint value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_hugeint(duckdb_hugeint input);\n\n/*!\nCreates a value from a uhugeint\n\n* @param input The uhugeint value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_uhugeint(duckdb_uhugeint input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_bignum(duckdb_bignum input);\n\n/*!\nCreates a DECIMAL value from a duckdb_decimal\n\n* @param input The duckdb_decimal value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_decimal(duckdb_decimal input);\n\n/*!\nCreates a value from a float\n\n* @param input The float value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_float(float input);\n\n/*!\nCreates a value from a double\n\n* @param input The double value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_double(double input);\n\n/*!\nCreates a value from a date\n\n* @param input The date value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_date(duckdb_date input);\n\n/*!\nCreates a value from a time\n\n* @param input The time value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_time(duckdb_time input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_time_ns(duckdb_time_ns input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_time_tz_value(duckdb_time_tz value);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_timestamp(duckdb_timestamp input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_timestamp_tz(duckdb_timestamp input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_timestamp_s(duckdb_timestamp_s input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_timestamp_ms(duckdb_timestamp_ms input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_timestamp_ns(duckdb_timestamp_ns input);\n\n/*!\nCreates a value from an interval\n\n* @param input The interval value\n* @return The value. This must be destroyed with `duckdb_destroy_value`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_interval(duckdb_interval input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_blob(const uint8_t *data, idx_t length);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_bit(duckdb_bit input);\n\n/*!\nCreates 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`.\n*/\nDUCKDB_C_API duckdb_value duckdb_create_uuid(duckdb_uhugeint input);\n\n/*!\nReturns 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\n*/\nDUCKDB_C_API bool duckdb_get_bool(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API int8_t duckdb_get_int8(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API uint8_t duckdb_get_uint8(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API int16_t duckdb_get_int16(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API uint16_t duckdb_get_uint16(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API int32_t duckdb_get_int32(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API uint32_t duckdb_get_uint32(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API int64_t duckdb_get_int64(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API uint64_t duckdb_get_uint64(duckdb_value val);\n\n/*!\nReturns the hugeint value of the given value.\n\n* @param val A duckdb_value containing a hugeint\n* @return A duckdb_hugeint, or MinValue if the value cannot be converted\n*/\nDUCKDB_C_API duckdb_hugeint duckdb_get_hugeint(duckdb_value val);\n\n/*!\nReturns the uhugeint value of the given value.\n\n* @param val A duckdb_value containing a uhugeint\n* @return A duckdb_uhugeint, or MinValue if the value cannot be converted\n*/\nDUCKDB_C_API duckdb_uhugeint duckdb_get_uhugeint(duckdb_value val);\n\n/*!\nReturns 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`.\n*/\nDUCKDB_C_API duckdb_bignum duckdb_get_bignum(duckdb_value val);\n\n/*!\nReturns 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 if the value cannot be converted\n*/\nDUCKDB_C_API duckdb_decimal duckdb_get_decimal(duckdb_value val);\n\n/*!\nReturns 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\n*/\nDUCKDB_C_API float duckdb_get_float(duckdb_value val);\n\n/*!\nReturns 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\n*/\nDUCKDB_C_API double duckdb_get_double(duckdb_value val);\n\n/*!\nReturns the date value of the given value.\n\n* @param val A duckdb_value containing a date\n* @return A duckdb_date, or MinValue if the value cannot be converted\n*/\nDUCKDB_C_API duckdb_date duckdb_get_date(duckdb_value val);\n\n/*!\nReturns the time value of the given value.\n\n* @param val A duckdb_value containing a time\n* @return A duckdb_time, or MinValue