├── .github └── workflows │ └── MainDistributionPipeline.yml ├── .gitignore ├── .gitmodules ├── CMakeLists.txt ├── Makefile ├── README.md ├── duckdb_capi ├── README.md ├── duckdb.h └── duckdb_extension.h ├── src ├── add_numbers.c ├── capi_quack.c └── include │ └── add_numbers.h └── test └── sql └── capi_quack.test /.github/workflows/MainDistributionPipeline.yml: -------------------------------------------------------------------------------- 1 | # 2 | # This workflow calls the main distribution pipeline from DuckDB to build, test and (optionally) release the extension 3 | # 4 | name: Main Extension Distribution Pipeline 5 | on: 6 | push: 7 | pull_request: 8 | workflow_dispatch: 9 | 10 | concurrency: 11 | group: ${{ github.workflow }}-${{ github.ref }}-${{ github.head_ref || '' }}-${{ github.base_ref || '' }}-${{ github.ref != 'refs/heads/main' || github.sha }} 12 | cancel-in-progress: true 13 | 14 | jobs: 15 | duckdb-build: 16 | name: Build extension binaries 17 | uses: duckdb/extension-ci-tools/.github/workflows/_extension_distribution.yml@v1.3.0 18 | with: 19 | duckdb_version: v1.3.0 20 | ci_tools_version: v1.3.0 21 | extension_name: capi_quack 22 | extra_toolchains: python3 23 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | cmake_build 2 | build 3 | configure 4 | .idea 5 | duckdb_unittest_tempdir 6 | /test/bin 7 | venv -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "extension-ci-tools"] 2 | path = extension-ci-tools 3 | url = https://github.com/duckdb/extension-ci-tools 4 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.5...3.29) 2 | option(DUCKDB_WASM_EXTENSIONS "Whether compiling for Wasm target" OFF) 3 | 4 | ### 5 | # Configuration 6 | ### 7 | if(NOT DEFINED EXTENSION_NAME) 8 | message(FATAL_ERROR "DuckDB extension name is required") 9 | endif() 10 | if (DEFINED TARGET_DUCKDB_VERSION_MAJOR) 11 | add_definitions(-DDUCKDB_EXTENSION_API_VERSION_MAJOR=${TARGET_DUCKDB_VERSION_MAJOR}) 12 | endif() 13 | if (DEFINED TARGET_DUCKDB_VERSION_MINOR) 14 | add_definitions(-DDUCKDB_EXTENSION_API_VERSION_MINOR=${TARGET_DUCKDB_VERSION_MINOR}) 15 | endif() 16 | if (DEFINED TARGET_DUCKDB_VERSION_PATCH) 17 | add_definitions(-DDUCKDB_EXTENSION_API_VERSION_PATCH=${TARGET_DUCKDB_VERSION_PATCH}) 18 | endif() 19 | 20 | add_definitions(-DDUCKDB_EXTENSION_NAME=${EXTENSION_NAME}) 21 | 22 | if (DEFINED DUCKDB_EXTENSION_API_VERSION_UNSTABLE) 23 | add_definitions(-DDUCKDB_EXTENSION_API_VERSION_UNSTABLE=${DUCKDB_EXTENSION_API_VERSION_UNSTABLE}) 24 | endif() 25 | 26 | ### 27 | # Build 28 | ### 29 | project(${EXTENSION_NAME} LANGUAGES C) 30 | 31 | # Create Extension library 32 | set(EXTENSION_SOURCES 33 | src/add_numbers.c 34 | src/capi_quack.c 35 | ) 36 | 37 | if (DUCKDB_WASM_EXTENSION) 38 | add_library(${EXTENSION_NAME} STATIC ${EXTENSION_SOURCES}) 39 | else() 40 | add_library(${EXTENSION_NAME} SHARED ${EXTENSION_SOURCES}) 41 | endif() 42 | 43 | # Hide symbols 44 | set(CMAKE_CXX_VISIBILITY_PRESET hidden) 45 | set(CMAKE_C_VISIBILITY_PRESET hidden) 46 | set(VISIBILITY_INLINES_HIDDEN ON) 47 | set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -s") 48 | set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s") 49 | 50 | # Include own headers 51 | target_include_directories(${EXTENSION_NAME} PRIVATE src/include) 52 | 53 | # Include DuckDB C API headers 54 | target_include_directories(${EXTENSION_NAME} PRIVATE duckdb_capi) 55 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: clean clean_all 2 | 3 | PROJ_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST)))) 4 | 5 | # Main extension configuration 6 | EXTENSION_NAME=capi_quack 7 | 8 | # Set to 1 to enable Unstable API (binaries will only work on TARGET_DUCKDB_VERSION, forwards compatibility will be broken) 9 | # WARNING: When set to 1, the duckdb_extension.h from the TARGET_DUCKDB_VERSION must be used, using any other version of 10 | # the header is unsafe. 11 | USE_UNSTABLE_C_API=0 12 | 13 | # The DuckDB version to target 14 | TARGET_DUCKDB_VERSION=v1.2.0 15 | 16 | all: configure release 17 | 18 | # Include makefiles from DuckDB 19 | include extension-ci-tools/makefiles/c_api_extensions/base.Makefile 20 | include extension-ci-tools/makefiles/c_api_extensions/c_cpp.Makefile 21 | 22 | configure: venv platform extension_version 23 | 24 | debug: build_extension_library_debug build_extension_with_metadata_debug 25 | release: build_extension_library_release build_extension_with_metadata_release 26 | 27 | test: test_debug 28 | test_debug: test_extension_debug 29 | test_release: test_extension_release 30 | 31 | clean: clean_build clean_cmake 32 | clean_all: clean clean_configure -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # DuckDB C/C++ extension template 2 | This is an **experimental** template for C/C++ based extensions that link with the **C Extension API** of DuckDB. Note that this 3 | is different from https://github.com/duckdb/extension-template, which links against the C++ API of DuckDB. 4 | 5 | Features: 6 | - No DuckDB build required 7 | - CI/CD chain preconfigured 8 | - (Coming soon) Works with community extensions 9 | 10 | ## Cloning 11 | Clone the repo with submodules 12 | 13 | ```shell 14 | git clone --recurse-submodules 15 | ``` 16 | 17 | ## Dependencies 18 | In principle, compiling this template only requires a C/C++ toolchain. However, this template relies on some additional 19 | tooling to make life a little easier and to be able to share CI/CD infrastructure with extension templates for other languages: 20 | 21 | - Python3 22 | - Python3-venv 23 | - [Make](https://www.gnu.org/software/make) 24 | - CMake 25 | - Git 26 | - (Optional) Ninja + ccache 27 | 28 | Installing these dependencies will vary per platform: 29 | - For Linux, these come generally pre-installed or are available through the distro-specific package manager. 30 | - For MacOS, [homebrew](https://formulae.brew.sh/). 31 | - For Windows, [chocolatey](https://community.chocolatey.org/). 32 | 33 | ## Building 34 | After installing the dependencies, building is a two-step process. Firstly run: 35 | ```shell 36 | make configure 37 | ``` 38 | This will ensure a Python venv is set up with DuckDB and DuckDB's test runner installed. Additionally, depending on configuration, 39 | DuckDB will be used to determine the correct platform for which you are compiling. 40 | 41 | Then, to build the extension run: 42 | ```shell 43 | make debug 44 | ``` 45 | This delegates the build process to cargo, which will produce a shared library in `target/debug/`. After this step, 46 | a script is run to transform the shared library into a loadable extension by appending a binary footer. The resulting extension is written 47 | to the `build/debug` directory. 48 | 49 | To create optimized release binaries, simply run `make release` instead. 50 | 51 | ### Faster builds 52 | We recommend to install Ninja and Ccache for building as this can have a significant speed boost during development. After installing, ninja can be used 53 | by running: 54 | ```shell 55 | make clean 56 | GEN=ninja make debug 57 | ``` 58 | 59 | ## Testing 60 | This extension uses the DuckDB Python client for testing. This should be automatically installed in the `make configure` step. 61 | The tests themselves are written in the SQLLogicTest format, just like most of DuckDB's tests. A sample test can be found in 62 | `test/sql/.test`. To run the tests using the *debug* build: 63 | 64 | ```shell 65 | make test_debug 66 | ``` 67 | 68 | or for the *release* build: 69 | ```shell 70 | make test_release 71 | ``` 72 | 73 | ### Version switching 74 | Testing with different DuckDB versions is really simple: 75 | 76 | First, run 77 | ``` 78 | make clean_all 79 | ``` 80 | to ensure the previous `make configure` step is deleted. 81 | 82 | Then, run 83 | ``` 84 | DUCKDB_TEST_VERSION=v1.1.2 make configure 85 | ``` 86 | to select a different duckdb version to test with 87 | 88 | Finally, build and test with 89 | ``` 90 | make debug 91 | make test_debug 92 | ``` 93 | 94 | ### Using unstable Extension C API functionality 95 | The DuckDB Extension C API has a stable part and an unstable part. By default, this template only allows usage of the stable 96 | part of the API. To switch it to allow using the unstable part, take the following steps: 97 | 98 | Firstly, set your `TARGET_DUCKDB_VERSION` to your desired in `./Makefile`. Then, run `make update_duckdb_headers` to ensure 99 | the headers in `./duckdb_capi` are set to the correct version. (FIXME: this is not yet working properly). 100 | 101 | Finally, set `USE_UNSTABLE_C_API` to 1 in `./Makefile`. That's all! -------------------------------------------------------------------------------- /duckdb_capi/README.md: -------------------------------------------------------------------------------- 1 | # DuckDB C API Headers 2 | This directory contains the C API headers of DuckDB. These headers should generally match the `TARGET_DUCKDB_VERSION` 3 | that is specified in the `Makefile`. Note that these headers can be updated automatically 4 | to match the `TARGET_DUCKDB_VERSION` makefile variable by running (assuming the default makefile setup): 5 | 6 | ```shell 7 | make update_duckdb_headers 8 | ``` 9 | 10 | Of course manually updating the headers is also fine, just make sure that the headers are always from the same 11 | DuckDB version and that they are not from a later release of DuckDB than is specified in the `TARGET_DUCKDB_VERSION` 12 | build variable. Using headers from an older version than `TARGET_DUCKDB_VERSION` is allowed, but you probably don't want 13 | that. -------------------------------------------------------------------------------- /duckdb_capi/duckdb_extension.h: -------------------------------------------------------------------------------- 1 | //===----------------------------------------------------------------------===// 2 | // 3 | // DuckDB 4 | // 5 | // duckdb_extension.h 6 | // 7 | // 8 | //===----------------------------------------------------------------------===// 9 | // 10 | // !!!!!!! 11 | // WARNING: this file is autogenerated by scripts/generate_c_api.py, manual changes will be overwritten 12 | // !!!!!!! 13 | 14 | // WARNING: this API is not yet stable, meaning it is only guaranteed to work for this specific DuckDB version. 15 | 16 | #pragma once 17 | 18 | #include "duckdb.h" 19 | 20 | //===--------------------------------------------------------------------===// 21 | // Util Macros 22 | //===--------------------------------------------------------------------===// 23 | 24 | #ifdef __cplusplus 25 | #define DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN extern "C" { 26 | #define DUCKDB_EXTENSION_EXTERN_C_GUARD_CLOSE } 27 | #else 28 | #define DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN 29 | #define DUCKDB_EXTENSION_EXTERN_C_GUARD_CLOSE 30 | #endif 31 | 32 | #define DUCKDB_EXTENSION_GLUE_HELPER(x, y) x##y 33 | #define DUCKDB_EXTENSION_GLUE(x, y) DUCKDB_EXTENSION_GLUE_HELPER(x, y) 34 | #define DUCKDB_EXTENSION_STR_HELPER(x) #x 35 | #define DUCKDB_EXTENSION_STR(x) DUCKDB_EXTENSION_STR_HELPER(x) 36 | #define DUCKDB_EXTENSION_SEMVER_STRING(major, minor, patch) \ 37 | "v" DUCKDB_EXTENSION_STR_HELPER(major) "." DUCKDB_EXTENSION_STR_HELPER(minor) "." DUCKDB_EXTENSION_STR_HELPER(patch) 38 | 39 | //===--------------------------------------------------------------------===// 40 | // Versioning 41 | //===--------------------------------------------------------------------===// 42 | //! Set version to latest if no explicit version is defined 43 | 44 | #if !defined(DUCKDB_EXTENSION_API_VERSION_MAJOR) && !defined(DUCKDB_EXTENSION_API_VERSION_MINOR) && \ 45 | !defined(DUCKDB_EXTENSION_API_VERSION_PATCH) 46 | #define DUCKDB_EXTENSION_API_VERSION_MAJOR 1 47 | #define DUCKDB_EXTENSION_API_VERSION_MINOR 2 48 | #define DUCKDB_EXTENSION_API_VERSION_PATCH 0 49 | #elif !(defined(DUCKDB_EXTENSION_API_VERSION_MAJOR) && defined(DUCKDB_EXTENSION_API_VERSION_MINOR) && \ 50 | defined(DUCKDB_EXTENSION_API_VERSION_PATCH)) 51 | #error "either all or none of the DUCKDB_EXTENSION_API_VERSION_ defines should be defined" 52 | #endif 53 | 54 | //! Set the DUCKDB_EXTENSION_API_VERSION_STRING which is passed to DuckDB on extension load 55 | #ifdef DUCKDB_EXTENSION_API_UNSTABLE_VERSION 56 | #define DUCKDB_EXTENSION_API_VERSION_STRING DUCKDB_EXTENSION_API_UNSTABLE_VERSION 57 | #else 58 | #define DUCKDB_EXTENSION_API_VERSION_STRING \ 59 | DUCKDB_EXTENSION_SEMVER_STRING(DUCKDB_EXTENSION_API_VERSION_MAJOR, DUCKDB_EXTENSION_API_VERSION_MINOR, \ 60 | DUCKDB_EXTENSION_API_VERSION_PATCH) 61 | #endif 62 | 63 | #if DUCKDB_EXTENSION_API_VERSION_MAJOR != 1 64 | #error "This version of the extension API header only supports API VERSION v1.x.x" 65 | #endif 66 | 67 | //===--------------------------------------------------------------------===// 68 | // Function pointer struct 69 | //===--------------------------------------------------------------------===// 70 | typedef struct { 71 | #if DUCKDB_EXTENSION_API_VERSION_MINOR > 2 || \ 72 | (DUCKDB_EXTENSION_API_VERSION_MINOR == 2 && DUCKDB_EXTENSION_API_VERSION_PATCH >= 0) // v1.2.0 73 | duckdb_state (*duckdb_open)(const char *path, duckdb_database *out_database); 74 | duckdb_state (*duckdb_open_ext)(const char *path, duckdb_database *out_database, duckdb_config config, 75 | char **out_error); 76 | void (*duckdb_close)(duckdb_database *database); 77 | duckdb_state (*duckdb_connect)(duckdb_database database, duckdb_connection *out_connection); 78 | void (*duckdb_interrupt)(duckdb_connection connection); 79 | duckdb_query_progress_type (*duckdb_query_progress)(duckdb_connection connection); 80 | void (*duckdb_disconnect)(duckdb_connection *connection); 81 | const char *(*duckdb_library_version)(); 82 | duckdb_state (*duckdb_create_config)(duckdb_config *out_config); 83 | size_t (*duckdb_config_count)(); 84 | duckdb_state (*duckdb_get_config_flag)(size_t index, const char **out_name, const char **out_description); 85 | duckdb_state (*duckdb_set_config)(duckdb_config config, const char *name, const char *option); 86 | void (*duckdb_destroy_config)(duckdb_config *config); 87 | duckdb_state (*duckdb_query)(duckdb_connection connection, const char *query, duckdb_result *out_result); 88 | void (*duckdb_destroy_result)(duckdb_result *result); 89 | const char *(*duckdb_column_name)(duckdb_result *result, idx_t col); 90 | duckdb_type (*duckdb_column_type)(duckdb_result *result, idx_t col); 91 | duckdb_statement_type (*duckdb_result_statement_type)(duckdb_result result); 92 | duckdb_logical_type (*duckdb_column_logical_type)(duckdb_result *result, idx_t col); 93 | idx_t (*duckdb_column_count)(duckdb_result *result); 94 | idx_t (*duckdb_rows_changed)(duckdb_result *result); 95 | const char *(*duckdb_result_error)(duckdb_result *result); 96 | duckdb_error_type (*duckdb_result_error_type)(duckdb_result *result); 97 | duckdb_result_type (*duckdb_result_return_type)(duckdb_result result); 98 | void *(*duckdb_malloc)(size_t size); 99 | void (*duckdb_free)(void *ptr); 100 | idx_t (*duckdb_vector_size)(); 101 | bool (*duckdb_string_is_inlined)(duckdb_string_t string); 102 | uint32_t (*duckdb_string_t_length)(duckdb_string_t string); 103 | const char *(*duckdb_string_t_data)(duckdb_string_t *string); 104 | duckdb_date_struct (*duckdb_from_date)(duckdb_date date); 105 | duckdb_date (*duckdb_to_date)(duckdb_date_struct date); 106 | bool (*duckdb_is_finite_date)(duckdb_date date); 107 | duckdb_time_struct (*duckdb_from_time)(duckdb_time time); 108 | duckdb_time_tz (*duckdb_create_time_tz)(int64_t micros, int32_t offset); 109 | duckdb_time_tz_struct (*duckdb_from_time_tz)(duckdb_time_tz micros); 110 | duckdb_time (*duckdb_to_time)(duckdb_time_struct time); 111 | duckdb_timestamp_struct (*duckdb_from_timestamp)(duckdb_timestamp ts); 112 | duckdb_timestamp (*duckdb_to_timestamp)(duckdb_timestamp_struct ts); 113 | bool (*duckdb_is_finite_timestamp)(duckdb_timestamp ts); 114 | double (*duckdb_hugeint_to_double)(duckdb_hugeint val); 115 | duckdb_hugeint (*duckdb_double_to_hugeint)(double val); 116 | double (*duckdb_uhugeint_to_double)(duckdb_uhugeint val); 117 | duckdb_uhugeint (*duckdb_double_to_uhugeint)(double val); 118 | duckdb_decimal (*duckdb_double_to_decimal)(double val, uint8_t width, uint8_t scale); 119 | double (*duckdb_decimal_to_double)(duckdb_decimal val); 120 | duckdb_state (*duckdb_prepare)(duckdb_connection connection, const char *query, 121 | duckdb_prepared_statement *out_prepared_statement); 122 | void (*duckdb_destroy_prepare)(duckdb_prepared_statement *prepared_statement); 123 | const char *(*duckdb_prepare_error)(duckdb_prepared_statement prepared_statement); 124 | idx_t (*duckdb_nparams)(duckdb_prepared_statement prepared_statement); 125 | const char *(*duckdb_parameter_name)(duckdb_prepared_statement prepared_statement, idx_t index); 126 | duckdb_type (*duckdb_param_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx); 127 | duckdb_logical_type (*duckdb_param_logical_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx); 128 | duckdb_state (*duckdb_clear_bindings)(duckdb_prepared_statement prepared_statement); 129 | duckdb_statement_type (*duckdb_prepared_statement_type)(duckdb_prepared_statement statement); 130 | duckdb_state (*duckdb_bind_value)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val); 131 | duckdb_state (*duckdb_bind_parameter_index)(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out, 132 | const char *name); 133 | duckdb_state (*duckdb_bind_boolean)(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val); 134 | duckdb_state (*duckdb_bind_int8)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val); 135 | duckdb_state (*duckdb_bind_int16)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val); 136 | duckdb_state (*duckdb_bind_int32)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val); 137 | duckdb_state (*duckdb_bind_int64)(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val); 138 | duckdb_state (*duckdb_bind_hugeint)(duckdb_prepared_statement prepared_statement, idx_t param_idx, 139 | duckdb_hugeint val); 140 | duckdb_state (*duckdb_bind_uhugeint)(duckdb_prepared_statement prepared_statement, idx_t param_idx, 141 | duckdb_uhugeint val); 142 | duckdb_state (*duckdb_bind_decimal)(duckdb_prepared_statement prepared_statement, idx_t param_idx, 143 | duckdb_decimal val); 144 | duckdb_state (*duckdb_bind_uint8)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val); 145 | duckdb_state (*duckdb_bind_uint16)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val); 146 | duckdb_state (*duckdb_bind_uint32)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val); 147 | duckdb_state (*duckdb_bind_uint64)(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val); 148 | duckdb_state (*duckdb_bind_float)(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val); 149 | duckdb_state (*duckdb_bind_double)(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val); 150 | duckdb_state (*duckdb_bind_date)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_date val); 151 | duckdb_state (*duckdb_bind_time)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_time val); 152 | duckdb_state (*duckdb_bind_timestamp)(duckdb_prepared_statement prepared_statement, idx_t param_idx, 153 | duckdb_timestamp val); 154 | duckdb_state (*duckdb_bind_timestamp_tz)(duckdb_prepared_statement prepared_statement, idx_t param_idx, 155 | duckdb_timestamp val); 156 | duckdb_state (*duckdb_bind_interval)(duckdb_prepared_statement prepared_statement, idx_t param_idx, 157 | duckdb_interval val); 158 | duckdb_state (*duckdb_bind_varchar)(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val); 159 | duckdb_state (*duckdb_bind_varchar_length)(duckdb_prepared_statement prepared_statement, idx_t param_idx, 160 | const char *val, idx_t length); 161 | duckdb_state (*duckdb_bind_blob)(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data, 162 | idx_t length); 163 | duckdb_state (*duckdb_bind_null)(duckdb_prepared_statement prepared_statement, idx_t param_idx); 164 | duckdb_state (*duckdb_execute_prepared)(duckdb_prepared_statement prepared_statement, duckdb_result *out_result); 165 | idx_t (*duckdb_extract_statements)(duckdb_connection connection, const char *query, 166 | duckdb_extracted_statements *out_extracted_statements); 167 | duckdb_state (*duckdb_prepare_extracted_statement)(duckdb_connection connection, 168 | duckdb_extracted_statements extracted_statements, idx_t index, 169 | duckdb_prepared_statement *out_prepared_statement); 170 | const char *(*duckdb_extract_statements_error)(duckdb_extracted_statements extracted_statements); 171 | void (*duckdb_destroy_extracted)(duckdb_extracted_statements *extracted_statements); 172 | duckdb_state (*duckdb_pending_prepared)(duckdb_prepared_statement prepared_statement, 173 | duckdb_pending_result *out_result); 174 | void (*duckdb_destroy_pending)(duckdb_pending_result *pending_result); 175 | const char *(*duckdb_pending_error)(duckdb_pending_result pending_result); 176 | duckdb_pending_state (*duckdb_pending_execute_task)(duckdb_pending_result pending_result); 177 | duckdb_pending_state (*duckdb_pending_execute_check_state)(duckdb_pending_result pending_result); 178 | duckdb_state (*duckdb_execute_pending)(duckdb_pending_result pending_result, duckdb_result *out_result); 179 | bool (*duckdb_pending_execution_is_finished)(duckdb_pending_state pending_state); 180 | void (*duckdb_destroy_value)(duckdb_value *value); 181 | duckdb_value (*duckdb_create_varchar)(const char *text); 182 | duckdb_value (*duckdb_create_varchar_length)(const char *text, idx_t length); 183 | duckdb_value (*duckdb_create_bool)(bool input); 184 | duckdb_value (*duckdb_create_int8)(int8_t input); 185 | duckdb_value (*duckdb_create_uint8)(uint8_t input); 186 | duckdb_value (*duckdb_create_int16)(int16_t input); 187 | duckdb_value (*duckdb_create_uint16)(uint16_t input); 188 | duckdb_value (*duckdb_create_int32)(int32_t input); 189 | duckdb_value (*duckdb_create_uint32)(uint32_t input); 190 | duckdb_value (*duckdb_create_uint64)(uint64_t input); 191 | duckdb_value (*duckdb_create_int64)(int64_t val); 192 | duckdb_value (*duckdb_create_hugeint)(duckdb_hugeint input); 193 | duckdb_value (*duckdb_create_uhugeint)(duckdb_uhugeint input); 194 | duckdb_value (*duckdb_create_float)(float input); 195 | duckdb_value (*duckdb_create_double)(double input); 196 | duckdb_value (*duckdb_create_date)(duckdb_date input); 197 | duckdb_value (*duckdb_create_time)(duckdb_time input); 198 | duckdb_value (*duckdb_create_time_tz_value)(duckdb_time_tz value); 199 | duckdb_value (*duckdb_create_timestamp)(duckdb_timestamp input); 200 | duckdb_value (*duckdb_create_interval)(duckdb_interval input); 201 | duckdb_value (*duckdb_create_blob)(const uint8_t *data, idx_t length); 202 | duckdb_value (*duckdb_create_varint)(duckdb_varint input); 203 | duckdb_value (*duckdb_create_decimal)(duckdb_decimal input); 204 | duckdb_value (*duckdb_create_bit)(duckdb_bit input); 205 | duckdb_value (*duckdb_create_uuid)(duckdb_uhugeint input); 206 | bool (*duckdb_get_bool)(duckdb_value val); 207 | int8_t (*duckdb_get_int8)(duckdb_value val); 208 | uint8_t (*duckdb_get_uint8)(duckdb_value val); 209 | int16_t (*duckdb_get_int16)(duckdb_value val); 210 | uint16_t (*duckdb_get_uint16)(duckdb_value val); 211 | int32_t (*duckdb_get_int32)(duckdb_value val); 212 | uint32_t (*duckdb_get_uint32)(duckdb_value val); 213 | int64_t (*duckdb_get_int64)(duckdb_value val); 214 | uint64_t (*duckdb_get_uint64)(duckdb_value val); 215 | duckdb_hugeint (*duckdb_get_hugeint)(duckdb_value val); 216 | duckdb_uhugeint (*duckdb_get_uhugeint)(duckdb_value val); 217 | float (*duckdb_get_float)(duckdb_value val); 218 | double (*duckdb_get_double)(duckdb_value val); 219 | duckdb_date (*duckdb_get_date)(duckdb_value val); 220 | duckdb_time (*duckdb_get_time)(duckdb_value val); 221 | duckdb_time_tz (*duckdb_get_time_tz)(duckdb_value val); 222 | duckdb_timestamp (*duckdb_get_timestamp)(duckdb_value val); 223 | duckdb_interval (*duckdb_get_interval)(duckdb_value val); 224 | duckdb_logical_type (*duckdb_get_value_type)(duckdb_value val); 225 | duckdb_blob (*duckdb_get_blob)(duckdb_value val); 226 | duckdb_varint (*duckdb_get_varint)(duckdb_value val); 227 | duckdb_decimal (*duckdb_get_decimal)(duckdb_value val); 228 | duckdb_bit (*duckdb_get_bit)(duckdb_value val); 229 | duckdb_uhugeint (*duckdb_get_uuid)(duckdb_value val); 230 | char *(*duckdb_get_varchar)(duckdb_value value); 231 | duckdb_value (*duckdb_create_struct_value)(duckdb_logical_type type, duckdb_value *values); 232 | duckdb_value (*duckdb_create_list_value)(duckdb_logical_type type, duckdb_value *values, idx_t value_count); 233 | duckdb_value (*duckdb_create_array_value)(duckdb_logical_type type, duckdb_value *values, idx_t value_count); 234 | idx_t (*duckdb_get_map_size)(duckdb_value value); 235 | duckdb_value (*duckdb_get_map_key)(duckdb_value value, idx_t index); 236 | duckdb_value (*duckdb_get_map_value)(duckdb_value value, idx_t index); 237 | bool (*duckdb_is_null_value)(duckdb_value value); 238 | duckdb_value (*duckdb_create_null_value)(); 239 | idx_t (*duckdb_get_list_size)(duckdb_value value); 240 | duckdb_value (*duckdb_get_list_child)(duckdb_value value, idx_t index); 241 | duckdb_value (*duckdb_create_enum_value)(duckdb_logical_type type, uint64_t value); 242 | uint64_t (*duckdb_get_enum_value)(duckdb_value value); 243 | duckdb_value (*duckdb_get_struct_child)(duckdb_value value, idx_t index); 244 | duckdb_logical_type (*duckdb_create_logical_type)(duckdb_type type); 245 | char *(*duckdb_logical_type_get_alias)(duckdb_logical_type type); 246 | void (*duckdb_logical_type_set_alias)(duckdb_logical_type type, const char *alias); 247 | duckdb_logical_type (*duckdb_create_list_type)(duckdb_logical_type type); 248 | duckdb_logical_type (*duckdb_create_array_type)(duckdb_logical_type type, idx_t array_size); 249 | duckdb_logical_type (*duckdb_create_map_type)(duckdb_logical_type key_type, duckdb_logical_type value_type); 250 | duckdb_logical_type (*duckdb_create_union_type)(duckdb_logical_type *member_types, const char **member_names, 251 | idx_t member_count); 252 | duckdb_logical_type (*duckdb_create_struct_type)(duckdb_logical_type *member_types, const char **member_names, 253 | idx_t member_count); 254 | duckdb_logical_type (*duckdb_create_enum_type)(const char **member_names, idx_t member_count); 255 | duckdb_logical_type (*duckdb_create_decimal_type)(uint8_t width, uint8_t scale); 256 | duckdb_type (*duckdb_get_type_id)(duckdb_logical_type type); 257 | uint8_t (*duckdb_decimal_width)(duckdb_logical_type type); 258 | uint8_t (*duckdb_decimal_scale)(duckdb_logical_type type); 259 | duckdb_type (*duckdb_decimal_internal_type)(duckdb_logical_type type); 260 | duckdb_type (*duckdb_enum_internal_type)(duckdb_logical_type type); 261 | uint32_t (*duckdb_enum_dictionary_size)(duckdb_logical_type type); 262 | char *(*duckdb_enum_dictionary_value)(duckdb_logical_type type, idx_t index); 263 | duckdb_logical_type (*duckdb_list_type_child_type)(duckdb_logical_type type); 264 | duckdb_logical_type (*duckdb_array_type_child_type)(duckdb_logical_type type); 265 | idx_t (*duckdb_array_type_array_size)(duckdb_logical_type type); 266 | duckdb_logical_type (*duckdb_map_type_key_type)(duckdb_logical_type type); 267 | duckdb_logical_type (*duckdb_map_type_value_type)(duckdb_logical_type type); 268 | idx_t (*duckdb_struct_type_child_count)(duckdb_logical_type type); 269 | char *(*duckdb_struct_type_child_name)(duckdb_logical_type type, idx_t index); 270 | duckdb_logical_type (*duckdb_struct_type_child_type)(duckdb_logical_type type, idx_t index); 271 | idx_t (*duckdb_union_type_member_count)(duckdb_logical_type type); 272 | char *(*duckdb_union_type_member_name)(duckdb_logical_type type, idx_t index); 273 | duckdb_logical_type (*duckdb_union_type_member_type)(duckdb_logical_type type, idx_t index); 274 | void (*duckdb_destroy_logical_type)(duckdb_logical_type *type); 275 | duckdb_state (*duckdb_register_logical_type)(duckdb_connection con, duckdb_logical_type type, 276 | duckdb_create_type_info info); 277 | duckdb_data_chunk (*duckdb_create_data_chunk)(duckdb_logical_type *types, idx_t column_count); 278 | void (*duckdb_destroy_data_chunk)(duckdb_data_chunk *chunk); 279 | void (*duckdb_data_chunk_reset)(duckdb_data_chunk chunk); 280 | idx_t (*duckdb_data_chunk_get_column_count)(duckdb_data_chunk chunk); 281 | duckdb_vector (*duckdb_data_chunk_get_vector)(duckdb_data_chunk chunk, idx_t col_idx); 282 | idx_t (*duckdb_data_chunk_get_size)(duckdb_data_chunk chunk); 283 | void (*duckdb_data_chunk_set_size)(duckdb_data_chunk chunk, idx_t size); 284 | duckdb_logical_type (*duckdb_vector_get_column_type)(duckdb_vector vector); 285 | void *(*duckdb_vector_get_data)(duckdb_vector vector); 286 | uint64_t *(*duckdb_vector_get_validity)(duckdb_vector vector); 287 | void (*duckdb_vector_ensure_validity_writable)(duckdb_vector vector); 288 | void (*duckdb_vector_assign_string_element)(duckdb_vector vector, idx_t index, const char *str); 289 | void (*duckdb_vector_assign_string_element_len)(duckdb_vector vector, idx_t index, const char *str, idx_t str_len); 290 | duckdb_vector (*duckdb_list_vector_get_child)(duckdb_vector vector); 291 | idx_t (*duckdb_list_vector_get_size)(duckdb_vector vector); 292 | duckdb_state (*duckdb_list_vector_set_size)(duckdb_vector vector, idx_t size); 293 | duckdb_state (*duckdb_list_vector_reserve)(duckdb_vector vector, idx_t required_capacity); 294 | duckdb_vector (*duckdb_struct_vector_get_child)(duckdb_vector vector, idx_t index); 295 | duckdb_vector (*duckdb_array_vector_get_child)(duckdb_vector vector); 296 | bool (*duckdb_validity_row_is_valid)(uint64_t *validity, idx_t row); 297 | void (*duckdb_validity_set_row_validity)(uint64_t *validity, idx_t row, bool valid); 298 | void (*duckdb_validity_set_row_invalid)(uint64_t *validity, idx_t row); 299 | void (*duckdb_validity_set_row_valid)(uint64_t *validity, idx_t row); 300 | duckdb_scalar_function (*duckdb_create_scalar_function)(); 301 | void (*duckdb_destroy_scalar_function)(duckdb_scalar_function *scalar_function); 302 | void (*duckdb_scalar_function_set_name)(duckdb_scalar_function scalar_function, const char *name); 303 | void (*duckdb_scalar_function_set_varargs)(duckdb_scalar_function scalar_function, duckdb_logical_type type); 304 | void (*duckdb_scalar_function_set_special_handling)(duckdb_scalar_function scalar_function); 305 | void (*duckdb_scalar_function_set_volatile)(duckdb_scalar_function scalar_function); 306 | void (*duckdb_scalar_function_add_parameter)(duckdb_scalar_function scalar_function, duckdb_logical_type type); 307 | void (*duckdb_scalar_function_set_return_type)(duckdb_scalar_function scalar_function, duckdb_logical_type type); 308 | void (*duckdb_scalar_function_set_extra_info)(duckdb_scalar_function scalar_function, void *extra_info, 309 | duckdb_delete_callback_t destroy); 310 | void (*duckdb_scalar_function_set_function)(duckdb_scalar_function scalar_function, 311 | duckdb_scalar_function_t function); 312 | duckdb_state (*duckdb_register_scalar_function)(duckdb_connection con, duckdb_scalar_function scalar_function); 313 | void *(*duckdb_scalar_function_get_extra_info)(duckdb_function_info info); 314 | void (*duckdb_scalar_function_set_error)(duckdb_function_info info, const char *error); 315 | duckdb_scalar_function_set (*duckdb_create_scalar_function_set)(const char *name); 316 | void (*duckdb_destroy_scalar_function_set)(duckdb_scalar_function_set *scalar_function_set); 317 | duckdb_state (*duckdb_add_scalar_function_to_set)(duckdb_scalar_function_set set, duckdb_scalar_function function); 318 | duckdb_state (*duckdb_register_scalar_function_set)(duckdb_connection con, duckdb_scalar_function_set set); 319 | duckdb_aggregate_function (*duckdb_create_aggregate_function)(); 320 | void (*duckdb_destroy_aggregate_function)(duckdb_aggregate_function *aggregate_function); 321 | void (*duckdb_aggregate_function_set_name)(duckdb_aggregate_function aggregate_function, const char *name); 322 | void (*duckdb_aggregate_function_add_parameter)(duckdb_aggregate_function aggregate_function, 323 | duckdb_logical_type type); 324 | void (*duckdb_aggregate_function_set_return_type)(duckdb_aggregate_function aggregate_function, 325 | duckdb_logical_type type); 326 | void (*duckdb_aggregate_function_set_functions)(duckdb_aggregate_function aggregate_function, 327 | duckdb_aggregate_state_size state_size, 328 | duckdb_aggregate_init_t state_init, 329 | duckdb_aggregate_update_t update, 330 | duckdb_aggregate_combine_t combine, 331 | duckdb_aggregate_finalize_t finalize); 332 | void (*duckdb_aggregate_function_set_destructor)(duckdb_aggregate_function aggregate_function, 333 | duckdb_aggregate_destroy_t destroy); 334 | duckdb_state (*duckdb_register_aggregate_function)(duckdb_connection con, 335 | duckdb_aggregate_function aggregate_function); 336 | void (*duckdb_aggregate_function_set_special_handling)(duckdb_aggregate_function aggregate_function); 337 | void (*duckdb_aggregate_function_set_extra_info)(duckdb_aggregate_function aggregate_function, void *extra_info, 338 | duckdb_delete_callback_t destroy); 339 | void *(*duckdb_aggregate_function_get_extra_info)(duckdb_function_info info); 340 | void (*duckdb_aggregate_function_set_error)(duckdb_function_info info, const char *error); 341 | duckdb_aggregate_function_set (*duckdb_create_aggregate_function_set)(const char *name); 342 | void (*duckdb_destroy_aggregate_function_set)(duckdb_aggregate_function_set *aggregate_function_set); 343 | duckdb_state (*duckdb_add_aggregate_function_to_set)(duckdb_aggregate_function_set set, 344 | duckdb_aggregate_function function); 345 | duckdb_state (*duckdb_register_aggregate_function_set)(duckdb_connection con, duckdb_aggregate_function_set set); 346 | duckdb_table_function (*duckdb_create_table_function)(); 347 | void (*duckdb_destroy_table_function)(duckdb_table_function *table_function); 348 | void (*duckdb_table_function_set_name)(duckdb_table_function table_function, const char *name); 349 | void (*duckdb_table_function_add_parameter)(duckdb_table_function table_function, duckdb_logical_type type); 350 | void (*duckdb_table_function_add_named_parameter)(duckdb_table_function table_function, const char *name, 351 | duckdb_logical_type type); 352 | void (*duckdb_table_function_set_extra_info)(duckdb_table_function table_function, void *extra_info, 353 | duckdb_delete_callback_t destroy); 354 | void (*duckdb_table_function_set_bind)(duckdb_table_function table_function, duckdb_table_function_bind_t bind); 355 | void (*duckdb_table_function_set_init)(duckdb_table_function table_function, duckdb_table_function_init_t init); 356 | void (*duckdb_table_function_set_local_init)(duckdb_table_function table_function, 357 | duckdb_table_function_init_t init); 358 | void (*duckdb_table_function_set_function)(duckdb_table_function table_function, duckdb_table_function_t function); 359 | void (*duckdb_table_function_supports_projection_pushdown)(duckdb_table_function table_function, bool pushdown); 360 | duckdb_state (*duckdb_register_table_function)(duckdb_connection con, duckdb_table_function function); 361 | void *(*duckdb_bind_get_extra_info)(duckdb_bind_info info); 362 | void (*duckdb_bind_add_result_column)(duckdb_bind_info info, const char *name, duckdb_logical_type type); 363 | idx_t (*duckdb_bind_get_parameter_count)(duckdb_bind_info info); 364 | duckdb_value (*duckdb_bind_get_parameter)(duckdb_bind_info info, idx_t index); 365 | duckdb_value (*duckdb_bind_get_named_parameter)(duckdb_bind_info info, const char *name); 366 | void (*duckdb_bind_set_bind_data)(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy); 367 | void (*duckdb_bind_set_cardinality)(duckdb_bind_info info, idx_t cardinality, bool is_exact); 368 | void (*duckdb_bind_set_error)(duckdb_bind_info info, const char *error); 369 | void *(*duckdb_init_get_extra_info)(duckdb_init_info info); 370 | void *(*duckdb_init_get_bind_data)(duckdb_init_info info); 371 | void (*duckdb_init_set_init_data)(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy); 372 | idx_t (*duckdb_init_get_column_count)(duckdb_init_info info); 373 | idx_t (*duckdb_init_get_column_index)(duckdb_init_info info, idx_t column_index); 374 | void (*duckdb_init_set_max_threads)(duckdb_init_info info, idx_t max_threads); 375 | void (*duckdb_init_set_error)(duckdb_init_info info, const char *error); 376 | void *(*duckdb_function_get_extra_info)(duckdb_function_info info); 377 | void *(*duckdb_function_get_bind_data)(duckdb_function_info info); 378 | void *(*duckdb_function_get_init_data)(duckdb_function_info info); 379 | void *(*duckdb_function_get_local_init_data)(duckdb_function_info info); 380 | void (*duckdb_function_set_error)(duckdb_function_info info, const char *error); 381 | void (*duckdb_add_replacement_scan)(duckdb_database db, duckdb_replacement_callback_t replacement, void *extra_data, 382 | duckdb_delete_callback_t delete_callback); 383 | void (*duckdb_replacement_scan_set_function_name)(duckdb_replacement_scan_info info, const char *function_name); 384 | void (*duckdb_replacement_scan_add_parameter)(duckdb_replacement_scan_info info, duckdb_value parameter); 385 | void (*duckdb_replacement_scan_set_error)(duckdb_replacement_scan_info info, const char *error); 386 | duckdb_value (*duckdb_profiling_info_get_metrics)(duckdb_profiling_info info); 387 | idx_t (*duckdb_profiling_info_get_child_count)(duckdb_profiling_info info); 388 | duckdb_profiling_info (*duckdb_profiling_info_get_child)(duckdb_profiling_info info, idx_t index); 389 | duckdb_state (*duckdb_appender_create)(duckdb_connection connection, const char *schema, const char *table, 390 | duckdb_appender *out_appender); 391 | duckdb_state (*duckdb_appender_create_ext)(duckdb_connection connection, const char *catalog, const char *schema, 392 | const char *table, duckdb_appender *out_appender); 393 | idx_t (*duckdb_appender_column_count)(duckdb_appender appender); 394 | duckdb_logical_type (*duckdb_appender_column_type)(duckdb_appender appender, idx_t col_idx); 395 | const char *(*duckdb_appender_error)(duckdb_appender appender); 396 | duckdb_state (*duckdb_appender_flush)(duckdb_appender appender); 397 | duckdb_state (*duckdb_appender_close)(duckdb_appender appender); 398 | duckdb_state (*duckdb_appender_destroy)(duckdb_appender *appender); 399 | duckdb_state (*duckdb_appender_add_column)(duckdb_appender appender, const char *name); 400 | duckdb_state (*duckdb_appender_clear_columns)(duckdb_appender appender); 401 | duckdb_state (*duckdb_append_data_chunk)(duckdb_appender appender, duckdb_data_chunk chunk); 402 | duckdb_state (*duckdb_table_description_create)(duckdb_connection connection, const char *schema, const char *table, 403 | duckdb_table_description *out); 404 | duckdb_state (*duckdb_table_description_create_ext)(duckdb_connection connection, const char *catalog, 405 | const char *schema, const char *table, 406 | duckdb_table_description *out); 407 | void (*duckdb_table_description_destroy)(duckdb_table_description *table_description); 408 | const char *(*duckdb_table_description_error)(duckdb_table_description table_description); 409 | duckdb_state (*duckdb_column_has_default)(duckdb_table_description table_description, idx_t index, bool *out); 410 | char *(*duckdb_table_description_get_column_name)(duckdb_table_description table_description, idx_t index); 411 | void (*duckdb_execute_tasks)(duckdb_database database, idx_t max_tasks); 412 | duckdb_task_state (*duckdb_create_task_state)(duckdb_database database); 413 | void (*duckdb_execute_tasks_state)(duckdb_task_state state); 414 | idx_t (*duckdb_execute_n_tasks_state)(duckdb_task_state state, idx_t max_tasks); 415 | void (*duckdb_finish_execution)(duckdb_task_state state); 416 | bool (*duckdb_task_state_is_finished)(duckdb_task_state state); 417 | void (*duckdb_destroy_task_state)(duckdb_task_state state); 418 | bool (*duckdb_execution_is_finished)(duckdb_connection con); 419 | duckdb_data_chunk (*duckdb_fetch_chunk)(duckdb_result result); 420 | duckdb_cast_function (*duckdb_create_cast_function)(); 421 | void (*duckdb_cast_function_set_source_type)(duckdb_cast_function cast_function, duckdb_logical_type source_type); 422 | void (*duckdb_cast_function_set_target_type)(duckdb_cast_function cast_function, duckdb_logical_type target_type); 423 | void (*duckdb_cast_function_set_implicit_cast_cost)(duckdb_cast_function cast_function, int64_t cost); 424 | void (*duckdb_cast_function_set_function)(duckdb_cast_function cast_function, duckdb_cast_function_t function); 425 | void (*duckdb_cast_function_set_extra_info)(duckdb_cast_function cast_function, void *extra_info, 426 | duckdb_delete_callback_t destroy); 427 | void *(*duckdb_cast_function_get_extra_info)(duckdb_function_info info); 428 | duckdb_cast_mode (*duckdb_cast_function_get_cast_mode)(duckdb_function_info info); 429 | void (*duckdb_cast_function_set_error)(duckdb_function_info info, const char *error); 430 | void (*duckdb_cast_function_set_row_error)(duckdb_function_info info, const char *error, idx_t row, 431 | duckdb_vector output); 432 | duckdb_state (*duckdb_register_cast_function)(duckdb_connection con, duckdb_cast_function cast_function); 433 | void (*duckdb_destroy_cast_function)(duckdb_cast_function *cast_function); 434 | bool (*duckdb_is_finite_timestamp_s)(duckdb_timestamp_s ts); 435 | bool (*duckdb_is_finite_timestamp_ms)(duckdb_timestamp_ms ts); 436 | bool (*duckdb_is_finite_timestamp_ns)(duckdb_timestamp_ns ts); 437 | duckdb_value (*duckdb_create_timestamp_tz)(duckdb_timestamp input); 438 | duckdb_value (*duckdb_create_timestamp_s)(duckdb_timestamp_s input); 439 | duckdb_value (*duckdb_create_timestamp_ms)(duckdb_timestamp_ms input); 440 | duckdb_value (*duckdb_create_timestamp_ns)(duckdb_timestamp_ns input); 441 | duckdb_timestamp (*duckdb_get_timestamp_tz)(duckdb_value val); 442 | duckdb_timestamp_s (*duckdb_get_timestamp_s)(duckdb_value val); 443 | duckdb_timestamp_ms (*duckdb_get_timestamp_ms)(duckdb_value val); 444 | duckdb_timestamp_ns (*duckdb_get_timestamp_ns)(duckdb_value val); 445 | duckdb_state (*duckdb_append_value)(duckdb_appender appender, duckdb_value value); 446 | duckdb_profiling_info (*duckdb_get_profiling_info)(duckdb_connection connection); 447 | duckdb_value (*duckdb_profiling_info_get_value)(duckdb_profiling_info info, const char *key); 448 | duckdb_state (*duckdb_appender_begin_row)(duckdb_appender appender); 449 | duckdb_state (*duckdb_appender_end_row)(duckdb_appender appender); 450 | duckdb_state (*duckdb_append_default)(duckdb_appender appender); 451 | duckdb_state (*duckdb_append_bool)(duckdb_appender appender, bool value); 452 | duckdb_state (*duckdb_append_int8)(duckdb_appender appender, int8_t value); 453 | duckdb_state (*duckdb_append_int16)(duckdb_appender appender, int16_t value); 454 | duckdb_state (*duckdb_append_int32)(duckdb_appender appender, int32_t value); 455 | duckdb_state (*duckdb_append_int64)(duckdb_appender appender, int64_t value); 456 | duckdb_state (*duckdb_append_hugeint)(duckdb_appender appender, duckdb_hugeint value); 457 | duckdb_state (*duckdb_append_uint8)(duckdb_appender appender, uint8_t value); 458 | duckdb_state (*duckdb_append_uint16)(duckdb_appender appender, uint16_t value); 459 | duckdb_state (*duckdb_append_uint32)(duckdb_appender appender, uint32_t value); 460 | duckdb_state (*duckdb_append_uint64)(duckdb_appender appender, uint64_t value); 461 | duckdb_state (*duckdb_append_uhugeint)(duckdb_appender appender, duckdb_uhugeint value); 462 | duckdb_state (*duckdb_append_float)(duckdb_appender appender, float value); 463 | duckdb_state (*duckdb_append_double)(duckdb_appender appender, double value); 464 | duckdb_state (*duckdb_append_date)(duckdb_appender appender, duckdb_date value); 465 | duckdb_state (*duckdb_append_time)(duckdb_appender appender, duckdb_time value); 466 | duckdb_state (*duckdb_append_timestamp)(duckdb_appender appender, duckdb_timestamp value); 467 | duckdb_state (*duckdb_append_interval)(duckdb_appender appender, duckdb_interval value); 468 | duckdb_state (*duckdb_append_varchar)(duckdb_appender appender, const char *val); 469 | duckdb_state (*duckdb_append_varchar_length)(duckdb_appender appender, const char *val, idx_t length); 470 | duckdb_state (*duckdb_append_blob)(duckdb_appender appender, const void *data, idx_t length); 471 | duckdb_state (*duckdb_append_null)(duckdb_appender appender); 472 | #endif 473 | 474 | // These functions have been deprecated and may be removed in future versions of DuckDB 475 | #ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE 476 | idx_t (*duckdb_row_count)(duckdb_result *result); 477 | void *(*duckdb_column_data)(duckdb_result *result, idx_t col); 478 | bool *(*duckdb_nullmask_data)(duckdb_result *result, idx_t col); 479 | duckdb_data_chunk (*duckdb_result_get_chunk)(duckdb_result result, idx_t chunk_index); 480 | bool (*duckdb_result_is_streaming)(duckdb_result result); 481 | idx_t (*duckdb_result_chunk_count)(duckdb_result result); 482 | bool (*duckdb_value_boolean)(duckdb_result *result, idx_t col, idx_t row); 483 | int8_t (*duckdb_value_int8)(duckdb_result *result, idx_t col, idx_t row); 484 | int16_t (*duckdb_value_int16)(duckdb_result *result, idx_t col, idx_t row); 485 | int32_t (*duckdb_value_int32)(duckdb_result *result, idx_t col, idx_t row); 486 | int64_t (*duckdb_value_int64)(duckdb_result *result, idx_t col, idx_t row); 487 | duckdb_hugeint (*duckdb_value_hugeint)(duckdb_result *result, idx_t col, idx_t row); 488 | duckdb_uhugeint (*duckdb_value_uhugeint)(duckdb_result *result, idx_t col, idx_t row); 489 | duckdb_decimal (*duckdb_value_decimal)(duckdb_result *result, idx_t col, idx_t row); 490 | uint8_t (*duckdb_value_uint8)(duckdb_result *result, idx_t col, idx_t row); 491 | uint16_t (*duckdb_value_uint16)(duckdb_result *result, idx_t col, idx_t row); 492 | uint32_t (*duckdb_value_uint32)(duckdb_result *result, idx_t col, idx_t row); 493 | uint64_t (*duckdb_value_uint64)(duckdb_result *result, idx_t col, idx_t row); 494 | float (*duckdb_value_float)(duckdb_result *result, idx_t col, idx_t row); 495 | double (*duckdb_value_double)(duckdb_result *result, idx_t col, idx_t row); 496 | duckdb_date (*duckdb_value_date)(duckdb_result *result, idx_t col, idx_t row); 497 | duckdb_time (*duckdb_value_time)(duckdb_result *result, idx_t col, idx_t row); 498 | duckdb_timestamp (*duckdb_value_timestamp)(duckdb_result *result, idx_t col, idx_t row); 499 | duckdb_interval (*duckdb_value_interval)(duckdb_result *result, idx_t col, idx_t row); 500 | char *(*duckdb_value_varchar)(duckdb_result *result, idx_t col, idx_t row); 501 | duckdb_string (*duckdb_value_string)(duckdb_result *result, idx_t col, idx_t row); 502 | char *(*duckdb_value_varchar_internal)(duckdb_result *result, idx_t col, idx_t row); 503 | duckdb_string (*duckdb_value_string_internal)(duckdb_result *result, idx_t col, idx_t row); 504 | duckdb_blob (*duckdb_value_blob)(duckdb_result *result, idx_t col, idx_t row); 505 | bool (*duckdb_value_is_null)(duckdb_result *result, idx_t col, idx_t row); 506 | duckdb_state (*duckdb_execute_prepared_streaming)(duckdb_prepared_statement prepared_statement, 507 | duckdb_result *out_result); 508 | duckdb_state (*duckdb_pending_prepared_streaming)(duckdb_prepared_statement prepared_statement, 509 | duckdb_pending_result *out_result); 510 | duckdb_state (*duckdb_query_arrow)(duckdb_connection connection, const char *query, duckdb_arrow *out_result); 511 | duckdb_state (*duckdb_query_arrow_schema)(duckdb_arrow result, duckdb_arrow_schema *out_schema); 512 | duckdb_state (*duckdb_prepared_arrow_schema)(duckdb_prepared_statement prepared, duckdb_arrow_schema *out_schema); 513 | void (*duckdb_result_arrow_array)(duckdb_result result, duckdb_data_chunk chunk, duckdb_arrow_array *out_array); 514 | duckdb_state (*duckdb_query_arrow_array)(duckdb_arrow result, duckdb_arrow_array *out_array); 515 | idx_t (*duckdb_arrow_column_count)(duckdb_arrow result); 516 | idx_t (*duckdb_arrow_row_count)(duckdb_arrow result); 517 | idx_t (*duckdb_arrow_rows_changed)(duckdb_arrow result); 518 | const char *(*duckdb_query_arrow_error)(duckdb_arrow result); 519 | void (*duckdb_destroy_arrow)(duckdb_arrow *result); 520 | void (*duckdb_destroy_arrow_stream)(duckdb_arrow_stream *stream_p); 521 | duckdb_state (*duckdb_execute_prepared_arrow)(duckdb_prepared_statement prepared_statement, 522 | duckdb_arrow *out_result); 523 | duckdb_state (*duckdb_arrow_scan)(duckdb_connection connection, const char *table_name, duckdb_arrow_stream arrow); 524 | duckdb_state (*duckdb_arrow_array_scan)(duckdb_connection connection, const char *table_name, 525 | duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array, 526 | duckdb_arrow_stream *out_stream); 527 | duckdb_data_chunk (*duckdb_stream_fetch_chunk)(duckdb_result result); 528 | #endif 529 | 530 | // Exposing the instance cache 531 | #ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE 532 | duckdb_instance_cache (*duckdb_create_instance_cache)(); 533 | duckdb_state (*duckdb_get_or_create_from_cache)(duckdb_instance_cache instance_cache, const char *path, 534 | duckdb_database *out_database, duckdb_config config, 535 | char **out_error); 536 | void (*duckdb_destroy_instance_cache)(duckdb_instance_cache *instance_cache); 537 | #endif 538 | 539 | // New append functions that are added 540 | #ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE 541 | duckdb_state (*duckdb_append_default_to_chunk)(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col, 542 | idx_t row); 543 | #endif 544 | 545 | } duckdb_ext_api_v1; 546 | 547 | //===--------------------------------------------------------------------===// 548 | // Typedefs mapping functions to struct entries 549 | //===--------------------------------------------------------------------===// 550 | // Version v1.2.0 551 | #define duckdb_open duckdb_ext_api.duckdb_open 552 | #define duckdb_open_ext duckdb_ext_api.duckdb_open_ext 553 | #define duckdb_close duckdb_ext_api.duckdb_close 554 | #define duckdb_connect duckdb_ext_api.duckdb_connect 555 | #define duckdb_interrupt duckdb_ext_api.duckdb_interrupt 556 | #define duckdb_query_progress duckdb_ext_api.duckdb_query_progress 557 | #define duckdb_disconnect duckdb_ext_api.duckdb_disconnect 558 | #define duckdb_library_version duckdb_ext_api.duckdb_library_version 559 | #define duckdb_create_config duckdb_ext_api.duckdb_create_config 560 | #define duckdb_config_count duckdb_ext_api.duckdb_config_count 561 | #define duckdb_get_config_flag duckdb_ext_api.duckdb_get_config_flag 562 | #define duckdb_set_config duckdb_ext_api.duckdb_set_config 563 | #define duckdb_destroy_config duckdb_ext_api.duckdb_destroy_config 564 | #define duckdb_query duckdb_ext_api.duckdb_query 565 | #define duckdb_destroy_result duckdb_ext_api.duckdb_destroy_result 566 | #define duckdb_column_name duckdb_ext_api.duckdb_column_name 567 | #define duckdb_column_type duckdb_ext_api.duckdb_column_type 568 | #define duckdb_result_statement_type duckdb_ext_api.duckdb_result_statement_type 569 | #define duckdb_column_logical_type duckdb_ext_api.duckdb_column_logical_type 570 | #define duckdb_column_count duckdb_ext_api.duckdb_column_count 571 | #define duckdb_rows_changed duckdb_ext_api.duckdb_rows_changed 572 | #define duckdb_result_error duckdb_ext_api.duckdb_result_error 573 | #define duckdb_result_error_type duckdb_ext_api.duckdb_result_error_type 574 | #define duckdb_result_return_type duckdb_ext_api.duckdb_result_return_type 575 | #define duckdb_malloc duckdb_ext_api.duckdb_malloc 576 | #define duckdb_free duckdb_ext_api.duckdb_free 577 | #define duckdb_vector_size duckdb_ext_api.duckdb_vector_size 578 | #define duckdb_string_is_inlined duckdb_ext_api.duckdb_string_is_inlined 579 | #define duckdb_string_t_length duckdb_ext_api.duckdb_string_t_length 580 | #define duckdb_string_t_data duckdb_ext_api.duckdb_string_t_data 581 | #define duckdb_from_date duckdb_ext_api.duckdb_from_date 582 | #define duckdb_to_date duckdb_ext_api.duckdb_to_date 583 | #define duckdb_is_finite_date duckdb_ext_api.duckdb_is_finite_date 584 | #define duckdb_from_time duckdb_ext_api.duckdb_from_time 585 | #define duckdb_create_time_tz duckdb_ext_api.duckdb_create_time_tz 586 | #define duckdb_from_time_tz duckdb_ext_api.duckdb_from_time_tz 587 | #define duckdb_to_time duckdb_ext_api.duckdb_to_time 588 | #define duckdb_from_timestamp duckdb_ext_api.duckdb_from_timestamp 589 | #define duckdb_to_timestamp duckdb_ext_api.duckdb_to_timestamp 590 | #define duckdb_is_finite_timestamp duckdb_ext_api.duckdb_is_finite_timestamp 591 | #define duckdb_is_finite_timestamp_s duckdb_ext_api.duckdb_is_finite_timestamp_s 592 | #define duckdb_is_finite_timestamp_ms duckdb_ext_api.duckdb_is_finite_timestamp_ms 593 | #define duckdb_is_finite_timestamp_ns duckdb_ext_api.duckdb_is_finite_timestamp_ns 594 | #define duckdb_hugeint_to_double duckdb_ext_api.duckdb_hugeint_to_double 595 | #define duckdb_double_to_hugeint duckdb_ext_api.duckdb_double_to_hugeint 596 | #define duckdb_uhugeint_to_double duckdb_ext_api.duckdb_uhugeint_to_double 597 | #define duckdb_double_to_uhugeint duckdb_ext_api.duckdb_double_to_uhugeint 598 | #define duckdb_double_to_decimal duckdb_ext_api.duckdb_double_to_decimal 599 | #define duckdb_decimal_to_double duckdb_ext_api.duckdb_decimal_to_double 600 | #define duckdb_prepare duckdb_ext_api.duckdb_prepare 601 | #define duckdb_destroy_prepare duckdb_ext_api.duckdb_destroy_prepare 602 | #define duckdb_prepare_error duckdb_ext_api.duckdb_prepare_error 603 | #define duckdb_nparams duckdb_ext_api.duckdb_nparams 604 | #define duckdb_parameter_name duckdb_ext_api.duckdb_parameter_name 605 | #define duckdb_param_type duckdb_ext_api.duckdb_param_type 606 | #define duckdb_param_logical_type duckdb_ext_api.duckdb_param_logical_type 607 | #define duckdb_clear_bindings duckdb_ext_api.duckdb_clear_bindings 608 | #define duckdb_prepared_statement_type duckdb_ext_api.duckdb_prepared_statement_type 609 | #define duckdb_bind_value duckdb_ext_api.duckdb_bind_value 610 | #define duckdb_bind_parameter_index duckdb_ext_api.duckdb_bind_parameter_index 611 | #define duckdb_bind_boolean duckdb_ext_api.duckdb_bind_boolean 612 | #define duckdb_bind_int8 duckdb_ext_api.duckdb_bind_int8 613 | #define duckdb_bind_int16 duckdb_ext_api.duckdb_bind_int16 614 | #define duckdb_bind_int32 duckdb_ext_api.duckdb_bind_int32 615 | #define duckdb_bind_int64 duckdb_ext_api.duckdb_bind_int64 616 | #define duckdb_bind_hugeint duckdb_ext_api.duckdb_bind_hugeint 617 | #define duckdb_bind_uhugeint duckdb_ext_api.duckdb_bind_uhugeint 618 | #define duckdb_bind_decimal duckdb_ext_api.duckdb_bind_decimal 619 | #define duckdb_bind_uint8 duckdb_ext_api.duckdb_bind_uint8 620 | #define duckdb_bind_uint16 duckdb_ext_api.duckdb_bind_uint16 621 | #define duckdb_bind_uint32 duckdb_ext_api.duckdb_bind_uint32 622 | #define duckdb_bind_uint64 duckdb_ext_api.duckdb_bind_uint64 623 | #define duckdb_bind_float duckdb_ext_api.duckdb_bind_float 624 | #define duckdb_bind_double duckdb_ext_api.duckdb_bind_double 625 | #define duckdb_bind_date duckdb_ext_api.duckdb_bind_date 626 | #define duckdb_bind_time duckdb_ext_api.duckdb_bind_time 627 | #define duckdb_bind_timestamp duckdb_ext_api.duckdb_bind_timestamp 628 | #define duckdb_bind_timestamp_tz duckdb_ext_api.duckdb_bind_timestamp_tz 629 | #define duckdb_bind_interval duckdb_ext_api.duckdb_bind_interval 630 | #define duckdb_bind_varchar duckdb_ext_api.duckdb_bind_varchar 631 | #define duckdb_bind_varchar_length duckdb_ext_api.duckdb_bind_varchar_length 632 | #define duckdb_bind_blob duckdb_ext_api.duckdb_bind_blob 633 | #define duckdb_bind_null duckdb_ext_api.duckdb_bind_null 634 | #define duckdb_execute_prepared duckdb_ext_api.duckdb_execute_prepared 635 | #define duckdb_extract_statements duckdb_ext_api.duckdb_extract_statements 636 | #define duckdb_prepare_extracted_statement duckdb_ext_api.duckdb_prepare_extracted_statement 637 | #define duckdb_extract_statements_error duckdb_ext_api.duckdb_extract_statements_error 638 | #define duckdb_destroy_extracted duckdb_ext_api.duckdb_destroy_extracted 639 | #define duckdb_pending_prepared duckdb_ext_api.duckdb_pending_prepared 640 | #define duckdb_destroy_pending duckdb_ext_api.duckdb_destroy_pending 641 | #define duckdb_pending_error duckdb_ext_api.duckdb_pending_error 642 | #define duckdb_pending_execute_task duckdb_ext_api.duckdb_pending_execute_task 643 | #define duckdb_pending_execute_check_state duckdb_ext_api.duckdb_pending_execute_check_state 644 | #define duckdb_execute_pending duckdb_ext_api.duckdb_execute_pending 645 | #define duckdb_pending_execution_is_finished duckdb_ext_api.duckdb_pending_execution_is_finished 646 | #define duckdb_destroy_value duckdb_ext_api.duckdb_destroy_value 647 | #define duckdb_create_varchar duckdb_ext_api.duckdb_create_varchar 648 | #define duckdb_create_varchar_length duckdb_ext_api.duckdb_create_varchar_length 649 | #define duckdb_create_bool duckdb_ext_api.duckdb_create_bool 650 | #define duckdb_create_int8 duckdb_ext_api.duckdb_create_int8 651 | #define duckdb_create_uint8 duckdb_ext_api.duckdb_create_uint8 652 | #define duckdb_create_int16 duckdb_ext_api.duckdb_create_int16 653 | #define duckdb_create_uint16 duckdb_ext_api.duckdb_create_uint16 654 | #define duckdb_create_int32 duckdb_ext_api.duckdb_create_int32 655 | #define duckdb_create_uint32 duckdb_ext_api.duckdb_create_uint32 656 | #define duckdb_create_uint64 duckdb_ext_api.duckdb_create_uint64 657 | #define duckdb_create_int64 duckdb_ext_api.duckdb_create_int64 658 | #define duckdb_create_hugeint duckdb_ext_api.duckdb_create_hugeint 659 | #define duckdb_create_uhugeint duckdb_ext_api.duckdb_create_uhugeint 660 | #define duckdb_create_varint duckdb_ext_api.duckdb_create_varint 661 | #define duckdb_create_decimal duckdb_ext_api.duckdb_create_decimal 662 | #define duckdb_create_float duckdb_ext_api.duckdb_create_float 663 | #define duckdb_create_double duckdb_ext_api.duckdb_create_double 664 | #define duckdb_create_date duckdb_ext_api.duckdb_create_date 665 | #define duckdb_create_time duckdb_ext_api.duckdb_create_time 666 | #define duckdb_create_time_tz_value duckdb_ext_api.duckdb_create_time_tz_value 667 | #define duckdb_create_timestamp duckdb_ext_api.duckdb_create_timestamp 668 | #define duckdb_create_timestamp_tz duckdb_ext_api.duckdb_create_timestamp_tz 669 | #define duckdb_create_timestamp_s duckdb_ext_api.duckdb_create_timestamp_s 670 | #define duckdb_create_timestamp_ms duckdb_ext_api.duckdb_create_timestamp_ms 671 | #define duckdb_create_timestamp_ns duckdb_ext_api.duckdb_create_timestamp_ns 672 | #define duckdb_create_interval duckdb_ext_api.duckdb_create_interval 673 | #define duckdb_create_blob duckdb_ext_api.duckdb_create_blob 674 | #define duckdb_create_bit duckdb_ext_api.duckdb_create_bit 675 | #define duckdb_create_uuid duckdb_ext_api.duckdb_create_uuid 676 | #define duckdb_get_bool duckdb_ext_api.duckdb_get_bool 677 | #define duckdb_get_int8 duckdb_ext_api.duckdb_get_int8 678 | #define duckdb_get_uint8 duckdb_ext_api.duckdb_get_uint8 679 | #define duckdb_get_int16 duckdb_ext_api.duckdb_get_int16 680 | #define duckdb_get_uint16 duckdb_ext_api.duckdb_get_uint16 681 | #define duckdb_get_int32 duckdb_ext_api.duckdb_get_int32 682 | #define duckdb_get_uint32 duckdb_ext_api.duckdb_get_uint32 683 | #define duckdb_get_int64 duckdb_ext_api.duckdb_get_int64 684 | #define duckdb_get_uint64 duckdb_ext_api.duckdb_get_uint64 685 | #define duckdb_get_hugeint duckdb_ext_api.duckdb_get_hugeint 686 | #define duckdb_get_uhugeint duckdb_ext_api.duckdb_get_uhugeint 687 | #define duckdb_get_varint duckdb_ext_api.duckdb_get_varint 688 | #define duckdb_get_decimal duckdb_ext_api.duckdb_get_decimal 689 | #define duckdb_get_float duckdb_ext_api.duckdb_get_float 690 | #define duckdb_get_double duckdb_ext_api.duckdb_get_double 691 | #define duckdb_get_date duckdb_ext_api.duckdb_get_date 692 | #define duckdb_get_time duckdb_ext_api.duckdb_get_time 693 | #define duckdb_get_time_tz duckdb_ext_api.duckdb_get_time_tz 694 | #define duckdb_get_timestamp duckdb_ext_api.duckdb_get_timestamp 695 | #define duckdb_get_timestamp_tz duckdb_ext_api.duckdb_get_timestamp_tz 696 | #define duckdb_get_timestamp_s duckdb_ext_api.duckdb_get_timestamp_s 697 | #define duckdb_get_timestamp_ms duckdb_ext_api.duckdb_get_timestamp_ms 698 | #define duckdb_get_timestamp_ns duckdb_ext_api.duckdb_get_timestamp_ns 699 | #define duckdb_get_interval duckdb_ext_api.duckdb_get_interval 700 | #define duckdb_get_value_type duckdb_ext_api.duckdb_get_value_type 701 | #define duckdb_get_blob duckdb_ext_api.duckdb_get_blob 702 | #define duckdb_get_bit duckdb_ext_api.duckdb_get_bit 703 | #define duckdb_get_uuid duckdb_ext_api.duckdb_get_uuid 704 | #define duckdb_get_varchar duckdb_ext_api.duckdb_get_varchar 705 | #define duckdb_create_struct_value duckdb_ext_api.duckdb_create_struct_value 706 | #define duckdb_create_list_value duckdb_ext_api.duckdb_create_list_value 707 | #define duckdb_create_array_value duckdb_ext_api.duckdb_create_array_value 708 | #define duckdb_get_map_size duckdb_ext_api.duckdb_get_map_size 709 | #define duckdb_get_map_key duckdb_ext_api.duckdb_get_map_key 710 | #define duckdb_get_map_value duckdb_ext_api.duckdb_get_map_value 711 | #define duckdb_is_null_value duckdb_ext_api.duckdb_is_null_value 712 | #define duckdb_create_null_value duckdb_ext_api.duckdb_create_null_value 713 | #define duckdb_get_list_size duckdb_ext_api.duckdb_get_list_size 714 | #define duckdb_get_list_child duckdb_ext_api.duckdb_get_list_child 715 | #define duckdb_create_enum_value duckdb_ext_api.duckdb_create_enum_value 716 | #define duckdb_get_enum_value duckdb_ext_api.duckdb_get_enum_value 717 | #define duckdb_get_struct_child duckdb_ext_api.duckdb_get_struct_child 718 | #define duckdb_create_logical_type duckdb_ext_api.duckdb_create_logical_type 719 | #define duckdb_logical_type_get_alias duckdb_ext_api.duckdb_logical_type_get_alias 720 | #define duckdb_logical_type_set_alias duckdb_ext_api.duckdb_logical_type_set_alias 721 | #define duckdb_create_list_type duckdb_ext_api.duckdb_create_list_type 722 | #define duckdb_create_array_type duckdb_ext_api.duckdb_create_array_type 723 | #define duckdb_create_map_type duckdb_ext_api.duckdb_create_map_type 724 | #define duckdb_create_union_type duckdb_ext_api.duckdb_create_union_type 725 | #define duckdb_create_struct_type duckdb_ext_api.duckdb_create_struct_type 726 | #define duckdb_create_enum_type duckdb_ext_api.duckdb_create_enum_type 727 | #define duckdb_create_decimal_type duckdb_ext_api.duckdb_create_decimal_type 728 | #define duckdb_get_type_id duckdb_ext_api.duckdb_get_type_id 729 | #define duckdb_decimal_width duckdb_ext_api.duckdb_decimal_width 730 | #define duckdb_decimal_scale duckdb_ext_api.duckdb_decimal_scale 731 | #define duckdb_decimal_internal_type duckdb_ext_api.duckdb_decimal_internal_type 732 | #define duckdb_enum_internal_type duckdb_ext_api.duckdb_enum_internal_type 733 | #define duckdb_enum_dictionary_size duckdb_ext_api.duckdb_enum_dictionary_size 734 | #define duckdb_enum_dictionary_value duckdb_ext_api.duckdb_enum_dictionary_value 735 | #define duckdb_list_type_child_type duckdb_ext_api.duckdb_list_type_child_type 736 | #define duckdb_array_type_child_type duckdb_ext_api.duckdb_array_type_child_type 737 | #define duckdb_array_type_array_size duckdb_ext_api.duckdb_array_type_array_size 738 | #define duckdb_map_type_key_type duckdb_ext_api.duckdb_map_type_key_type 739 | #define duckdb_map_type_value_type duckdb_ext_api.duckdb_map_type_value_type 740 | #define duckdb_struct_type_child_count duckdb_ext_api.duckdb_struct_type_child_count 741 | #define duckdb_struct_type_child_name duckdb_ext_api.duckdb_struct_type_child_name 742 | #define duckdb_struct_type_child_type duckdb_ext_api.duckdb_struct_type_child_type 743 | #define duckdb_union_type_member_count duckdb_ext_api.duckdb_union_type_member_count 744 | #define duckdb_union_type_member_name duckdb_ext_api.duckdb_union_type_member_name 745 | #define duckdb_union_type_member_type duckdb_ext_api.duckdb_union_type_member_type 746 | #define duckdb_destroy_logical_type duckdb_ext_api.duckdb_destroy_logical_type 747 | #define duckdb_register_logical_type duckdb_ext_api.duckdb_register_logical_type 748 | #define duckdb_create_data_chunk duckdb_ext_api.duckdb_create_data_chunk 749 | #define duckdb_destroy_data_chunk duckdb_ext_api.duckdb_destroy_data_chunk 750 | #define duckdb_data_chunk_reset duckdb_ext_api.duckdb_data_chunk_reset 751 | #define duckdb_data_chunk_get_column_count duckdb_ext_api.duckdb_data_chunk_get_column_count 752 | #define duckdb_data_chunk_get_vector duckdb_ext_api.duckdb_data_chunk_get_vector 753 | #define duckdb_data_chunk_get_size duckdb_ext_api.duckdb_data_chunk_get_size 754 | #define duckdb_data_chunk_set_size duckdb_ext_api.duckdb_data_chunk_set_size 755 | #define duckdb_vector_get_column_type duckdb_ext_api.duckdb_vector_get_column_type 756 | #define duckdb_vector_get_data duckdb_ext_api.duckdb_vector_get_data 757 | #define duckdb_vector_get_validity duckdb_ext_api.duckdb_vector_get_validity 758 | #define duckdb_vector_ensure_validity_writable duckdb_ext_api.duckdb_vector_ensure_validity_writable 759 | #define duckdb_vector_assign_string_element duckdb_ext_api.duckdb_vector_assign_string_element 760 | #define duckdb_vector_assign_string_element_len duckdb_ext_api.duckdb_vector_assign_string_element_len 761 | #define duckdb_list_vector_get_child duckdb_ext_api.duckdb_list_vector_get_child 762 | #define duckdb_list_vector_get_size duckdb_ext_api.duckdb_list_vector_get_size 763 | #define duckdb_list_vector_set_size duckdb_ext_api.duckdb_list_vector_set_size 764 | #define duckdb_list_vector_reserve duckdb_ext_api.duckdb_list_vector_reserve 765 | #define duckdb_struct_vector_get_child duckdb_ext_api.duckdb_struct_vector_get_child 766 | #define duckdb_array_vector_get_child duckdb_ext_api.duckdb_array_vector_get_child 767 | #define duckdb_validity_row_is_valid duckdb_ext_api.duckdb_validity_row_is_valid 768 | #define duckdb_validity_set_row_validity duckdb_ext_api.duckdb_validity_set_row_validity 769 | #define duckdb_validity_set_row_invalid duckdb_ext_api.duckdb_validity_set_row_invalid 770 | #define duckdb_validity_set_row_valid duckdb_ext_api.duckdb_validity_set_row_valid 771 | #define duckdb_create_scalar_function duckdb_ext_api.duckdb_create_scalar_function 772 | #define duckdb_destroy_scalar_function duckdb_ext_api.duckdb_destroy_scalar_function 773 | #define duckdb_scalar_function_set_name duckdb_ext_api.duckdb_scalar_function_set_name 774 | #define duckdb_scalar_function_set_varargs duckdb_ext_api.duckdb_scalar_function_set_varargs 775 | #define duckdb_scalar_function_set_special_handling duckdb_ext_api.duckdb_scalar_function_set_special_handling 776 | #define duckdb_scalar_function_set_volatile duckdb_ext_api.duckdb_scalar_function_set_volatile 777 | #define duckdb_scalar_function_add_parameter duckdb_ext_api.duckdb_scalar_function_add_parameter 778 | #define duckdb_scalar_function_set_return_type duckdb_ext_api.duckdb_scalar_function_set_return_type 779 | #define duckdb_scalar_function_set_extra_info duckdb_ext_api.duckdb_scalar_function_set_extra_info 780 | #define duckdb_scalar_function_set_function duckdb_ext_api.duckdb_scalar_function_set_function 781 | #define duckdb_register_scalar_function duckdb_ext_api.duckdb_register_scalar_function 782 | #define duckdb_scalar_function_get_extra_info duckdb_ext_api.duckdb_scalar_function_get_extra_info 783 | #define duckdb_scalar_function_set_error duckdb_ext_api.duckdb_scalar_function_set_error 784 | #define duckdb_create_scalar_function_set duckdb_ext_api.duckdb_create_scalar_function_set 785 | #define duckdb_destroy_scalar_function_set duckdb_ext_api.duckdb_destroy_scalar_function_set 786 | #define duckdb_add_scalar_function_to_set duckdb_ext_api.duckdb_add_scalar_function_to_set 787 | #define duckdb_register_scalar_function_set duckdb_ext_api.duckdb_register_scalar_function_set 788 | #define duckdb_create_aggregate_function duckdb_ext_api.duckdb_create_aggregate_function 789 | #define duckdb_destroy_aggregate_function duckdb_ext_api.duckdb_destroy_aggregate_function 790 | #define duckdb_aggregate_function_set_name duckdb_ext_api.duckdb_aggregate_function_set_name 791 | #define duckdb_aggregate_function_add_parameter duckdb_ext_api.duckdb_aggregate_function_add_parameter 792 | #define duckdb_aggregate_function_set_return_type duckdb_ext_api.duckdb_aggregate_function_set_return_type 793 | #define duckdb_aggregate_function_set_functions duckdb_ext_api.duckdb_aggregate_function_set_functions 794 | #define duckdb_aggregate_function_set_destructor duckdb_ext_api.duckdb_aggregate_function_set_destructor 795 | #define duckdb_register_aggregate_function duckdb_ext_api.duckdb_register_aggregate_function 796 | #define duckdb_aggregate_function_set_special_handling duckdb_ext_api.duckdb_aggregate_function_set_special_handling 797 | #define duckdb_aggregate_function_set_extra_info duckdb_ext_api.duckdb_aggregate_function_set_extra_info 798 | #define duckdb_aggregate_function_get_extra_info duckdb_ext_api.duckdb_aggregate_function_get_extra_info 799 | #define duckdb_aggregate_function_set_error duckdb_ext_api.duckdb_aggregate_function_set_error 800 | #define duckdb_create_aggregate_function_set duckdb_ext_api.duckdb_create_aggregate_function_set 801 | #define duckdb_destroy_aggregate_function_set duckdb_ext_api.duckdb_destroy_aggregate_function_set 802 | #define duckdb_add_aggregate_function_to_set duckdb_ext_api.duckdb_add_aggregate_function_to_set 803 | #define duckdb_register_aggregate_function_set duckdb_ext_api.duckdb_register_aggregate_function_set 804 | #define duckdb_create_table_function duckdb_ext_api.duckdb_create_table_function 805 | #define duckdb_destroy_table_function duckdb_ext_api.duckdb_destroy_table_function 806 | #define duckdb_table_function_set_name duckdb_ext_api.duckdb_table_function_set_name 807 | #define duckdb_table_function_add_parameter duckdb_ext_api.duckdb_table_function_add_parameter 808 | #define duckdb_table_function_add_named_parameter duckdb_ext_api.duckdb_table_function_add_named_parameter 809 | #define duckdb_table_function_set_extra_info duckdb_ext_api.duckdb_table_function_set_extra_info 810 | #define duckdb_table_function_set_bind duckdb_ext_api.duckdb_table_function_set_bind 811 | #define duckdb_table_function_set_init duckdb_ext_api.duckdb_table_function_set_init 812 | #define duckdb_table_function_set_local_init duckdb_ext_api.duckdb_table_function_set_local_init 813 | #define duckdb_table_function_set_function duckdb_ext_api.duckdb_table_function_set_function 814 | #define duckdb_table_function_supports_projection_pushdown \ 815 | duckdb_ext_api.duckdb_table_function_supports_projection_pushdown 816 | #define duckdb_register_table_function duckdb_ext_api.duckdb_register_table_function 817 | #define duckdb_bind_get_extra_info duckdb_ext_api.duckdb_bind_get_extra_info 818 | #define duckdb_bind_add_result_column duckdb_ext_api.duckdb_bind_add_result_column 819 | #define duckdb_bind_get_parameter_count duckdb_ext_api.duckdb_bind_get_parameter_count 820 | #define duckdb_bind_get_parameter duckdb_ext_api.duckdb_bind_get_parameter 821 | #define duckdb_bind_get_named_parameter duckdb_ext_api.duckdb_bind_get_named_parameter 822 | #define duckdb_bind_set_bind_data duckdb_ext_api.duckdb_bind_set_bind_data 823 | #define duckdb_bind_set_cardinality duckdb_ext_api.duckdb_bind_set_cardinality 824 | #define duckdb_bind_set_error duckdb_ext_api.duckdb_bind_set_error 825 | #define duckdb_init_get_extra_info duckdb_ext_api.duckdb_init_get_extra_info 826 | #define duckdb_init_get_bind_data duckdb_ext_api.duckdb_init_get_bind_data 827 | #define duckdb_init_set_init_data duckdb_ext_api.duckdb_init_set_init_data 828 | #define duckdb_init_get_column_count duckdb_ext_api.duckdb_init_get_column_count 829 | #define duckdb_init_get_column_index duckdb_ext_api.duckdb_init_get_column_index 830 | #define duckdb_init_set_max_threads duckdb_ext_api.duckdb_init_set_max_threads 831 | #define duckdb_init_set_error duckdb_ext_api.duckdb_init_set_error 832 | #define duckdb_function_get_extra_info duckdb_ext_api.duckdb_function_get_extra_info 833 | #define duckdb_function_get_bind_data duckdb_ext_api.duckdb_function_get_bind_data 834 | #define duckdb_function_get_init_data duckdb_ext_api.duckdb_function_get_init_data 835 | #define duckdb_function_get_local_init_data duckdb_ext_api.duckdb_function_get_local_init_data 836 | #define duckdb_function_set_error duckdb_ext_api.duckdb_function_set_error 837 | #define duckdb_add_replacement_scan duckdb_ext_api.duckdb_add_replacement_scan 838 | #define duckdb_replacement_scan_set_function_name duckdb_ext_api.duckdb_replacement_scan_set_function_name 839 | #define duckdb_replacement_scan_add_parameter duckdb_ext_api.duckdb_replacement_scan_add_parameter 840 | #define duckdb_replacement_scan_set_error duckdb_ext_api.duckdb_replacement_scan_set_error 841 | #define duckdb_get_profiling_info duckdb_ext_api.duckdb_get_profiling_info 842 | #define duckdb_profiling_info_get_value duckdb_ext_api.duckdb_profiling_info_get_value 843 | #define duckdb_profiling_info_get_metrics duckdb_ext_api.duckdb_profiling_info_get_metrics 844 | #define duckdb_profiling_info_get_child_count duckdb_ext_api.duckdb_profiling_info_get_child_count 845 | #define duckdb_profiling_info_get_child duckdb_ext_api.duckdb_profiling_info_get_child 846 | #define duckdb_appender_create duckdb_ext_api.duckdb_appender_create 847 | #define duckdb_appender_create_ext duckdb_ext_api.duckdb_appender_create_ext 848 | #define duckdb_appender_column_count duckdb_ext_api.duckdb_appender_column_count 849 | #define duckdb_appender_column_type duckdb_ext_api.duckdb_appender_column_type 850 | #define duckdb_appender_error duckdb_ext_api.duckdb_appender_error 851 | #define duckdb_appender_flush duckdb_ext_api.duckdb_appender_flush 852 | #define duckdb_appender_close duckdb_ext_api.duckdb_appender_close 853 | #define duckdb_appender_destroy duckdb_ext_api.duckdb_appender_destroy 854 | #define duckdb_appender_add_column duckdb_ext_api.duckdb_appender_add_column 855 | #define duckdb_appender_clear_columns duckdb_ext_api.duckdb_appender_clear_columns 856 | #define duckdb_appender_begin_row duckdb_ext_api.duckdb_appender_begin_row 857 | #define duckdb_appender_end_row duckdb_ext_api.duckdb_appender_end_row 858 | #define duckdb_append_default duckdb_ext_api.duckdb_append_default 859 | #define duckdb_append_bool duckdb_ext_api.duckdb_append_bool 860 | #define duckdb_append_int8 duckdb_ext_api.duckdb_append_int8 861 | #define duckdb_append_int16 duckdb_ext_api.duckdb_append_int16 862 | #define duckdb_append_int32 duckdb_ext_api.duckdb_append_int32 863 | #define duckdb_append_int64 duckdb_ext_api.duckdb_append_int64 864 | #define duckdb_append_hugeint duckdb_ext_api.duckdb_append_hugeint 865 | #define duckdb_append_uint8 duckdb_ext_api.duckdb_append_uint8 866 | #define duckdb_append_uint16 duckdb_ext_api.duckdb_append_uint16 867 | #define duckdb_append_uint32 duckdb_ext_api.duckdb_append_uint32 868 | #define duckdb_append_uint64 duckdb_ext_api.duckdb_append_uint64 869 | #define duckdb_append_uhugeint duckdb_ext_api.duckdb_append_uhugeint 870 | #define duckdb_append_float duckdb_ext_api.duckdb_append_float 871 | #define duckdb_append_double duckdb_ext_api.duckdb_append_double 872 | #define duckdb_append_date duckdb_ext_api.duckdb_append_date 873 | #define duckdb_append_time duckdb_ext_api.duckdb_append_time 874 | #define duckdb_append_timestamp duckdb_ext_api.duckdb_append_timestamp 875 | #define duckdb_append_interval duckdb_ext_api.duckdb_append_interval 876 | #define duckdb_append_varchar duckdb_ext_api.duckdb_append_varchar 877 | #define duckdb_append_varchar_length duckdb_ext_api.duckdb_append_varchar_length 878 | #define duckdb_append_blob duckdb_ext_api.duckdb_append_blob 879 | #define duckdb_append_null duckdb_ext_api.duckdb_append_null 880 | #define duckdb_append_value duckdb_ext_api.duckdb_append_value 881 | #define duckdb_append_data_chunk duckdb_ext_api.duckdb_append_data_chunk 882 | #define duckdb_table_description_create duckdb_ext_api.duckdb_table_description_create 883 | #define duckdb_table_description_create_ext duckdb_ext_api.duckdb_table_description_create_ext 884 | #define duckdb_table_description_destroy duckdb_ext_api.duckdb_table_description_destroy 885 | #define duckdb_table_description_error duckdb_ext_api.duckdb_table_description_error 886 | #define duckdb_column_has_default duckdb_ext_api.duckdb_column_has_default 887 | #define duckdb_table_description_get_column_name duckdb_ext_api.duckdb_table_description_get_column_name 888 | #define duckdb_execute_tasks duckdb_ext_api.duckdb_execute_tasks 889 | #define duckdb_create_task_state duckdb_ext_api.duckdb_create_task_state 890 | #define duckdb_execute_tasks_state duckdb_ext_api.duckdb_execute_tasks_state 891 | #define duckdb_execute_n_tasks_state duckdb_ext_api.duckdb_execute_n_tasks_state 892 | #define duckdb_finish_execution duckdb_ext_api.duckdb_finish_execution 893 | #define duckdb_task_state_is_finished duckdb_ext_api.duckdb_task_state_is_finished 894 | #define duckdb_destroy_task_state duckdb_ext_api.duckdb_destroy_task_state 895 | #define duckdb_execution_is_finished duckdb_ext_api.duckdb_execution_is_finished 896 | #define duckdb_fetch_chunk duckdb_ext_api.duckdb_fetch_chunk 897 | #define duckdb_create_cast_function duckdb_ext_api.duckdb_create_cast_function 898 | #define duckdb_cast_function_set_source_type duckdb_ext_api.duckdb_cast_function_set_source_type 899 | #define duckdb_cast_function_set_target_type duckdb_ext_api.duckdb_cast_function_set_target_type 900 | #define duckdb_cast_function_set_implicit_cast_cost duckdb_ext_api.duckdb_cast_function_set_implicit_cast_cost 901 | #define duckdb_cast_function_set_function duckdb_ext_api.duckdb_cast_function_set_function 902 | #define duckdb_cast_function_set_extra_info duckdb_ext_api.duckdb_cast_function_set_extra_info 903 | #define duckdb_cast_function_get_extra_info duckdb_ext_api.duckdb_cast_function_get_extra_info 904 | #define duckdb_cast_function_get_cast_mode duckdb_ext_api.duckdb_cast_function_get_cast_mode 905 | #define duckdb_cast_function_set_error duckdb_ext_api.duckdb_cast_function_set_error 906 | #define duckdb_cast_function_set_row_error duckdb_ext_api.duckdb_cast_function_set_row_error 907 | #define duckdb_register_cast_function duckdb_ext_api.duckdb_register_cast_function 908 | #define duckdb_destroy_cast_function duckdb_ext_api.duckdb_destroy_cast_function 909 | 910 | // Version unstable_deprecated 911 | #define duckdb_row_count duckdb_ext_api.duckdb_row_count 912 | #define duckdb_column_data duckdb_ext_api.duckdb_column_data 913 | #define duckdb_nullmask_data duckdb_ext_api.duckdb_nullmask_data 914 | #define duckdb_result_get_chunk duckdb_ext_api.duckdb_result_get_chunk 915 | #define duckdb_result_is_streaming duckdb_ext_api.duckdb_result_is_streaming 916 | #define duckdb_result_chunk_count duckdb_ext_api.duckdb_result_chunk_count 917 | #define duckdb_value_boolean duckdb_ext_api.duckdb_value_boolean 918 | #define duckdb_value_int8 duckdb_ext_api.duckdb_value_int8 919 | #define duckdb_value_int16 duckdb_ext_api.duckdb_value_int16 920 | #define duckdb_value_int32 duckdb_ext_api.duckdb_value_int32 921 | #define duckdb_value_int64 duckdb_ext_api.duckdb_value_int64 922 | #define duckdb_value_hugeint duckdb_ext_api.duckdb_value_hugeint 923 | #define duckdb_value_uhugeint duckdb_ext_api.duckdb_value_uhugeint 924 | #define duckdb_value_decimal duckdb_ext_api.duckdb_value_decimal 925 | #define duckdb_value_uint8 duckdb_ext_api.duckdb_value_uint8 926 | #define duckdb_value_uint16 duckdb_ext_api.duckdb_value_uint16 927 | #define duckdb_value_uint32 duckdb_ext_api.duckdb_value_uint32 928 | #define duckdb_value_uint64 duckdb_ext_api.duckdb_value_uint64 929 | #define duckdb_value_float duckdb_ext_api.duckdb_value_float 930 | #define duckdb_value_double duckdb_ext_api.duckdb_value_double 931 | #define duckdb_value_date duckdb_ext_api.duckdb_value_date 932 | #define duckdb_value_time duckdb_ext_api.duckdb_value_time 933 | #define duckdb_value_timestamp duckdb_ext_api.duckdb_value_timestamp 934 | #define duckdb_value_interval duckdb_ext_api.duckdb_value_interval 935 | #define duckdb_value_varchar duckdb_ext_api.duckdb_value_varchar 936 | #define duckdb_value_string duckdb_ext_api.duckdb_value_string 937 | #define duckdb_value_varchar_internal duckdb_ext_api.duckdb_value_varchar_internal 938 | #define duckdb_value_string_internal duckdb_ext_api.duckdb_value_string_internal 939 | #define duckdb_value_blob duckdb_ext_api.duckdb_value_blob 940 | #define duckdb_value_is_null duckdb_ext_api.duckdb_value_is_null 941 | #define duckdb_execute_prepared_streaming duckdb_ext_api.duckdb_execute_prepared_streaming 942 | #define duckdb_pending_prepared_streaming duckdb_ext_api.duckdb_pending_prepared_streaming 943 | #define duckdb_query_arrow duckdb_ext_api.duckdb_query_arrow 944 | #define duckdb_query_arrow_schema duckdb_ext_api.duckdb_query_arrow_schema 945 | #define duckdb_prepared_arrow_schema duckdb_ext_api.duckdb_prepared_arrow_schema 946 | #define duckdb_result_arrow_array duckdb_ext_api.duckdb_result_arrow_array 947 | #define duckdb_query_arrow_array duckdb_ext_api.duckdb_query_arrow_array 948 | #define duckdb_arrow_column_count duckdb_ext_api.duckdb_arrow_column_count 949 | #define duckdb_arrow_row_count duckdb_ext_api.duckdb_arrow_row_count 950 | #define duckdb_arrow_rows_changed duckdb_ext_api.duckdb_arrow_rows_changed 951 | #define duckdb_query_arrow_error duckdb_ext_api.duckdb_query_arrow_error 952 | #define duckdb_destroy_arrow duckdb_ext_api.duckdb_destroy_arrow 953 | #define duckdb_destroy_arrow_stream duckdb_ext_api.duckdb_destroy_arrow_stream 954 | #define duckdb_execute_prepared_arrow duckdb_ext_api.duckdb_execute_prepared_arrow 955 | #define duckdb_arrow_scan duckdb_ext_api.duckdb_arrow_scan 956 | #define duckdb_arrow_array_scan duckdb_ext_api.duckdb_arrow_array_scan 957 | #define duckdb_stream_fetch_chunk duckdb_ext_api.duckdb_stream_fetch_chunk 958 | 959 | // Version unstable_instance_cache 960 | #define duckdb_create_instance_cache duckdb_ext_api.duckdb_create_instance_cache 961 | #define duckdb_get_or_create_from_cache duckdb_ext_api.duckdb_get_or_create_from_cache 962 | #define duckdb_destroy_instance_cache duckdb_ext_api.duckdb_destroy_instance_cache 963 | 964 | // Version unstable_new_append_functions 965 | #define duckdb_append_default_to_chunk duckdb_ext_api.duckdb_append_default_to_chunk 966 | 967 | //===--------------------------------------------------------------------===// 968 | // Struct Global Macros 969 | //===--------------------------------------------------------------------===// 970 | // This goes in the c/c++ file containing the entrypoint (handle 971 | #define DUCKDB_EXTENSION_GLOBAL duckdb_ext_api_v1 duckdb_ext_api = {0}; 972 | // Initializes the C Extension API: First thing to call in the extension entrypoint 973 | #define DUCKDB_EXTENSION_API_INIT(info, access, minimum_api_version) \ 974 | duckdb_ext_api_v1 *res = (duckdb_ext_api_v1 *)access->get_api(info, minimum_api_version); \ 975 | if (!res) { \ 976 | return false; \ 977 | }; \ 978 | duckdb_ext_api = *res; 979 | 980 | // Place in global scope of any C/C++ file that needs to access the extension API 981 | #define DUCKDB_EXTENSION_EXTERN extern duckdb_ext_api_v1 duckdb_ext_api; 982 | 983 | #ifdef _WIN32 984 | #define DUCKDB_CAPI_ENTRY_VISIBILITY __declspec(dllexport) 985 | #else 986 | #define DUCKDB_CAPI_ENTRY_VISIBILITY __attribute__((visibility("default"))) 987 | #endif 988 | 989 | //===--------------------------------------------------------------------===// 990 | // Entrypoint Macros 991 | //===--------------------------------------------------------------------===// 992 | 993 | // Note: the DUCKDB_EXTENSION_ENTRYPOINT macro requires DUCKDB_EXTENSION_NAME to be set. 994 | 995 | #ifdef DUCKDB_EXTENSION_NAME 996 | 997 | // Main entrypoint: opens (and closes) a connection automatically for the extension to register its functionality 998 | // through 999 | #define DUCKDB_EXTENSION_ENTRYPOINT \ 1000 | DUCKDB_EXTENSION_GLOBAL static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)( \ 1001 | duckdb_connection connection, duckdb_extension_info info, struct duckdb_extension_access * access); \ 1002 | DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_CAPI_ENTRY_VISIBILITY DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \ 1003 | DUCKDB_EXTENSION_NAME, _init_c_api)(duckdb_extension_info info, struct duckdb_extension_access * access) { \ 1004 | DUCKDB_EXTENSION_API_INIT(info, access, DUCKDB_EXTENSION_API_VERSION_STRING); \ 1005 | duckdb_database *db = access->get_database(info); \ 1006 | duckdb_connection conn; \ 1007 | if (duckdb_connect(*db, &conn) == DuckDBError) { \ 1008 | access->set_error(info, "Failed to open connection to database"); \ 1009 | return false; \ 1010 | } \ 1011 | bool init_result = DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)(conn, info, access); \ 1012 | duckdb_disconnect(&conn); \ 1013 | return init_result; \ 1014 | } \ 1015 | DUCKDB_EXTENSION_EXTERN_C_GUARD_CLOSE static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal) 1016 | 1017 | // Custom entrypoint: just forwards the info and access 1018 | #define DUCKDB_EXTENSION_ENTRYPOINT_CUSTOM \ 1019 | DUCKDB_EXTENSION_GLOBAL static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)( \ 1020 | duckdb_extension_info info, struct duckdb_extension_access * access); \ 1021 | DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_CAPI_ENTRY_VISIBILITY DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \ 1022 | DUCKDB_EXTENSION_NAME, _init_c_api)(duckdb_extension_info info, struct duckdb_extension_access * access) { \ 1023 | DUCKDB_EXTENSION_API_INIT(info, access, DUCKDB_EXTENSION_API_VERSION_STRING); \ 1024 | return DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)(info, access); \ 1025 | } \ 1026 | DUCKDB_EXTENSION_EXTERN_C_GUARD_CLOSE static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal) 1027 | #endif 1028 | -------------------------------------------------------------------------------- /src/add_numbers.c: -------------------------------------------------------------------------------- 1 | #include "duckdb_extension.h" 2 | 3 | #include "add_numbers.h" 4 | 5 | DUCKDB_EXTENSION_EXTERN 6 | 7 | // Scalar function that adds two numbers together 8 | static void AddNumbersTogether(duckdb_function_info info, duckdb_data_chunk input, duckdb_vector output) { 9 | // get the total number of rows in this chunk 10 | idx_t input_size = duckdb_data_chunk_get_size(input); 11 | // extract the two input vectors 12 | duckdb_vector a = duckdb_data_chunk_get_vector(input, 0); 13 | duckdb_vector b = duckdb_data_chunk_get_vector(input, 1); 14 | // get the data pointers for the input vectors (both int64 as specified by the parameter types) 15 | int64_t* a_data = (int64_t *)duckdb_vector_get_data(a); 16 | int64_t* b_data = (int64_t *)duckdb_vector_get_data(b); 17 | int64_t* result_data = (int64_t *)duckdb_vector_get_data(output); 18 | // get the validity vectors 19 | uint64_t* a_validity = duckdb_vector_get_validity(a); 20 | uint64_t* b_validity = duckdb_vector_get_validity(b); 21 | if (a_validity || b_validity) { 22 | // if either a_validity or b_validity is defined there might be NULL values 23 | duckdb_vector_ensure_validity_writable(output); 24 | uint64_t* result_validity = duckdb_vector_get_validity(output); 25 | for (idx_t row = 0; row < input_size; row++) { 26 | if (duckdb_validity_row_is_valid(a_validity, row) && duckdb_validity_row_is_valid(b_validity, row)) { 27 | // not null - do the addition 28 | result_data[row] = a_data[row] + b_data[row]; 29 | } else { 30 | // either a or b is NULL - set the result row to NULL 31 | duckdb_validity_set_row_invalid(result_validity, row); 32 | } 33 | } 34 | } else { 35 | // no NULL values - iterate and do the operation directly 36 | for (idx_t row = 0; row < input_size; row++) { 37 | result_data[row] = a_data[row] * b_data[row]; 38 | } 39 | } 40 | } 41 | 42 | // Register the AddNumbersFunction 43 | void RegisterAddNumbersFunction(duckdb_connection connection) { 44 | // create a scalar function 45 | duckdb_scalar_function function = duckdb_create_scalar_function(); 46 | duckdb_scalar_function_set_name(function, "multiply_numbers_together"); 47 | 48 | // add a two bigint parameters 49 | duckdb_logical_type type = duckdb_create_logical_type(DUCKDB_TYPE_BIGINT); 50 | duckdb_scalar_function_add_parameter(function, type); 51 | duckdb_scalar_function_add_parameter(function, type); 52 | 53 | // set the return type to bigint 54 | duckdb_scalar_function_set_return_type(function, type); 55 | 56 | duckdb_destroy_logical_type(&type); 57 | 58 | // set up the function 59 | duckdb_scalar_function_set_function(function, AddNumbersTogether); 60 | 61 | // register and cleanup 62 | duckdb_register_scalar_function(connection, function); 63 | duckdb_destroy_scalar_function(&function); 64 | } 65 | -------------------------------------------------------------------------------- /src/capi_quack.c: -------------------------------------------------------------------------------- 1 | #include "duckdb_extension.h" 2 | 3 | #include "add_numbers.h" 4 | 5 | DUCKDB_EXTENSION_ENTRYPOINT(duckdb_connection connection, duckdb_extension_info info, struct duckdb_extension_access *access) { 6 | // Register a demo function 7 | RegisterAddNumbersFunction(connection); 8 | 9 | // Return true to indicate succesful initialization 10 | return true; 11 | } 12 | -------------------------------------------------------------------------------- /src/include/add_numbers.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "duckdb_extension.h" 4 | 5 | void RegisterAddNumbersFunction(duckdb_connection connection); 6 | -------------------------------------------------------------------------------- /test/sql/capi_quack.test: -------------------------------------------------------------------------------- 1 | # name: test/sql/capi_quack.test 2 | # description: test capi_quack extension 3 | # group: [capi_quack] 4 | 5 | # Before we load the extension, this will fail 6 | statement error 7 | SELECT multiply_numbers_together(1,2); 8 | ---- 9 | Catalog Error: Scalar Function with name multiply_numbers_together does not exist! 10 | 11 | # Require statement will ensure the extension is loaded from now on 12 | require capi_quack 13 | 14 | # Confirm the extension works 15 | query I 16 | SELECT multiply_numbers_together(5,10) 17 | ---- 18 | 50 --------------------------------------------------------------------------------