diff --git a/CMakeLists.txt b/CMakeLists.txt index dafdd75..d9d4b3e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,19 +3,23 @@ cmake_minimum_required(VERSION 2.8) ### # Configuration ### -if(NOT DEFINED MINIMUM_DUCKDB_VERSION_MAJOR OR - NOT DEFINED MINIMUM_DUCKDB_VERSION_MINOR OR - NOT DEFINED MINIMUM_DUCKDB_VERSION_PATCH) - message(FATAL_ERROR "DuckDB minimum version is required") +if(NOT DEFINED TARGET_DUCKDB_VERSION_MAJOR OR + NOT DEFINED TARGET_DUCKDB_VERSION_MINOR OR + NOT DEFINED TARGET_DUCKDB_VERSION_PATCH) + message(FATAL_ERROR "DuckDB target version is required") endif() if(NOT DEFINED EXTENSION_NAME) message(FATAL_ERROR "DuckDB extension name is required") endif() -add_definitions(-DDUCKDB_EXTENSION_API_VERSION_MAJOR=${MINIMUM_DUCKDB_VERSION_MAJOR}) -add_definitions(-DDUCKDB_EXTENSION_API_VERSION_MINOR=${MINIMUM_DUCKDB_VERSION_MINOR}) -add_definitions(-DDUCKDB_EXTENSION_API_VERSION_PATCH=${MINIMUM_DUCKDB_VERSION_PATCH}) +add_definitions(-DDUCKDB_EXTENSION_API_VERSION_MAJOR=${TARGET_DUCKDB_VERSION_MAJOR}) +add_definitions(-DDUCKDB_EXTENSION_API_VERSION_MINOR=${TARGET_DUCKDB_VERSION_MINOR}) +add_definitions(-DDUCKDB_EXTENSION_API_VERSION_PATCH=${TARGET_DUCKDB_VERSION_PATCH}) add_definitions(-DDUCKDB_EXTENSION_NAME=${EXTENSION_NAME}) +if (DEFINED DUCKDB_EXTENSION_API_VERSION_UNSTABLE) + add_definitions(-DDUCKDB_EXTENSION_API_VERSION_UNSTABLE=${DUCKDB_EXTENSION_API_VERSION_UNSTABLE}) +endif() + ### # Build ### diff --git a/Makefile b/Makefile index d6337c1..c6ae74a 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,13 @@ PROJ_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST)))) # Main extension configuration EXTENSION_NAME=capi_quack -MINIMUM_DUCKDB_VERSION_MAJOR=0 -MINIMUM_DUCKDB_VERSION_MINOR=0 -MINIMUM_DUCKDB_VERSION_PATCH=1 -MINIMUM_DUCKDB_VERSION=v$(MINIMUM_DUCKDB_VERSION_MAJOR).$(MINIMUM_DUCKDB_VERSION_MINOR).$(MINIMUM_DUCKDB_VERSION_PATCH) +TARGET_DUCKDB_VERSION_MAJOR=1 +TARGET_DUCKDB_VERSION_MINOR=2 +TARGET_DUCKDB_VERSION_PATCH=0 +TARGET_DUCKDB_VERSION=v$(TARGET_DUCKDB_VERSION_MAJOR).$(TARGET_DUCKDB_VERSION_MINOR).$(TARGET_DUCKDB_VERSION_PATCH) + +# Set to 1 to target the unstable C API. +USE_UNSTABLE_C_API=0 all: configure release diff --git a/duckdb_capi/README.md b/duckdb_capi/README.md index e4915c7..cddc8a1 100644 --- a/duckdb_capi/README.md +++ b/duckdb_capi/README.md @@ -1,13 +1,13 @@ # DuckDB C API Headers -This directory contains the C API headers of DuckDB. These headers should generally match the `MINIMUM_DUCKDB_VERSION` +This directory contains the C API headers of DuckDB. These headers should generally match the `TARGET_DUCKDB_VERSION` that is specified in the `Makefile`. Note that these headers can be updated automatically -to match the `MINIMUM_DUCKDB_VERSION` makefile variable by running (assuming the default makefile setup): +to match the `TARGET_DUCKDB_VERSION` makefile variable by running (assuming the default makefile setup): ```shell make update_duckdb_headers ``` Of course manually updating the headers is also fine, just make sure that the headers are always from the same -DuckDB version and that they are not from a later release of DuckDB than is specified in the `MINIMUM_DUCKDB_VERSION` -build variable. Using headers from an older version than `MINIMUM_DUCKDB_VERSION` is allowed, but you probably don't want +DuckDB version and that they are not from a later release of DuckDB than is specified in the `TARGET_DUCKDB_VERSION` +build variable. Using headers from an older version than `TARGET_DUCKDB_VERSION` is allowed, but you probably don't want that. \ No newline at end of file diff --git a/duckdb_capi/duckdb.h b/duckdb_capi/duckdb.h index b915ff5..36b9dc7 100644 --- a/duckdb_capi/duckdb.h +++ b/duckdb_capi/duckdb.h @@ -282,15 +282,32 @@ typedef struct { int32_t offset; } duckdb_time_tz_struct; -//! Timestamps are stored as microseconds since 1970-01-01 -//! Use the duckdb_from_timestamp/duckdb_to_timestamp function to extract individual information +//! TIMESTAMP values are stored as microseconds since 1970-01-01. +//! Use the duckdb_from_timestamp and duckdb_to_timestamp functions to extract individual information. typedef struct { int64_t micros; } duckdb_timestamp; + +//! TIMESTAMP_S values are stored as seconds since 1970-01-01. +typedef struct { + int64_t seconds; +} duckdb_timestamp_s; + +//! TIMESTAMP_MS values are stored as milliseconds since 1970-01-01. +typedef struct { + int64_t millis; +} duckdb_timestamp_ms; + +//! TIMESTAMP_NS values are stored as nanoseconds since 1970-01-01. +typedef struct { + int64_t nanos; +} duckdb_timestamp_ns; + typedef struct { duckdb_date_struct date; duckdb_time_struct time; } duckdb_timestamp_struct; + typedef struct { int32_t months; int32_t days; @@ -1323,11 +1340,35 @@ DUCKDB_API duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts); /*! Test a `duckdb_timestamp` to see if it is a finite value. -* @param ts The timestamp object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column. +* @param ts The duckdb_timestamp object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column. * @return True if the timestamp is finite, false if it is ±infinity. */ DUCKDB_API bool duckdb_is_finite_timestamp(duckdb_timestamp ts); +/*! +Test a `duckdb_timestamp_s` to see if it is a finite value. + +* @param ts The duckdb_timestamp_s object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_S` column. +* @return True if the timestamp is finite, false if it is ±infinity. +*/ +DUCKDB_API bool duckdb_is_finite_timestamp_s(duckdb_timestamp_s ts); + +/*! +Test a `duckdb_timestamp_ms` to see if it is a finite value. + +* @param ts The duckdb_timestamp_ms object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_MS` column. +* @return True if the timestamp is finite, false if it is ±infinity. +*/ +DUCKDB_API bool duckdb_is_finite_timestamp_ms(duckdb_timestamp_ms ts); + +/*! +Test a `duckdb_timestamp_ns` to see if it is a finite value. + +* @param ts The duckdb_timestamp_ns object, as obtained from a `DUCKDB_TYPE_TIMESTAMP_NS` column. +* @return True if the timestamp is finite, false if it is ±infinity. +*/ +DUCKDB_API bool duckdb_is_finite_timestamp_ns(duckdb_timestamp_ns ts); + //===--------------------------------------------------------------------===// // Hugeint Helpers //===--------------------------------------------------------------------===// @@ -1472,7 +1513,7 @@ Returns `DUCKDB_TYPE_INVALID` if the parameter index is out of range or the stat DUCKDB_API duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx); /*! -Returns the parameter logical type for the parameter at the given index. +Returns the logical type for the parameter at the given index. Returns `nullptr` if the parameter index is out of range or the statement was not successfully prepared. @@ -1480,7 +1521,7 @@ The return type of this call should be destroyed with `duckdb_destroy_logical_ty * @param prepared_statement The prepared statement. * @param param_idx The parameter index. -* @return The parameter logical type +* @return The logical type of the parameter */ DUCKDB_API duckdb_logical_type duckdb_param_logical_type(duckdb_prepared_statement prepared_statement, idx_t param_idx); @@ -1992,13 +2033,45 @@ Not to be confused with `duckdb_create_time_tz`, which creates a duckdb_time_tz_ DUCKDB_API duckdb_value duckdb_create_time_tz_value(duckdb_time_tz value); /*! -Creates a value from a timestamp +Creates a TIMESTAMP value from a duckdb_timestamp -* @param input The timestamp value +* @param input The duckdb_timestamp value * @return The value. This must be destroyed with `duckdb_destroy_value`. */ DUCKDB_API duckdb_value duckdb_create_timestamp(duckdb_timestamp input); +/*! +Creates a TIMESTAMP_TZ value from a duckdb_timestamp + +* @param input The duckdb_timestamp value +* @return The value. This must be destroyed with `duckdb_destroy_value`. +*/ +DUCKDB_API duckdb_value duckdb_create_timestamp_tz(duckdb_timestamp input); + +/*! +Creates a TIMESTAMP_S value from a duckdb_timestamp_s + +* @param input The duckdb_timestamp_s value +* @return The value. This must be destroyed with `duckdb_destroy_value`. +*/ +DUCKDB_API duckdb_value duckdb_create_timestamp_s(duckdb_timestamp_s input); + +/*! +Creates a TIMESTAMP_MS value from a duckdb_timestamp_ms + +* @param input The duckdb_timestamp_ms value +* @return The value. This must be destroyed with `duckdb_destroy_value`. +*/ +DUCKDB_API duckdb_value duckdb_create_timestamp_ms(duckdb_timestamp_ms input); + +/*! +Creates a TIMESTAMP_NS value from a duckdb_timestamp_ns + +* @param input The duckdb_timestamp_ns value +* @return The value. This must be destroyed with `duckdb_destroy_value`. +*/ +DUCKDB_API duckdb_value duckdb_create_timestamp_ns(duckdb_timestamp_ns input); + /*! Creates a value from an interval @@ -2145,13 +2218,45 @@ Returns the time_tz value of the given value. DUCKDB_API duckdb_time_tz duckdb_get_time_tz(duckdb_value val); /*! -Returns the timestamp value of the given value. +Returns the TIMESTAMP value of the given value. -* @param val A duckdb_value containing a timestamp +* @param val A duckdb_value containing a TIMESTAMP * @return A duckdb_timestamp, or MinValue if the value cannot be converted */ DUCKDB_API duckdb_timestamp duckdb_get_timestamp(duckdb_value val); +/*! +Returns the TIMESTAMP_TZ value of the given value. + +* @param val A duckdb_value containing a TIMESTAMP_TZ +* @return A duckdb_timestamp, or MinValue if the value cannot be converted +*/ +DUCKDB_API duckdb_timestamp duckdb_get_timestamp_tz(duckdb_value val); + +/*! +Returns the duckdb_timestamp_s value of the given value. + +* @param val A duckdb_value containing a TIMESTAMP_S +* @return A duckdb_timestamp_s, or MinValue if the value cannot be converted +*/ +DUCKDB_API duckdb_timestamp_s duckdb_get_timestamp_s(duckdb_value val); + +/*! +Returns the duckdb_timestamp_ms value of the given value. + +* @param val A duckdb_value containing a TIMESTAMP_MS +* @return A duckdb_timestamp_ms, or MinValue if the value cannot be converted +*/ +DUCKDB_API duckdb_timestamp_ms duckdb_get_timestamp_ms(duckdb_value val); + +/*! +Returns the duckdb_timestamp_ns value of the given value. + +* @param val A duckdb_value containing a TIMESTAMP_NS +* @return A duckdb_timestamp_ns, or MinValue if the value cannot be converted +*/ +DUCKDB_API duckdb_timestamp_ns duckdb_get_timestamp_ns(duckdb_value val); + /*! Returns the interval value of the given value. @@ -2244,17 +2349,17 @@ Returns the MAP value at index as a duckdb_value. DUCKDB_API duckdb_value duckdb_get_map_value(duckdb_value value, idx_t index); /*! -Returns whether the specified value is null value or not. +Returns whether the value's type is SQLNULL or not. * @param value The value to check. -* @return True if the value is null, otherwise false. +* @return True, if the value's type is SQLNULL, otherwise false. */ DUCKDB_API bool duckdb_is_null_value(duckdb_value value); /*! -Creates a value representing a NULL value. +Creates a value of type SQLNULL. -* @return The duckdb_value that represents NULL. This must be destroyed with `duckdb_destroy_value`. +* @return The duckdb_value representing SQLNULL. This must be destroyed with `duckdb_destroy_value`. */ DUCKDB_API duckdb_value duckdb_create_null_value(); @@ -2275,6 +2380,32 @@ Returns the LIST child at index as a duckdb_value. */ DUCKDB_API duckdb_value duckdb_get_list_child(duckdb_value value, idx_t index); +/*! +Creates an enum value from a type and a value. Must be destroyed with `duckdb_destroy_value`. + +* @param type The type of the enum +* @param value The value for the enum +* @return The enum value, or nullptr. +*/ +DUCKDB_API duckdb_value duckdb_create_enum_value(duckdb_logical_type type, uint64_t value); + +/*! +Returns the enum value of the given value. + +* @param value A duckdb_value containing an enum +* @return A uint64_t, or MinValue if the value cannot be converted +*/ +DUCKDB_API uint64_t duckdb_get_enum_value(duckdb_value value); + +/*! +Returns the STRUCT child at index as a duckdb_value. + +* @param value The STRUCT value. +* @param index The index of the child. +* @return The child as a duckdb_value. +*/ +DUCKDB_API duckdb_value duckdb_get_struct_child(duckdb_value value, idx_t index); + //===--------------------------------------------------------------------===// // Logical Type Interface //===--------------------------------------------------------------------===// @@ -2681,7 +2812,7 @@ DUCKDB_API uint64_t *duckdb_vector_get_validity(duckdb_vector vector); Ensures the validity mask is writable by allocating it. After this function is called, `duckdb_vector_get_validity` will ALWAYS return non-NULL. -This allows null values to be written to the vector, regardless of whether a validity mask was present before. +This allows NULL values to be written to the vector, regardless of whether a validity mask was present before. * @param vector The vector to alter */ @@ -3528,18 +3659,20 @@ DUCKDB_API duckdb_profiling_info duckdb_profiling_info_get_child(duckdb_profilin // Appender //===--------------------------------------------------------------------===// -// Appenders are the most efficient way of loading data into DuckDB from within the C interface, and are recommended for -// fast data loading. The appender is much faster than using prepared statements or individual `INSERT INTO` statements. +// Appenders are the most efficient way of loading data into DuckDB from within the C API. +// They are recommended for fast data loading as they perform better than prepared statements or individual `INSERT +// INTO` statements. + +// Appends are possible in row-wise format, and by appending entire data chunks. -// Appends are made in row-wise format. For every column, a `duckdb_append_[type]` call should be made, after which -// the row should be finished by calling `duckdb_appender_end_row`. After all rows have been appended, -// `duckdb_appender_destroy` should be used to finalize the appender and clean up the resulting memory. +// Row-wise: for every column, a `duckdb_append_[type]` call should be made. After finishing all appends to a row, call +// `duckdb_appender_end_row`. -// Instead of appending rows with `duckdb_appender_end_row`, it is also possible to fill and append -// chunks-at-a-time. +// Chunk-wise: Consecutively call `duckdb_append_data_chunk` until all chunks have been appended. + +// After all data has been appended, call `duckdb_appender_close` to finalize the appender followed by +// `duckdb_appender_destroy` to clean up the memory. -// Note that `duckdb_appender_destroy` should always be called on the resulting appender, even if the function returns -// `DuckDBError`. /*! Creates an appender object. @@ -3571,21 +3704,23 @@ DUCKDB_API duckdb_state duckdb_appender_create_ext(duckdb_connection connection, duckdb_appender *out_appender); /*! -Returns the number of columns in the table that belongs to the appender. +Returns the number of columns that belong to the appender. +If there is no active column list, then this equals the table's physical columns. * @param appender The appender to get the column count from. -* @return The number of columns in the table. +* @return The number of columns in the data chunks. */ DUCKDB_API idx_t duckdb_appender_column_count(duckdb_appender appender); /*! -Returns the type of the column at the specified index. +Returns the type of the column at the specified index. This is either a type in the active column list, or the same type +as a column in the receiving table. -Note: The resulting type should be destroyed with `duckdb_destroy_logical_type`. +Note: The resulting type must be destroyed with `duckdb_destroy_logical_type`. * @param appender The appender to get the column type from. * @param col_idx The index of the column to get the type of. -* @return The duckdb_logical_type of the column. +* @return The `duckdb_logical_type` of the column. */ DUCKDB_API duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t col_idx); @@ -3634,6 +3769,26 @@ before destroying the appender, if you need insights into the specific error. */ DUCKDB_API duckdb_state duckdb_appender_destroy(duckdb_appender *appender); +/*! +Appends a column to the active column list of the appender. Immediately flushes all previous data. + +The active column list specifies all columns that are expected when flushing the data. Any non-active columns are filled +with their default values, or NULL. + +* @param appender The appender to add the column to. +* @return `DuckDBSuccess` on success or `DuckDBError` on failure. +*/ +DUCKDB_API duckdb_state duckdb_appender_add_column(duckdb_appender appender, const char *name); + +/*! +Removes all columns from the active column list of the appender, resetting the appender to treat all columns as active. +Immediately flushes all previous data. + +* @param appender The appender to clear the columns from. +* @return `DuckDBSuccess` on success or `DuckDBError` on failure. +*/ +DUCKDB_API duckdb_state duckdb_appender_clear_columns(duckdb_appender appender); + /*! A nop function, provided for backwards compatibility reasons. Does nothing. Only `duckdb_appender_end_row` is required. */ @@ -3758,15 +3913,17 @@ Append a NULL value to the appender (of any type). DUCKDB_API duckdb_state duckdb_append_null(duckdb_appender appender); /*! -Appends a pre-filled data chunk to the specified appender. +Append a duckdb_value to the appender. +*/ +DUCKDB_API duckdb_state duckdb_append_value(duckdb_appender appender, duckdb_value value); -The types of the data chunk must exactly match the types of the table, no casting is performed. -If the types do not match or the appender is in an invalid state, DuckDBError is returned. -If the append is successful, DuckDBSuccess is returned. +/*! +Appends a pre-filled data chunk to the specified appender. + Attempts casting, if the data chunk types do not match the active appender types. * @param appender The appender to append to. * @param chunk The data chunk to append. -* @return The return state. +* @return `DuckDBSuccess` on success or `DuckDBError` on failure. */ DUCKDB_API duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk); diff --git a/duckdb_capi/duckdb_extension.h b/duckdb_capi/duckdb_extension.h index e85b148..af2c9df 100644 --- a/duckdb_capi/duckdb_extension.h +++ b/duckdb_capi/duckdb_extension.h @@ -41,34 +41,36 @@ // Versioning //===--------------------------------------------------------------------===// //! Set version to latest if no explicit version is defined + #if !defined(DUCKDB_EXTENSION_API_VERSION_MAJOR) && !defined(DUCKDB_EXTENSION_API_VERSION_MINOR) && \ !defined(DUCKDB_EXTENSION_API_VERSION_PATCH) -#define DUCKDB_EXTENSION_API_VERSION_MAJOR 0 -#define DUCKDB_EXTENSION_API_VERSION_MINOR 0 -#define DUCKDB_EXTENSION_API_VERSION_PATCH 1 +#define DUCKDB_EXTENSION_API_VERSION_MAJOR 1 +#define DUCKDB_EXTENSION_API_VERSION_MINOR 2 +#define DUCKDB_EXTENSION_API_VERSION_PATCH 0 #elif !(defined(DUCKDB_EXTENSION_API_VERSION_MAJOR) && defined(DUCKDB_EXTENSION_API_VERSION_MINOR) && \ defined(DUCKDB_EXTENSION_API_VERSION_PATCH)) #error "either all or none of the DUCKDB_EXTENSION_API_VERSION_ defines should be defined" #endif //! Set the DUCKDB_EXTENSION_API_VERSION_STRING which is passed to DuckDB on extension load -#if DUCKDB_EXTENSION_API_VERSION_DEV -#define DUCKDB_EXTENSION_API_VERSION_STRING "dev" +#ifdef DUCKDB_EXTENSION_API_UNSTABLE_VERSION +#define DUCKDB_EXTENSION_API_VERSION_STRING DUCKDB_EXTENSION_API_UNSTABLE_VERSION #else #define DUCKDB_EXTENSION_API_VERSION_STRING \ DUCKDB_EXTENSION_SEMVER_STRING(DUCKDB_EXTENSION_API_VERSION_MAJOR, DUCKDB_EXTENSION_API_VERSION_MINOR, \ DUCKDB_EXTENSION_API_VERSION_PATCH) #endif -#if DUCKDB_EXTENSION_API_VERSION_MAJOR != 0 -#error "This version of the extension API header only supports API VERSION v0.x.x" +#if DUCKDB_EXTENSION_API_VERSION_MAJOR != 1 +#error "This version of the extension API header only supports API VERSION v1.x.x" #endif //===--------------------------------------------------------------------===// // Function pointer struct //===--------------------------------------------------------------------===// typedef struct { -#if DUCKDB_EXTENSION_API_VERSION_MINOR >= 0 && DUCKDB_EXTENSION_API_VERSION_PATCH >= 1 // v0.0.1 +#if DUCKDB_EXTENSION_API_VERSION_MINOR > 2 || \ + (DUCKDB_EXTENSION_API_VERSION_MINOR == 2 && DUCKDB_EXTENSION_API_VERSION_PATCH >= 0) // v1.2.0 duckdb_state (*duckdb_open)(const char *path, duckdb_database *out_database); duckdb_state (*duckdb_open_ext)(const char *path, duckdb_database *out_database, duckdb_config config, char **out_error); @@ -92,10 +94,14 @@ typedef struct { idx_t (*duckdb_column_count)(duckdb_result *result); idx_t (*duckdb_rows_changed)(duckdb_result *result); const char *(*duckdb_result_error)(duckdb_result *result); + duckdb_error_type (*duckdb_result_error_type)(duckdb_result *result); + duckdb_result_type (*duckdb_result_return_type)(duckdb_result result); void *(*duckdb_malloc)(size_t size); void (*duckdb_free)(void *ptr); idx_t (*duckdb_vector_size)(); bool (*duckdb_string_is_inlined)(duckdb_string_t string); + uint32_t (*duckdb_string_t_length)(duckdb_string_t string); + const char *(*duckdb_string_t_data)(duckdb_string_t *string); duckdb_date_struct (*duckdb_from_date)(duckdb_date date); duckdb_date (*duckdb_to_date)(duckdb_date_struct date); bool (*duckdb_is_finite_date)(duckdb_date date); @@ -119,6 +125,7 @@ typedef struct { idx_t (*duckdb_nparams)(duckdb_prepared_statement prepared_statement); const char *(*duckdb_parameter_name)(duckdb_prepared_statement prepared_statement, idx_t index); duckdb_type (*duckdb_param_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx); + duckdb_logical_type (*duckdb_param_logical_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx); duckdb_state (*duckdb_clear_bindings)(duckdb_prepared_statement prepared_statement); duckdb_statement_type (*duckdb_prepared_statement_type)(duckdb_prepared_statement statement); duckdb_state (*duckdb_bind_value)(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val); @@ -174,14 +181,62 @@ typedef struct { void (*duckdb_destroy_value)(duckdb_value *value); duckdb_value (*duckdb_create_varchar)(const char *text); duckdb_value (*duckdb_create_varchar_length)(const char *text, idx_t length); + duckdb_value (*duckdb_create_bool)(bool input); + duckdb_value (*duckdb_create_int8)(int8_t input); + duckdb_value (*duckdb_create_uint8)(uint8_t input); + duckdb_value (*duckdb_create_int16)(int16_t input); + duckdb_value (*duckdb_create_uint16)(uint16_t input); + duckdb_value (*duckdb_create_int32)(int32_t input); + duckdb_value (*duckdb_create_uint32)(uint32_t input); + duckdb_value (*duckdb_create_uint64)(uint64_t input); duckdb_value (*duckdb_create_int64)(int64_t val); + duckdb_value (*duckdb_create_hugeint)(duckdb_hugeint input); + duckdb_value (*duckdb_create_uhugeint)(duckdb_uhugeint input); + duckdb_value (*duckdb_create_float)(float input); + duckdb_value (*duckdb_create_double)(double input); + duckdb_value (*duckdb_create_date)(duckdb_date input); + duckdb_value (*duckdb_create_time)(duckdb_time input); + duckdb_value (*duckdb_create_time_tz_value)(duckdb_time_tz value); + duckdb_value (*duckdb_create_timestamp)(duckdb_timestamp input); + duckdb_value (*duckdb_create_interval)(duckdb_interval input); + duckdb_value (*duckdb_create_blob)(const uint8_t *data, idx_t length); + bool (*duckdb_get_bool)(duckdb_value val); + int8_t (*duckdb_get_int8)(duckdb_value val); + uint8_t (*duckdb_get_uint8)(duckdb_value val); + int16_t (*duckdb_get_int16)(duckdb_value val); + uint16_t (*duckdb_get_uint16)(duckdb_value val); + int32_t (*duckdb_get_int32)(duckdb_value val); + uint32_t (*duckdb_get_uint32)(duckdb_value val); + int64_t (*duckdb_get_int64)(duckdb_value val); + uint64_t (*duckdb_get_uint64)(duckdb_value val); + duckdb_hugeint (*duckdb_get_hugeint)(duckdb_value val); + duckdb_uhugeint (*duckdb_get_uhugeint)(duckdb_value val); + float (*duckdb_get_float)(duckdb_value val); + double (*duckdb_get_double)(duckdb_value val); + duckdb_date (*duckdb_get_date)(duckdb_value val); + duckdb_time (*duckdb_get_time)(duckdb_value val); + duckdb_time_tz (*duckdb_get_time_tz)(duckdb_value val); + duckdb_timestamp (*duckdb_get_timestamp)(duckdb_value val); + duckdb_interval (*duckdb_get_interval)(duckdb_value val); + duckdb_logical_type (*duckdb_get_value_type)(duckdb_value val); + duckdb_blob (*duckdb_get_blob)(duckdb_value val); + char *(*duckdb_get_varchar)(duckdb_value value); duckdb_value (*duckdb_create_struct_value)(duckdb_logical_type type, duckdb_value *values); duckdb_value (*duckdb_create_list_value)(duckdb_logical_type type, duckdb_value *values, idx_t value_count); duckdb_value (*duckdb_create_array_value)(duckdb_logical_type type, duckdb_value *values, idx_t value_count); - char *(*duckdb_get_varchar)(duckdb_value value); - int64_t (*duckdb_get_int64)(duckdb_value val); + idx_t (*duckdb_get_map_size)(duckdb_value value); + duckdb_value (*duckdb_get_map_key)(duckdb_value value, idx_t index); + duckdb_value (*duckdb_get_map_value)(duckdb_value value, idx_t index); + bool (*duckdb_is_null_value)(duckdb_value value); + duckdb_value (*duckdb_create_null_value)(); + idx_t (*duckdb_get_list_size)(duckdb_value value); + duckdb_value (*duckdb_get_list_child)(duckdb_value value, idx_t index); + duckdb_value (*duckdb_create_enum_value)(duckdb_logical_type type, uint64_t value); + uint64_t (*duckdb_get_enum_value)(duckdb_value value); + duckdb_value (*duckdb_get_struct_child)(duckdb_value value, idx_t index); duckdb_logical_type (*duckdb_create_logical_type)(duckdb_type type); char *(*duckdb_logical_type_get_alias)(duckdb_logical_type type); + void (*duckdb_logical_type_set_alias)(duckdb_logical_type type, const char *alias); duckdb_logical_type (*duckdb_create_list_type)(duckdb_logical_type type); duckdb_logical_type (*duckdb_create_array_type)(duckdb_logical_type type, idx_t array_size); duckdb_logical_type (*duckdb_create_map_type)(duckdb_logical_type key_type, duckdb_logical_type value_type); @@ -210,7 +265,8 @@ typedef struct { char *(*duckdb_union_type_member_name)(duckdb_logical_type type, idx_t index); duckdb_logical_type (*duckdb_union_type_member_type)(duckdb_logical_type type, idx_t index); void (*duckdb_destroy_logical_type)(duckdb_logical_type *type); - duckdb_data_chunk (*duckdb_fetch_chunk)(duckdb_result result); + duckdb_state (*duckdb_register_logical_type)(duckdb_connection con, duckdb_logical_type type, + duckdb_create_type_info info); duckdb_data_chunk (*duckdb_create_data_chunk)(duckdb_logical_type *types, idx_t column_count); void (*duckdb_destroy_data_chunk)(duckdb_data_chunk *chunk); void (*duckdb_data_chunk_reset)(duckdb_data_chunk chunk); @@ -237,6 +293,9 @@ typedef struct { duckdb_scalar_function (*duckdb_create_scalar_function)(); void (*duckdb_destroy_scalar_function)(duckdb_scalar_function *scalar_function); void (*duckdb_scalar_function_set_name)(duckdb_scalar_function scalar_function, const char *name); + void (*duckdb_scalar_function_set_varargs)(duckdb_scalar_function scalar_function, duckdb_logical_type type); + void (*duckdb_scalar_function_set_special_handling)(duckdb_scalar_function scalar_function); + void (*duckdb_scalar_function_set_volatile)(duckdb_scalar_function scalar_function); void (*duckdb_scalar_function_add_parameter)(duckdb_scalar_function scalar_function, duckdb_logical_type type); void (*duckdb_scalar_function_set_return_type)(duckdb_scalar_function scalar_function, duckdb_logical_type type); void (*duckdb_scalar_function_set_extra_info)(duckdb_scalar_function scalar_function, void *extra_info, @@ -244,6 +303,39 @@ typedef struct { void (*duckdb_scalar_function_set_function)(duckdb_scalar_function scalar_function, duckdb_scalar_function_t function); duckdb_state (*duckdb_register_scalar_function)(duckdb_connection con, duckdb_scalar_function scalar_function); + void *(*duckdb_scalar_function_get_extra_info)(duckdb_function_info info); + void (*duckdb_scalar_function_set_error)(duckdb_function_info info, const char *error); + duckdb_scalar_function_set (*duckdb_create_scalar_function_set)(const char *name); + void (*duckdb_destroy_scalar_function_set)(duckdb_scalar_function_set *scalar_function_set); + duckdb_state (*duckdb_add_scalar_function_to_set)(duckdb_scalar_function_set set, duckdb_scalar_function function); + duckdb_state (*duckdb_register_scalar_function_set)(duckdb_connection con, duckdb_scalar_function_set set); + duckdb_aggregate_function (*duckdb_create_aggregate_function)(); + void (*duckdb_destroy_aggregate_function)(duckdb_aggregate_function *aggregate_function); + void (*duckdb_aggregate_function_set_name)(duckdb_aggregate_function aggregate_function, const char *name); + void (*duckdb_aggregate_function_add_parameter)(duckdb_aggregate_function aggregate_function, + duckdb_logical_type type); + void (*duckdb_aggregate_function_set_return_type)(duckdb_aggregate_function aggregate_function, + duckdb_logical_type type); + void (*duckdb_aggregate_function_set_functions)(duckdb_aggregate_function aggregate_function, + duckdb_aggregate_state_size state_size, + duckdb_aggregate_init_t state_init, + duckdb_aggregate_update_t update, + duckdb_aggregate_combine_t combine, + duckdb_aggregate_finalize_t finalize); + void (*duckdb_aggregate_function_set_destructor)(duckdb_aggregate_function aggregate_function, + duckdb_aggregate_destroy_t destroy); + duckdb_state (*duckdb_register_aggregate_function)(duckdb_connection con, + duckdb_aggregate_function aggregate_function); + void (*duckdb_aggregate_function_set_special_handling)(duckdb_aggregate_function aggregate_function); + void (*duckdb_aggregate_function_set_extra_info)(duckdb_aggregate_function aggregate_function, void *extra_info, + duckdb_delete_callback_t destroy); + void *(*duckdb_aggregate_function_get_extra_info)(duckdb_function_info info); + void (*duckdb_aggregate_function_set_error)(duckdb_function_info info, const char *error); + duckdb_aggregate_function_set (*duckdb_create_aggregate_function_set)(const char *name); + void (*duckdb_destroy_aggregate_function_set)(duckdb_aggregate_function_set *aggregate_function_set); + duckdb_state (*duckdb_add_aggregate_function_to_set)(duckdb_aggregate_function_set set, + duckdb_aggregate_function function); + duckdb_state (*duckdb_register_aggregate_function_set)(duckdb_connection con, duckdb_aggregate_function_set set); duckdb_table_function (*duckdb_create_table_function)(); void (*duckdb_destroy_table_function)(duckdb_table_function *table_function); void (*duckdb_table_function_set_name)(duckdb_table_function table_function, const char *name); @@ -284,14 +376,68 @@ typedef struct { void (*duckdb_replacement_scan_set_function_name)(duckdb_replacement_scan_info info, const char *function_name); void (*duckdb_replacement_scan_add_parameter)(duckdb_replacement_scan_info info, duckdb_value parameter); void (*duckdb_replacement_scan_set_error)(duckdb_replacement_scan_info info, const char *error); + duckdb_value (*duckdb_profiling_info_get_metrics)(duckdb_profiling_info info); + idx_t (*duckdb_profiling_info_get_child_count)(duckdb_profiling_info info); + duckdb_profiling_info (*duckdb_profiling_info_get_child)(duckdb_profiling_info info, idx_t index); duckdb_state (*duckdb_appender_create)(duckdb_connection connection, const char *schema, const char *table, duckdb_appender *out_appender); + duckdb_state (*duckdb_appender_create_ext)(duckdb_connection connection, const char *catalog, const char *schema, + const char *table, duckdb_appender *out_appender); idx_t (*duckdb_appender_column_count)(duckdb_appender appender); duckdb_logical_type (*duckdb_appender_column_type)(duckdb_appender appender, idx_t col_idx); const char *(*duckdb_appender_error)(duckdb_appender appender); duckdb_state (*duckdb_appender_flush)(duckdb_appender appender); duckdb_state (*duckdb_appender_close)(duckdb_appender appender); duckdb_state (*duckdb_appender_destroy)(duckdb_appender *appender); + duckdb_state (*duckdb_appender_add_column)(duckdb_appender appender, const char *name); + duckdb_state (*duckdb_appender_clear_columns)(duckdb_appender appender); + duckdb_state (*duckdb_append_data_chunk)(duckdb_appender appender, duckdb_data_chunk chunk); + duckdb_state (*duckdb_table_description_create)(duckdb_connection connection, const char *schema, const char *table, + duckdb_table_description *out); + duckdb_state (*duckdb_table_description_create_ext)(duckdb_connection connection, const char *catalog, + const char *schema, const char *table, + duckdb_table_description *out); + void (*duckdb_table_description_destroy)(duckdb_table_description *table_description); + const char *(*duckdb_table_description_error)(duckdb_table_description table_description); + duckdb_state (*duckdb_column_has_default)(duckdb_table_description table_description, idx_t index, bool *out); + char *(*duckdb_table_description_get_column_name)(duckdb_table_description table_description, idx_t index); + void (*duckdb_execute_tasks)(duckdb_database database, idx_t max_tasks); + duckdb_task_state (*duckdb_create_task_state)(duckdb_database database); + void (*duckdb_execute_tasks_state)(duckdb_task_state state); + idx_t (*duckdb_execute_n_tasks_state)(duckdb_task_state state, idx_t max_tasks); + void (*duckdb_finish_execution)(duckdb_task_state state); + bool (*duckdb_task_state_is_finished)(duckdb_task_state state); + void (*duckdb_destroy_task_state)(duckdb_task_state state); + bool (*duckdb_execution_is_finished)(duckdb_connection con); + duckdb_data_chunk (*duckdb_fetch_chunk)(duckdb_result result); + duckdb_cast_function (*duckdb_create_cast_function)(); + void (*duckdb_cast_function_set_source_type)(duckdb_cast_function cast_function, duckdb_logical_type source_type); + void (*duckdb_cast_function_set_target_type)(duckdb_cast_function cast_function, duckdb_logical_type target_type); + void (*duckdb_cast_function_set_implicit_cast_cost)(duckdb_cast_function cast_function, int64_t cost); + void (*duckdb_cast_function_set_function)(duckdb_cast_function cast_function, duckdb_cast_function_t function); + void (*duckdb_cast_function_set_extra_info)(duckdb_cast_function cast_function, void *extra_info, + duckdb_delete_callback_t destroy); + void *(*duckdb_cast_function_get_extra_info)(duckdb_function_info info); + duckdb_cast_mode (*duckdb_cast_function_get_cast_mode)(duckdb_function_info info); + void (*duckdb_cast_function_set_error)(duckdb_function_info info, const char *error); + void (*duckdb_cast_function_set_row_error)(duckdb_function_info info, const char *error, idx_t row, + duckdb_vector output); + duckdb_state (*duckdb_register_cast_function)(duckdb_connection con, duckdb_cast_function cast_function); + void (*duckdb_destroy_cast_function)(duckdb_cast_function *cast_function); + bool (*duckdb_is_finite_timestamp_s)(duckdb_timestamp_s ts); + bool (*duckdb_is_finite_timestamp_ms)(duckdb_timestamp_ms ts); + bool (*duckdb_is_finite_timestamp_ns)(duckdb_timestamp_ns ts); + duckdb_value (*duckdb_create_timestamp_tz)(duckdb_timestamp input); + duckdb_value (*duckdb_create_timestamp_s)(duckdb_timestamp_s input); + duckdb_value (*duckdb_create_timestamp_ms)(duckdb_timestamp_ms input); + duckdb_value (*duckdb_create_timestamp_ns)(duckdb_timestamp_ns input); + duckdb_timestamp (*duckdb_get_timestamp_tz)(duckdb_value val); + duckdb_timestamp_s (*duckdb_get_timestamp_s)(duckdb_value val); + duckdb_timestamp_ms (*duckdb_get_timestamp_ms)(duckdb_value val); + duckdb_timestamp_ns (*duckdb_get_timestamp_ns)(duckdb_value val); + duckdb_state (*duckdb_append_value)(duckdb_appender appender, duckdb_value value); + duckdb_profiling_info (*duckdb_get_profiling_info)(duckdb_connection connection); + duckdb_value (*duckdb_profiling_info_get_value)(duckdb_profiling_info info, const char *key); duckdb_state (*duckdb_appender_begin_row)(duckdb_appender appender); duckdb_state (*duckdb_appender_end_row)(duckdb_appender appender); duckdb_state (*duckdb_append_default)(duckdb_appender appender); @@ -316,127 +462,16 @@ typedef struct { duckdb_state (*duckdb_append_varchar_length)(duckdb_appender appender, const char *val, idx_t length); duckdb_state (*duckdb_append_blob)(duckdb_appender appender, const void *data, idx_t length); duckdb_state (*duckdb_append_null)(duckdb_appender appender); - duckdb_state (*duckdb_append_data_chunk)(duckdb_appender appender, duckdb_data_chunk chunk); - void (*duckdb_execute_tasks)(duckdb_database database, idx_t max_tasks); - duckdb_task_state (*duckdb_create_task_state)(duckdb_database database); - void (*duckdb_execute_tasks_state)(duckdb_task_state state); - idx_t (*duckdb_execute_n_tasks_state)(duckdb_task_state state, idx_t max_tasks); - void (*duckdb_finish_execution)(duckdb_task_state state); - bool (*duckdb_task_state_is_finished)(duckdb_task_state state); - void (*duckdb_destroy_task_state)(duckdb_task_state state); - bool (*duckdb_execution_is_finished)(duckdb_connection con); - duckdb_profiling_info (*duckdb_get_profiling_info)(duckdb_connection connection); - duckdb_value (*duckdb_profiling_info_get_value)(duckdb_profiling_info info, const char *key); - idx_t (*duckdb_profiling_info_get_child_count)(duckdb_profiling_info info); - duckdb_profiling_info (*duckdb_profiling_info_get_child)(duckdb_profiling_info info, idx_t index); - duckdb_value (*duckdb_profiling_info_get_metrics)(duckdb_profiling_info info); - void (*duckdb_scalar_function_set_varargs)(duckdb_scalar_function scalar_function, duckdb_logical_type type); - void (*duckdb_scalar_function_set_special_handling)(duckdb_scalar_function scalar_function); - void (*duckdb_scalar_function_set_volatile)(duckdb_scalar_function scalar_function); - void *(*duckdb_scalar_function_get_extra_info)(duckdb_function_info info); - void (*duckdb_scalar_function_set_error)(duckdb_function_info info, const char *error); - duckdb_state (*duckdb_table_description_create)(duckdb_connection connection, const char *schema, const char *table, - duckdb_table_description *out); - void (*duckdb_table_description_destroy)(duckdb_table_description *table_description); - const char *(*duckdb_table_description_error)(duckdb_table_description table_description); - duckdb_error_type (*duckdb_result_error_type)(duckdb_result *result); - uint32_t (*duckdb_string_t_length)(duckdb_string_t string); - const char *(*duckdb_string_t_data)(duckdb_string_t *string); - duckdb_value (*duckdb_create_bool)(bool input); - duckdb_value (*duckdb_create_int8)(int8_t input); - duckdb_value (*duckdb_create_uint8)(uint8_t input); - duckdb_value (*duckdb_create_int16)(int16_t input); - duckdb_value (*duckdb_create_uint16)(uint16_t input); - duckdb_value (*duckdb_create_int32)(int32_t input); - duckdb_value (*duckdb_create_uint32)(uint32_t input); - duckdb_value (*duckdb_create_uint64)(uint64_t input); - duckdb_value (*duckdb_create_hugeint)(duckdb_hugeint input); - duckdb_value (*duckdb_create_uhugeint)(duckdb_uhugeint input); - duckdb_value (*duckdb_create_float)(float input); - duckdb_value (*duckdb_create_double)(double input); - duckdb_value (*duckdb_create_date)(duckdb_date input); - duckdb_value (*duckdb_create_time)(duckdb_time input); - duckdb_value (*duckdb_create_time_tz_value)(duckdb_time_tz value); - duckdb_value (*duckdb_create_timestamp)(duckdb_timestamp input); - duckdb_value (*duckdb_create_interval)(duckdb_interval input); - duckdb_value (*duckdb_create_blob)(const uint8_t *data, idx_t length); - bool (*duckdb_get_bool)(duckdb_value val); - int8_t (*duckdb_get_int8)(duckdb_value val); - uint8_t (*duckdb_get_uint8)(duckdb_value val); - int16_t (*duckdb_get_int16)(duckdb_value val); - uint16_t (*duckdb_get_uint16)(duckdb_value val); - int32_t (*duckdb_get_int32)(duckdb_value val); - uint32_t (*duckdb_get_uint32)(duckdb_value val); - uint64_t (*duckdb_get_uint64)(duckdb_value val); - duckdb_hugeint (*duckdb_get_hugeint)(duckdb_value val); - duckdb_uhugeint (*duckdb_get_uhugeint)(duckdb_value val); - float (*duckdb_get_float)(duckdb_value val); - double (*duckdb_get_double)(duckdb_value val); - duckdb_date (*duckdb_get_date)(duckdb_value val); - duckdb_time (*duckdb_get_time)(duckdb_value val); - duckdb_time_tz (*duckdb_get_time_tz)(duckdb_value val); - duckdb_timestamp (*duckdb_get_timestamp)(duckdb_value val); - duckdb_interval (*duckdb_get_interval)(duckdb_value val); - duckdb_logical_type (*duckdb_get_value_type)(duckdb_value val); - duckdb_blob (*duckdb_get_blob)(duckdb_value val); - duckdb_scalar_function_set (*duckdb_create_scalar_function_set)(const char *name); - void (*duckdb_destroy_scalar_function_set)(duckdb_scalar_function_set *scalar_function_set); - duckdb_state (*duckdb_add_scalar_function_to_set)(duckdb_scalar_function_set set, duckdb_scalar_function function); - duckdb_state (*duckdb_register_scalar_function_set)(duckdb_connection con, duckdb_scalar_function_set set); - duckdb_aggregate_function_set (*duckdb_create_aggregate_function_set)(const char *name); - void (*duckdb_destroy_aggregate_function_set)(duckdb_aggregate_function_set *aggregate_function_set); - duckdb_state (*duckdb_add_aggregate_function_to_set)(duckdb_aggregate_function_set set, - duckdb_aggregate_function function); - duckdb_state (*duckdb_register_aggregate_function_set)(duckdb_connection con, duckdb_aggregate_function_set set); - idx_t (*duckdb_get_map_size)(duckdb_value value); - duckdb_value (*duckdb_get_map_key)(duckdb_value value, idx_t index); - duckdb_value (*duckdb_get_map_value)(duckdb_value value, idx_t index); - duckdb_aggregate_function (*duckdb_create_aggregate_function)(); - void (*duckdb_destroy_aggregate_function)(duckdb_aggregate_function *aggregate_function); - void (*duckdb_aggregate_function_set_name)(duckdb_aggregate_function aggregate_function, const char *name); - void (*duckdb_aggregate_function_add_parameter)(duckdb_aggregate_function aggregate_function, - duckdb_logical_type type); - void (*duckdb_aggregate_function_set_return_type)(duckdb_aggregate_function aggregate_function, - duckdb_logical_type type); - void (*duckdb_aggregate_function_set_functions)(duckdb_aggregate_function aggregate_function, - duckdb_aggregate_state_size state_size, - duckdb_aggregate_init_t state_init, - duckdb_aggregate_update_t update, - duckdb_aggregate_combine_t combine, - duckdb_aggregate_finalize_t finalize); - void (*duckdb_aggregate_function_set_destructor)(duckdb_aggregate_function aggregate_function, - duckdb_aggregate_destroy_t destroy); - duckdb_state (*duckdb_register_aggregate_function)(duckdb_connection con, - duckdb_aggregate_function aggregate_function); - void (*duckdb_aggregate_function_set_special_handling)(duckdb_aggregate_function aggregate_function); - void (*duckdb_aggregate_function_set_extra_info)(duckdb_aggregate_function aggregate_function, void *extra_info, - duckdb_delete_callback_t destroy); - void *(*duckdb_aggregate_function_get_extra_info)(duckdb_function_info info); - void (*duckdb_aggregate_function_set_error)(duckdb_function_info info, const char *error); - void (*duckdb_logical_type_set_alias)(duckdb_logical_type type, const char *alias); - duckdb_state (*duckdb_register_logical_type)(duckdb_connection con, duckdb_logical_type type, - duckdb_create_type_info info); - duckdb_cast_function (*duckdb_create_cast_function)(); - void (*duckdb_cast_function_set_source_type)(duckdb_cast_function cast_function, duckdb_logical_type source_type); - void (*duckdb_cast_function_set_target_type)(duckdb_cast_function cast_function, duckdb_logical_type target_type); - void (*duckdb_cast_function_set_implicit_cast_cost)(duckdb_cast_function cast_function, int64_t cost); - void (*duckdb_cast_function_set_function)(duckdb_cast_function cast_function, duckdb_cast_function_t function); - void (*duckdb_cast_function_set_extra_info)(duckdb_cast_function cast_function, void *extra_info, - duckdb_delete_callback_t destroy); - void *(*duckdb_cast_function_get_extra_info)(duckdb_function_info info); - duckdb_cast_mode (*duckdb_cast_function_get_cast_mode)(duckdb_function_info info); - void (*duckdb_cast_function_set_error)(duckdb_function_info info, const char *error); - void (*duckdb_cast_function_set_row_error)(duckdb_function_info info, const char *error, idx_t row, - duckdb_vector output); - duckdb_state (*duckdb_register_cast_function)(duckdb_connection con, duckdb_cast_function cast_function); - void (*duckdb_destroy_cast_function)(duckdb_cast_function *cast_function); +#endif + +// These functions have been deprecated and may be removed in future versions of DuckDB +#ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE idx_t (*duckdb_row_count)(duckdb_result *result); void *(*duckdb_column_data)(duckdb_result *result, idx_t col); bool *(*duckdb_nullmask_data)(duckdb_result *result, idx_t col); duckdb_data_chunk (*duckdb_result_get_chunk)(duckdb_result result, idx_t chunk_index); bool (*duckdb_result_is_streaming)(duckdb_result result); idx_t (*duckdb_result_chunk_count)(duckdb_result result); - duckdb_result_type (*duckdb_result_return_type)(duckdb_result result); bool (*duckdb_value_boolean)(duckdb_result *result, idx_t col, idx_t row); int8_t (*duckdb_value_int8)(duckdb_result *result, idx_t col, idx_t row); int16_t (*duckdb_value_int16)(duckdb_result *result, idx_t col, idx_t row); @@ -465,7 +500,6 @@ typedef struct { duckdb_result *out_result); duckdb_state (*duckdb_pending_prepared_streaming)(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result); - duckdb_state (*duckdb_column_has_default)(duckdb_table_description table_description, idx_t index, bool *out); duckdb_state (*duckdb_query_arrow)(duckdb_connection connection, const char *query, duckdb_arrow *out_result); duckdb_state (*duckdb_query_arrow_schema)(duckdb_arrow result, duckdb_arrow_schema *out_schema); duckdb_state (*duckdb_prepared_arrow_schema)(duckdb_prepared_statement prepared, duckdb_arrow_schema *out_schema); @@ -486,28 +520,12 @@ typedef struct { duckdb_data_chunk (*duckdb_stream_fetch_chunk)(duckdb_result result); #endif -#ifdef DUCKDB_EXTENSION_API_VERSION_DEV // dev - // WARNING! the functions below are not (yet) stable - - duckdb_state (*duckdb_appender_create_ext)(duckdb_connection connection, const char *catalog, const char *schema, - const char *table, duckdb_appender *out_appender); - duckdb_state (*duckdb_table_description_create_ext)(duckdb_connection connection, const char *catalog, - const char *schema, const char *table, - duckdb_table_description *out); - char *(*duckdb_table_description_get_column_name)(duckdb_table_description table_description, idx_t index); - duckdb_logical_type (*duckdb_param_logical_type)(duckdb_prepared_statement prepared_statement, idx_t param_idx); - bool (*duckdb_is_null_value)(duckdb_value value); - duckdb_value (*duckdb_create_null_value)(); - idx_t (*duckdb_get_list_size)(duckdb_value value); - duckdb_value (*duckdb_get_list_child)(duckdb_value value, idx_t index); -#endif - -} duckdb_ext_api_v0; +} duckdb_ext_api_v1; //===--------------------------------------------------------------------===// // Typedefs mapping functions to struct entries //===--------------------------------------------------------------------===// -// Version v0.0.1 +// Version v1.2.0 #define duckdb_open duckdb_ext_api.duckdb_open #define duckdb_open_ext duckdb_ext_api.duckdb_open_ext #define duckdb_close duckdb_ext_api.duckdb_close @@ -528,40 +546,10 @@ typedef struct { #define duckdb_result_statement_type duckdb_ext_api.duckdb_result_statement_type #define duckdb_column_logical_type duckdb_ext_api.duckdb_column_logical_type #define duckdb_column_count duckdb_ext_api.duckdb_column_count -#define duckdb_row_count duckdb_ext_api.duckdb_row_count #define duckdb_rows_changed duckdb_ext_api.duckdb_rows_changed -#define duckdb_column_data duckdb_ext_api.duckdb_column_data -#define duckdb_nullmask_data duckdb_ext_api.duckdb_nullmask_data #define duckdb_result_error duckdb_ext_api.duckdb_result_error #define duckdb_result_error_type duckdb_ext_api.duckdb_result_error_type -#define duckdb_result_get_chunk duckdb_ext_api.duckdb_result_get_chunk -#define duckdb_result_is_streaming duckdb_ext_api.duckdb_result_is_streaming -#define duckdb_result_chunk_count duckdb_ext_api.duckdb_result_chunk_count #define duckdb_result_return_type duckdb_ext_api.duckdb_result_return_type -#define duckdb_value_boolean duckdb_ext_api.duckdb_value_boolean -#define duckdb_value_int8 duckdb_ext_api.duckdb_value_int8 -#define duckdb_value_int16 duckdb_ext_api.duckdb_value_int16 -#define duckdb_value_int32 duckdb_ext_api.duckdb_value_int32 -#define duckdb_value_int64 duckdb_ext_api.duckdb_value_int64 -#define duckdb_value_hugeint duckdb_ext_api.duckdb_value_hugeint -#define duckdb_value_uhugeint duckdb_ext_api.duckdb_value_uhugeint -#define duckdb_value_decimal duckdb_ext_api.duckdb_value_decimal -#define duckdb_value_uint8 duckdb_ext_api.duckdb_value_uint8 -#define duckdb_value_uint16 duckdb_ext_api.duckdb_value_uint16 -#define duckdb_value_uint32 duckdb_ext_api.duckdb_value_uint32 -#define duckdb_value_uint64 duckdb_ext_api.duckdb_value_uint64 -#define duckdb_value_float duckdb_ext_api.duckdb_value_float -#define duckdb_value_double duckdb_ext_api.duckdb_value_double -#define duckdb_value_date duckdb_ext_api.duckdb_value_date -#define duckdb_value_time duckdb_ext_api.duckdb_value_time -#define duckdb_value_timestamp duckdb_ext_api.duckdb_value_timestamp -#define duckdb_value_interval duckdb_ext_api.duckdb_value_interval -#define duckdb_value_varchar duckdb_ext_api.duckdb_value_varchar -#define duckdb_value_string duckdb_ext_api.duckdb_value_string -#define duckdb_value_varchar_internal duckdb_ext_api.duckdb_value_varchar_internal -#define duckdb_value_string_internal duckdb_ext_api.duckdb_value_string_internal -#define duckdb_value_blob duckdb_ext_api.duckdb_value_blob -#define duckdb_value_is_null duckdb_ext_api.duckdb_value_is_null #define duckdb_malloc duckdb_ext_api.duckdb_malloc #define duckdb_free duckdb_ext_api.duckdb_free #define duckdb_vector_size duckdb_ext_api.duckdb_vector_size @@ -578,6 +566,9 @@ typedef struct { #define duckdb_from_timestamp duckdb_ext_api.duckdb_from_timestamp #define duckdb_to_timestamp duckdb_ext_api.duckdb_to_timestamp #define duckdb_is_finite_timestamp duckdb_ext_api.duckdb_is_finite_timestamp +#define duckdb_is_finite_timestamp_s duckdb_ext_api.duckdb_is_finite_timestamp_s +#define duckdb_is_finite_timestamp_ms duckdb_ext_api.duckdb_is_finite_timestamp_ms +#define duckdb_is_finite_timestamp_ns duckdb_ext_api.duckdb_is_finite_timestamp_ns #define duckdb_hugeint_to_double duckdb_ext_api.duckdb_hugeint_to_double #define duckdb_double_to_hugeint duckdb_ext_api.duckdb_double_to_hugeint #define duckdb_uhugeint_to_double duckdb_ext_api.duckdb_uhugeint_to_double @@ -590,6 +581,7 @@ typedef struct { #define duckdb_nparams duckdb_ext_api.duckdb_nparams #define duckdb_parameter_name duckdb_ext_api.duckdb_parameter_name #define duckdb_param_type duckdb_ext_api.duckdb_param_type +#define duckdb_param_logical_type duckdb_ext_api.duckdb_param_logical_type #define duckdb_clear_bindings duckdb_ext_api.duckdb_clear_bindings #define duckdb_prepared_statement_type duckdb_ext_api.duckdb_prepared_statement_type #define duckdb_bind_value duckdb_ext_api.duckdb_bind_value @@ -618,13 +610,11 @@ typedef struct { #define duckdb_bind_blob duckdb_ext_api.duckdb_bind_blob #define duckdb_bind_null duckdb_ext_api.duckdb_bind_null #define duckdb_execute_prepared duckdb_ext_api.duckdb_execute_prepared -#define duckdb_execute_prepared_streaming duckdb_ext_api.duckdb_execute_prepared_streaming #define duckdb_extract_statements duckdb_ext_api.duckdb_extract_statements #define duckdb_prepare_extracted_statement duckdb_ext_api.duckdb_prepare_extracted_statement #define duckdb_extract_statements_error duckdb_ext_api.duckdb_extract_statements_error #define duckdb_destroy_extracted duckdb_ext_api.duckdb_destroy_extracted #define duckdb_pending_prepared duckdb_ext_api.duckdb_pending_prepared -#define duckdb_pending_prepared_streaming duckdb_ext_api.duckdb_pending_prepared_streaming #define duckdb_destroy_pending duckdb_ext_api.duckdb_destroy_pending #define duckdb_pending_error duckdb_ext_api.duckdb_pending_error #define duckdb_pending_execute_task duckdb_ext_api.duckdb_pending_execute_task @@ -651,6 +641,10 @@ typedef struct { #define duckdb_create_time duckdb_ext_api.duckdb_create_time #define duckdb_create_time_tz_value duckdb_ext_api.duckdb_create_time_tz_value #define duckdb_create_timestamp duckdb_ext_api.duckdb_create_timestamp +#define duckdb_create_timestamp_tz duckdb_ext_api.duckdb_create_timestamp_tz +#define duckdb_create_timestamp_s duckdb_ext_api.duckdb_create_timestamp_s +#define duckdb_create_timestamp_ms duckdb_ext_api.duckdb_create_timestamp_ms +#define duckdb_create_timestamp_ns duckdb_ext_api.duckdb_create_timestamp_ns #define duckdb_create_interval duckdb_ext_api.duckdb_create_interval #define duckdb_create_blob duckdb_ext_api.duckdb_create_blob #define duckdb_get_bool duckdb_ext_api.duckdb_get_bool @@ -670,6 +664,10 @@ typedef struct { #define duckdb_get_time duckdb_ext_api.duckdb_get_time #define duckdb_get_time_tz duckdb_ext_api.duckdb_get_time_tz #define duckdb_get_timestamp duckdb_ext_api.duckdb_get_timestamp +#define duckdb_get_timestamp_tz duckdb_ext_api.duckdb_get_timestamp_tz +#define duckdb_get_timestamp_s duckdb_ext_api.duckdb_get_timestamp_s +#define duckdb_get_timestamp_ms duckdb_ext_api.duckdb_get_timestamp_ms +#define duckdb_get_timestamp_ns duckdb_ext_api.duckdb_get_timestamp_ns #define duckdb_get_interval duckdb_ext_api.duckdb_get_interval #define duckdb_get_value_type duckdb_ext_api.duckdb_get_value_type #define duckdb_get_blob duckdb_ext_api.duckdb_get_blob @@ -680,6 +678,13 @@ typedef struct { #define duckdb_get_map_size duckdb_ext_api.duckdb_get_map_size #define duckdb_get_map_key duckdb_ext_api.duckdb_get_map_key #define duckdb_get_map_value duckdb_ext_api.duckdb_get_map_value +#define duckdb_is_null_value duckdb_ext_api.duckdb_is_null_value +#define duckdb_create_null_value duckdb_ext_api.duckdb_create_null_value +#define duckdb_get_list_size duckdb_ext_api.duckdb_get_list_size +#define duckdb_get_list_child duckdb_ext_api.duckdb_get_list_child +#define duckdb_create_enum_value duckdb_ext_api.duckdb_create_enum_value +#define duckdb_get_enum_value duckdb_ext_api.duckdb_get_enum_value +#define duckdb_get_struct_child duckdb_ext_api.duckdb_get_struct_child #define duckdb_create_logical_type duckdb_ext_api.duckdb_create_logical_type #define duckdb_logical_type_get_alias duckdb_ext_api.duckdb_logical_type_get_alias #define duckdb_logical_type_set_alias duckdb_ext_api.duckdb_logical_type_set_alias @@ -809,12 +814,15 @@ typedef struct { #define duckdb_profiling_info_get_child_count duckdb_ext_api.duckdb_profiling_info_get_child_count #define duckdb_profiling_info_get_child duckdb_ext_api.duckdb_profiling_info_get_child #define duckdb_appender_create duckdb_ext_api.duckdb_appender_create +#define duckdb_appender_create_ext duckdb_ext_api.duckdb_appender_create_ext #define duckdb_appender_column_count duckdb_ext_api.duckdb_appender_column_count #define duckdb_appender_column_type duckdb_ext_api.duckdb_appender_column_type #define duckdb_appender_error duckdb_ext_api.duckdb_appender_error #define duckdb_appender_flush duckdb_ext_api.duckdb_appender_flush #define duckdb_appender_close duckdb_ext_api.duckdb_appender_close #define duckdb_appender_destroy duckdb_ext_api.duckdb_appender_destroy +#define duckdb_appender_add_column duckdb_ext_api.duckdb_appender_add_column +#define duckdb_appender_clear_columns duckdb_ext_api.duckdb_appender_clear_columns #define duckdb_appender_begin_row duckdb_ext_api.duckdb_appender_begin_row #define duckdb_appender_end_row duckdb_ext_api.duckdb_appender_end_row #define duckdb_append_default duckdb_ext_api.duckdb_append_default @@ -839,25 +847,14 @@ typedef struct { #define duckdb_append_varchar_length duckdb_ext_api.duckdb_append_varchar_length #define duckdb_append_blob duckdb_ext_api.duckdb_append_blob #define duckdb_append_null duckdb_ext_api.duckdb_append_null +#define duckdb_append_value duckdb_ext_api.duckdb_append_value #define duckdb_append_data_chunk duckdb_ext_api.duckdb_append_data_chunk #define duckdb_table_description_create duckdb_ext_api.duckdb_table_description_create +#define duckdb_table_description_create_ext duckdb_ext_api.duckdb_table_description_create_ext #define duckdb_table_description_destroy duckdb_ext_api.duckdb_table_description_destroy #define duckdb_table_description_error duckdb_ext_api.duckdb_table_description_error #define duckdb_column_has_default duckdb_ext_api.duckdb_column_has_default -#define duckdb_query_arrow duckdb_ext_api.duckdb_query_arrow -#define duckdb_query_arrow_schema duckdb_ext_api.duckdb_query_arrow_schema -#define duckdb_prepared_arrow_schema duckdb_ext_api.duckdb_prepared_arrow_schema -#define duckdb_result_arrow_array duckdb_ext_api.duckdb_result_arrow_array -#define duckdb_query_arrow_array duckdb_ext_api.duckdb_query_arrow_array -#define duckdb_arrow_column_count duckdb_ext_api.duckdb_arrow_column_count -#define duckdb_arrow_row_count duckdb_ext_api.duckdb_arrow_row_count -#define duckdb_arrow_rows_changed duckdb_ext_api.duckdb_arrow_rows_changed -#define duckdb_query_arrow_error duckdb_ext_api.duckdb_query_arrow_error -#define duckdb_destroy_arrow duckdb_ext_api.duckdb_destroy_arrow -#define duckdb_destroy_arrow_stream duckdb_ext_api.duckdb_destroy_arrow_stream -#define duckdb_execute_prepared_arrow duckdb_ext_api.duckdb_execute_prepared_arrow -#define duckdb_arrow_scan duckdb_ext_api.duckdb_arrow_scan -#define duckdb_arrow_array_scan duckdb_ext_api.duckdb_arrow_array_scan +#define duckdb_table_description_get_column_name duckdb_ext_api.duckdb_table_description_get_column_name #define duckdb_execute_tasks duckdb_ext_api.duckdb_execute_tasks #define duckdb_create_task_state duckdb_ext_api.duckdb_create_task_state #define duckdb_execute_tasks_state duckdb_ext_api.duckdb_execute_tasks_state @@ -866,7 +863,6 @@ typedef struct { #define duckdb_task_state_is_finished duckdb_ext_api.duckdb_task_state_is_finished #define duckdb_destroy_task_state duckdb_ext_api.duckdb_destroy_task_state #define duckdb_execution_is_finished duckdb_ext_api.duckdb_execution_is_finished -#define duckdb_stream_fetch_chunk duckdb_ext_api.duckdb_stream_fetch_chunk #define duckdb_fetch_chunk duckdb_ext_api.duckdb_fetch_chunk #define duckdb_create_cast_function duckdb_ext_api.duckdb_create_cast_function #define duckdb_cast_function_set_source_type duckdb_ext_api.duckdb_cast_function_set_source_type @@ -881,37 +877,70 @@ typedef struct { #define duckdb_register_cast_function duckdb_ext_api.duckdb_register_cast_function #define duckdb_destroy_cast_function duckdb_ext_api.duckdb_destroy_cast_function -// Version dev -#define duckdb_param_logical_type duckdb_ext_api.duckdb_param_logical_type -#define duckdb_is_null_value duckdb_ext_api.duckdb_is_null_value -#define duckdb_create_null_value duckdb_ext_api.duckdb_create_null_value -#define duckdb_get_list_size duckdb_ext_api.duckdb_get_list_size -#define duckdb_get_list_child duckdb_ext_api.duckdb_get_list_child -#define duckdb_appender_create_ext duckdb_ext_api.duckdb_appender_create_ext -#define duckdb_table_description_create_ext duckdb_ext_api.duckdb_table_description_create_ext -#define duckdb_table_description_get_column_name duckdb_ext_api.duckdb_table_description_get_column_name +// Version unstable_deprecated +#define duckdb_row_count duckdb_ext_api.duckdb_row_count +#define duckdb_column_data duckdb_ext_api.duckdb_column_data +#define duckdb_nullmask_data duckdb_ext_api.duckdb_nullmask_data +#define duckdb_result_get_chunk duckdb_ext_api.duckdb_result_get_chunk +#define duckdb_result_is_streaming duckdb_ext_api.duckdb_result_is_streaming +#define duckdb_result_chunk_count duckdb_ext_api.duckdb_result_chunk_count +#define duckdb_value_boolean duckdb_ext_api.duckdb_value_boolean +#define duckdb_value_int8 duckdb_ext_api.duckdb_value_int8 +#define duckdb_value_int16 duckdb_ext_api.duckdb_value_int16 +#define duckdb_value_int32 duckdb_ext_api.duckdb_value_int32 +#define duckdb_value_int64 duckdb_ext_api.duckdb_value_int64 +#define duckdb_value_hugeint duckdb_ext_api.duckdb_value_hugeint +#define duckdb_value_uhugeint duckdb_ext_api.duckdb_value_uhugeint +#define duckdb_value_decimal duckdb_ext_api.duckdb_value_decimal +#define duckdb_value_uint8 duckdb_ext_api.duckdb_value_uint8 +#define duckdb_value_uint16 duckdb_ext_api.duckdb_value_uint16 +#define duckdb_value_uint32 duckdb_ext_api.duckdb_value_uint32 +#define duckdb_value_uint64 duckdb_ext_api.duckdb_value_uint64 +#define duckdb_value_float duckdb_ext_api.duckdb_value_float +#define duckdb_value_double duckdb_ext_api.duckdb_value_double +#define duckdb_value_date duckdb_ext_api.duckdb_value_date +#define duckdb_value_time duckdb_ext_api.duckdb_value_time +#define duckdb_value_timestamp duckdb_ext_api.duckdb_value_timestamp +#define duckdb_value_interval duckdb_ext_api.duckdb_value_interval +#define duckdb_value_varchar duckdb_ext_api.duckdb_value_varchar +#define duckdb_value_string duckdb_ext_api.duckdb_value_string +#define duckdb_value_varchar_internal duckdb_ext_api.duckdb_value_varchar_internal +#define duckdb_value_string_internal duckdb_ext_api.duckdb_value_string_internal +#define duckdb_value_blob duckdb_ext_api.duckdb_value_blob +#define duckdb_value_is_null duckdb_ext_api.duckdb_value_is_null +#define duckdb_execute_prepared_streaming duckdb_ext_api.duckdb_execute_prepared_streaming +#define duckdb_pending_prepared_streaming duckdb_ext_api.duckdb_pending_prepared_streaming +#define duckdb_query_arrow duckdb_ext_api.duckdb_query_arrow +#define duckdb_query_arrow_schema duckdb_ext_api.duckdb_query_arrow_schema +#define duckdb_prepared_arrow_schema duckdb_ext_api.duckdb_prepared_arrow_schema +#define duckdb_result_arrow_array duckdb_ext_api.duckdb_result_arrow_array +#define duckdb_query_arrow_array duckdb_ext_api.duckdb_query_arrow_array +#define duckdb_arrow_column_count duckdb_ext_api.duckdb_arrow_column_count +#define duckdb_arrow_row_count duckdb_ext_api.duckdb_arrow_row_count +#define duckdb_arrow_rows_changed duckdb_ext_api.duckdb_arrow_rows_changed +#define duckdb_query_arrow_error duckdb_ext_api.duckdb_query_arrow_error +#define duckdb_destroy_arrow duckdb_ext_api.duckdb_destroy_arrow +#define duckdb_destroy_arrow_stream duckdb_ext_api.duckdb_destroy_arrow_stream +#define duckdb_execute_prepared_arrow duckdb_ext_api.duckdb_execute_prepared_arrow +#define duckdb_arrow_scan duckdb_ext_api.duckdb_arrow_scan +#define duckdb_arrow_array_scan duckdb_ext_api.duckdb_arrow_array_scan +#define duckdb_stream_fetch_chunk duckdb_ext_api.duckdb_stream_fetch_chunk //===--------------------------------------------------------------------===// // Struct Global Macros //===--------------------------------------------------------------------===// // This goes in the c/c++ file containing the entrypoint (handle -#define DUCKDB_EXTENSION_GLOBAL duckdb_ext_api_v0 duckdb_ext_api = {0}; +#define DUCKDB_EXTENSION_GLOBAL duckdb_ext_api_v1 duckdb_ext_api = {0}; // Initializes the C Extension API: First thing to call in the extension entrypoint #define DUCKDB_EXTENSION_API_INIT(info, access, minimum_api_version) \ - duckdb_ext_api_v0 *res = (duckdb_ext_api_v0 *)access->get_api(info, minimum_api_version); \ + duckdb_ext_api_v1 *res = (duckdb_ext_api_v1 *)access->get_api(info, minimum_api_version); \ if (!res) { \ return false; \ }; \ duckdb_ext_api = *res; // Place in global scope of any C/C++ file that needs to access the extension API -#define DUCKDB_EXTENSION_EXTERN extern duckdb_ext_api_v0 duckdb_ext_api; - -#ifdef _WIN32 -#define ENTRYPOINT_VISIBILITY __declspec(dllexport) -#else -#define ENTRYPOINT_VISIBILITY __attribute__((visibility("default"))) -#endif +#define DUCKDB_EXTENSION_EXTERN extern duckdb_ext_api_v1 duckdb_ext_api; //===--------------------------------------------------------------------===// // Entrypoint Macros @@ -926,7 +955,7 @@ typedef struct { #define DUCKDB_EXTENSION_ENTRYPOINT \ DUCKDB_EXTENSION_GLOBAL static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)( \ duckdb_connection connection, duckdb_extension_info info, struct duckdb_extension_access * access); \ - ENTRYPOINT_VISIBILITY DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \ + DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \ DUCKDB_EXTENSION_NAME, _init_c_api)(duckdb_extension_info info, struct duckdb_extension_access * access) { \ DUCKDB_EXTENSION_API_INIT(info, access, DUCKDB_EXTENSION_API_VERSION_STRING); \ duckdb_database *db = access->get_database(info); \ diff --git a/extension-ci-tools b/extension-ci-tools index 871db4d..7d7cae1 160000 --- a/extension-ci-tools +++ b/extension-ci-tools @@ -1 +1 @@ -Subproject commit 871db4d06e0d71769f737fb16301b287b25351cc +Subproject commit 7d7cae189bd00735df04c2a5e7031b14e56e112a