C-API-Referenz

Diese Seite enthält die Referenz der DuckDB-C-API.

API-Referenzübersicht

Öffnen und Verbinden

duckdb_instance_cache duckdb_create_instance_cache();
duckdb_state duckdb_get_or_create_from_cache(duckdb_instance_cache instance_cache, const char *path, duckdb_database *out_database, duckdb_config config, char **out_error);
void duckdb_destroy_instance_cache(duckdb_instance_cache *instance_cache);
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);
void duckdb_close(duckdb_database *database);
duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);
void duckdb_interrupt(duckdb_connection connection);
duckdb_query_progress_type duckdb_query_progress(duckdb_connection connection);
void duckdb_disconnect(duckdb_connection *connection);
void duckdb_connection_get_client_context(duckdb_connection connection, duckdb_client_context *out_context);
void duckdb_connection_get_arrow_options(duckdb_connection connection, duckdb_arrow_options *out_arrow_options);
idx_t duckdb_client_context_get_connection_id(duckdb_client_context context);
void duckdb_destroy_client_context(duckdb_client_context *context);
void duckdb_destroy_arrow_options(duckdb_arrow_options *arrow_options);
const char *duckdb_library_version();
duckdb_value duckdb_get_table_names(duckdb_connection connection, const char *query, bool qualified);

Konfiguration

duckdb_state duckdb_create_config(duckdb_config *out_config);
size_t duckdb_config_count();
duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description);
duckdb_state duckdb_set_config(duckdb_config config, const char *name, const char *option);
void duckdb_destroy_config(duckdb_config *config);

Fehlerdaten

duckdb_error_data duckdb_create_error_data(duckdb_error_type type, const char *message);
void duckdb_destroy_error_data(duckdb_error_data *error_data);
duckdb_error_type duckdb_error_data_error_type(duckdb_error_data error_data);
const char *duckdb_error_data_message(duckdb_error_data error_data);
bool duckdb_error_data_has_error(duckdb_error_data error_data);

Abfrageausführung

duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out_result);
void duckdb_destroy_result(duckdb_result *result);
const char *duckdb_column_name(duckdb_result *result, idx_t col);
duckdb_type duckdb_column_type(duckdb_result *result, idx_t col);
duckdb_statement_type duckdb_result_statement_type(duckdb_result result);
duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col);
duckdb_arrow_options duckdb_result_get_arrow_options(duckdb_result *result);
idx_t duckdb_column_count(duckdb_result *result);
idx_t duckdb_row_count(duckdb_result *result);
idx_t duckdb_rows_changed(duckdb_result *result);
void *duckdb_column_data(duckdb_result *result, idx_t col);
bool *duckdb_nullmask_data(duckdb_result *result, idx_t col);
const char *duckdb_result_error(duckdb_result *result);
duckdb_error_type duckdb_result_error_type(duckdb_result *result);

Ergebnisfunktionen

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);

Sichere Abruffunktionen

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);
int32_t duckdb_value_int32(duckdb_result *result, idx_t col, idx_t row);
int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row);
duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);
duckdb_uhugeint duckdb_value_uhugeint(duckdb_result *result, idx_t col, idx_t row);
duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);
uint8_t duckdb_value_uint8(duckdb_result *result, idx_t col, idx_t row);
uint16_t duckdb_value_uint16(duckdb_result *result, idx_t col, idx_t row);
uint32_t duckdb_value_uint32(duckdb_result *result, idx_t col, idx_t row);
uint64_t duckdb_value_uint64(duckdb_result *result, idx_t col, idx_t row);
float duckdb_value_float(duckdb_result *result, idx_t col, idx_t row);
double duckdb_value_double(duckdb_result *result, idx_t col, idx_t row);
duckdb_date duckdb_value_date(duckdb_result *result, idx_t col, idx_t row);
duckdb_time duckdb_value_time(duckdb_result *result, idx_t col, idx_t row);
duckdb_timestamp duckdb_value_timestamp(duckdb_result *result, idx_t col, idx_t row);
duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t row);
char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row);
duckdb_string duckdb_value_string(duckdb_result *result, idx_t col, idx_t row);
char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row);
duckdb_string duckdb_value_string_internal(duckdb_result *result, idx_t col, idx_t row);
duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row);
bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row);

Hilfsfunktionen

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);

Hilfsfunktionen für Date, Time und Timestamp

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);
duckdb_time_struct duckdb_from_time(duckdb_time time);
duckdb_time_tz duckdb_create_time_tz(int64_t micros, int32_t offset);
duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz micros);
duckdb_time duckdb_to_time(duckdb_time_struct time);
duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts);
duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts);
bool duckdb_is_finite_timestamp(duckdb_timestamp ts);
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);

Hugeint-Hilfsfunktionen

double duckdb_hugeint_to_double(duckdb_hugeint val);
duckdb_hugeint duckdb_double_to_hugeint(double val);

Unsigned-Hugeint-Hilfsfunktionen

double duckdb_uhugeint_to_double(duckdb_uhugeint val);
duckdb_uhugeint duckdb_double_to_uhugeint(double val);

Decimal-Hilfsfunktionen

duckdb_decimal duckdb_double_to_decimal(double val, uint8_t width, uint8_t scale);
double duckdb_decimal_to_double(duckdb_decimal val);

Prepared Statements

duckdb_state duckdb_prepare(duckdb_connection connection, const char *query, duckdb_prepared_statement *out_prepared_statement);
void duckdb_destroy_prepare(duckdb_prepared_statement *prepared_statement);
const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement);
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);
idx_t duckdb_prepared_statement_column_count(duckdb_prepared_statement prepared_statement);
const char *duckdb_prepared_statement_column_name(duckdb_prepared_statement prepared_statement, idx_t col_idx);
duckdb_logical_type duckdb_prepared_statement_column_logical_type(duckdb_prepared_statement prepared_statement, idx_t col_idx);
duckdb_type duckdb_prepared_statement_column_type(duckdb_prepared_statement prepared_statement, idx_t col_idx);

Werte an Prepared Statements binden

duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val);
duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out, const char *name);
duckdb_state duckdb_bind_boolean(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val);
duckdb_state duckdb_bind_int8(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val);
duckdb_state duckdb_bind_int16(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val);
duckdb_state duckdb_bind_int32(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val);
duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val);
duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_hugeint val);
duckdb_state duckdb_bind_uhugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_uhugeint val);
duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_decimal val);
duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val);
duckdb_state duckdb_bind_uint16(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val);
duckdb_state duckdb_bind_uint32(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val);
duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val);
duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val);
duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val);
duckdb_state duckdb_bind_date(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_date val);
duckdb_state duckdb_bind_time(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_time val);
duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_timestamp val);
duckdb_state duckdb_bind_timestamp_tz(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_timestamp val);
duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_interval val);
duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val);
duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val, idx_t length);
duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data, idx_t length);
duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx);

Prepared Statements ausführen

duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement, duckdb_result *out_result);
duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepared_statement, duckdb_result *out_result);

Anweisungen extrahieren

idx_t duckdb_extract_statements(duckdb_connection connection, const char *query, duckdb_extracted_statements *out_extracted_statements);
duckdb_state duckdb_prepare_extracted_statement(duckdb_connection connection, duckdb_extracted_statements extracted_statements, idx_t index, duckdb_prepared_statement *out_prepared_statement);
const char *duckdb_extract_statements_error(duckdb_extracted_statements extracted_statements);
void duckdb_destroy_extracted(duckdb_extracted_statements *extracted_statements);

Pending-Ergebnis-Schnittstelle

duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result);
duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result);
void duckdb_destroy_pending(duckdb_pending_result *pending_result);
const char *duckdb_pending_error(duckdb_pending_result pending_result);
duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_result);
duckdb_pending_state duckdb_pending_execute_check_state(duckdb_pending_result pending_result);
duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb_result *out_result);
bool duckdb_pending_execution_is_finished(duckdb_pending_state pending_state);

Value-Schnittstelle

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_bignum(duckdb_bignum input);
duckdb_value duckdb_create_decimal(duckdb_decimal 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_ns(duckdb_time_ns input);
duckdb_value duckdb_create_time_tz_value(duckdb_time_tz value);
duckdb_value duckdb_create_timestamp(duckdb_timestamp input);
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_value duckdb_create_interval(duckdb_interval input);
duckdb_value duckdb_create_blob(const uint8_t *data, idx_t length);
duckdb_value duckdb_create_bit(duckdb_bit input);
duckdb_value duckdb_create_uuid(duckdb_uhugeint input);
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);
duckdb_bignum duckdb_get_bignum(duckdb_value val);
duckdb_decimal duckdb_get_decimal(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_ns duckdb_get_time_ns(duckdb_value val);
duckdb_time_tz duckdb_get_time_tz(duckdb_value val);
duckdb_timestamp duckdb_get_timestamp(duckdb_value val);
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_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_bit duckdb_get_bit(duckdb_value val);
duckdb_uhugeint duckdb_get_uuid(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);
duckdb_value duckdb_create_map_value(duckdb_logical_type map_type, duckdb_value *keys, duckdb_value *values, idx_t entry_count);
duckdb_value duckdb_create_union_value(duckdb_logical_type union_type, idx_t tag_index, duckdb_value value);
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);
char *duckdb_value_to_string(duckdb_value value);

Logical-Type-Schnittstelle

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);
duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types, const char **member_names, idx_t member_count);
duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types, const char **member_names, idx_t member_count);
duckdb_logical_type duckdb_create_enum_type(const char **member_names, idx_t member_count);
duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale);
duckdb_type duckdb_get_type_id(duckdb_logical_type type);
uint8_t duckdb_decimal_width(duckdb_logical_type type);
uint8_t duckdb_decimal_scale(duckdb_logical_type type);
duckdb_type duckdb_decimal_internal_type(duckdb_logical_type type);
duckdb_type duckdb_enum_internal_type(duckdb_logical_type type);
uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type);
char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index);
duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type);
duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type);
idx_t duckdb_array_type_array_size(duckdb_logical_type type);
duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type);
duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type);
idx_t duckdb_struct_type_child_count(duckdb_logical_type type);
char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t index);
duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_t index);
idx_t duckdb_union_type_member_count(duckdb_logical_type type);
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_state duckdb_register_logical_type(duckdb_connection con, duckdb_logical_type type, duckdb_create_type_info info);

Data-Chunk-Schnittstelle

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);
idx_t duckdb_data_chunk_get_column_count(duckdb_data_chunk chunk);
duckdb_vector duckdb_data_chunk_get_vector(duckdb_data_chunk chunk, idx_t col_idx);
idx_t duckdb_data_chunk_get_size(duckdb_data_chunk chunk);
void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size);

Vector-Schnittstelle

duckdb_vector duckdb_create_vector(duckdb_logical_type type, idx_t capacity);
void duckdb_destroy_vector(duckdb_vector *vector);
duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector);
void *duckdb_vector_get_data(duckdb_vector vector);
uint64_t *duckdb_vector_get_validity(duckdb_vector vector);
void duckdb_vector_ensure_validity_writable(duckdb_vector vector);
void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str);
void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index, const char *str, idx_t str_len);
duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector);
idx_t duckdb_list_vector_get_size(duckdb_vector vector);
duckdb_state duckdb_list_vector_set_size(duckdb_vector vector, idx_t size);
duckdb_state duckdb_list_vector_reserve(duckdb_vector vector, idx_t required_capacity);
duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index);
duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector);
void duckdb_slice_vector(duckdb_vector vector, duckdb_selection_vector sel, idx_t len);
void duckdb_vector_copy_sel(duckdb_vector src, duckdb_vector dst, duckdb_selection_vector sel, idx_t src_count, idx_t src_offset, idx_t dst_offset);
void duckdb_vector_reference_value(duckdb_vector vector, duckdb_value value);
void duckdb_vector_reference_vector(duckdb_vector to_vector, duckdb_vector from_vector);

Validity-Mask-Funktionen

bool duckdb_validity_row_is_valid(uint64_t *validity, idx_t row);
void duckdb_validity_set_row_validity(uint64_t *validity, idx_t row, bool valid);
void duckdb_validity_set_row_invalid(uint64_t *validity, idx_t row);
void duckdb_validity_set_row_valid(uint64_t *validity, idx_t row);

Skalare Funktionen

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, duckdb_delete_callback_t destroy);
void duckdb_scalar_function_set_bind(duckdb_scalar_function scalar_function, duckdb_scalar_function_bind_t bind);
void duckdb_scalar_function_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
void duckdb_scalar_function_set_bind_data_copy(duckdb_bind_info info, duckdb_copy_callback_t copy);
void duckdb_scalar_function_bind_set_error(duckdb_bind_info info, const char *error);
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_bind_get_extra_info(duckdb_bind_info info);
void *duckdb_scalar_function_get_bind_data(duckdb_function_info info);
void duckdb_scalar_function_get_client_context(duckdb_bind_info info, duckdb_client_context *out_context);
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);
idx_t duckdb_scalar_function_bind_get_argument_count(duckdb_bind_info info);
duckdb_expression duckdb_scalar_function_bind_get_argument(duckdb_bind_info info, idx_t index);

Selection-Vector-Schnittstelle

duckdb_selection_vector duckdb_create_selection_vector(idx_t size);
void duckdb_destroy_selection_vector(duckdb_selection_vector sel);
sel_t *duckdb_selection_vector_get_data_ptr(duckdb_selection_vector sel);

Aggregatfunktionen

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);

Tabellenfunktionen

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);
void duckdb_table_function_add_parameter(duckdb_table_function table_function, duckdb_logical_type type);
void duckdb_table_function_add_named_parameter(duckdb_table_function table_function, const char *name, duckdb_logical_type type);
void duckdb_table_function_set_extra_info(duckdb_table_function table_function, void *extra_info, duckdb_delete_callback_t destroy);
void duckdb_table_function_set_bind(duckdb_table_function table_function, duckdb_table_function_bind_t bind);
void duckdb_table_function_set_init(duckdb_table_function table_function, duckdb_table_function_init_t init);
void duckdb_table_function_set_local_init(duckdb_table_function table_function, duckdb_table_function_init_t init);
void duckdb_table_function_set_function(duckdb_table_function table_function, duckdb_table_function_t function);
void duckdb_table_function_supports_projection_pushdown(duckdb_table_function table_function, bool pushdown);
duckdb_state duckdb_register_table_function(duckdb_connection con, duckdb_table_function function);

Tabellenfunktion binden

void *duckdb_bind_get_extra_info(duckdb_bind_info info);
void duckdb_table_function_get_client_context(duckdb_bind_info info, duckdb_client_context *out_context);
void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duckdb_logical_type type);
idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info);
duckdb_value duckdb_bind_get_parameter(duckdb_bind_info info, idx_t index);
duckdb_value duckdb_bind_get_named_parameter(duckdb_bind_info info, const char *name);
void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
void duckdb_bind_set_cardinality(duckdb_bind_info info, idx_t cardinality, bool is_exact);
void duckdb_bind_set_error(duckdb_bind_info info, const char *error);

Tabellenfunktion initialisieren

void *duckdb_init_get_extra_info(duckdb_init_info info);
void *duckdb_init_get_bind_data(duckdb_init_info info);
void duckdb_init_set_init_data(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy);
idx_t duckdb_init_get_column_count(duckdb_init_info info);
idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index);
void duckdb_init_set_max_threads(duckdb_init_info info, idx_t max_threads);
void duckdb_init_set_error(duckdb_init_info info, const char *error);

Tabellenfunktion

void *duckdb_function_get_extra_info(duckdb_function_info info);
void *duckdb_function_get_bind_data(duckdb_function_info info);
void *duckdb_function_get_init_data(duckdb_function_info info);
void *duckdb_function_get_local_init_data(duckdb_function_info info);
void duckdb_function_set_error(duckdb_function_info info, const char *error);

Replacement Scans

void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback_t replacement, void *extra_data, duckdb_delete_callback_t delete_callback);
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);

Profiling-Informationen

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_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);

Appender

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);
duckdb_state duckdb_appender_create_query(duckdb_connection connection, const char *query, idx_t column_count, duckdb_logical_type *types, const char *table_name, const char **column_names, 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_error_data duckdb_appender_error_data(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_appender_begin_row(duckdb_appender appender);
duckdb_state duckdb_appender_end_row(duckdb_appender appender);
duckdb_state duckdb_append_default(duckdb_appender appender);
duckdb_state duckdb_append_default_to_chunk(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col, idx_t row);
duckdb_state duckdb_append_bool(duckdb_appender appender, bool value);
duckdb_state duckdb_append_int8(duckdb_appender appender, int8_t value);
duckdb_state duckdb_append_int16(duckdb_appender appender, int16_t value);
duckdb_state duckdb_append_int32(duckdb_appender appender, int32_t value);
duckdb_state duckdb_append_int64(duckdb_appender appender, int64_t value);
duckdb_state duckdb_append_hugeint(duckdb_appender appender, duckdb_hugeint value);
duckdb_state duckdb_append_uint8(duckdb_appender appender, uint8_t value);
duckdb_state duckdb_append_uint16(duckdb_appender appender, uint16_t value);
duckdb_state duckdb_append_uint32(duckdb_appender appender, uint32_t value);
duckdb_state duckdb_append_uint64(duckdb_appender appender, uint64_t value);
duckdb_state duckdb_append_uhugeint(duckdb_appender appender, duckdb_uhugeint value);
duckdb_state duckdb_append_float(duckdb_appender appender, float value);
duckdb_state duckdb_append_double(duckdb_appender appender, double value);
duckdb_state duckdb_append_date(duckdb_appender appender, duckdb_date value);
duckdb_state duckdb_append_time(duckdb_appender appender, duckdb_time value);
duckdb_state duckdb_append_timestamp(duckdb_appender appender, duckdb_timestamp value);
duckdb_state duckdb_append_interval(duckdb_appender appender, duckdb_interval value);
duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val);
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_value(duckdb_appender appender, duckdb_value value);
duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk);

Tabellenbeschreibung

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);

Arrow-Schnittstelle

duckdb_error_data duckdb_to_arrow_schema(duckdb_arrow_options arrow_options, duckdb_logical_type *types, const char **names, idx_t column_count, struct ArrowSchema *out_schema);
duckdb_error_data duckdb_data_chunk_to_arrow(duckdb_arrow_options arrow_options, duckdb_data_chunk chunk, struct ArrowArray *out_arrow_array);
duckdb_error_data duckdb_schema_from_arrow(duckdb_connection connection, struct ArrowSchema *schema, duckdb_arrow_converted_schema *out_types);
duckdb_error_data duckdb_data_chunk_from_arrow(duckdb_connection connection, struct ArrowArray *arrow_array, duckdb_arrow_converted_schema converted_schema, duckdb_data_chunk *out_chunk);
void duckdb_destroy_arrow_converted_schema(duckdb_arrow_converted_schema *arrow_converted_schema);
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);
void duckdb_result_arrow_array(duckdb_result result, duckdb_data_chunk chunk, duckdb_arrow_array *out_array);
duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *out_array);
idx_t duckdb_arrow_column_count(duckdb_arrow result);
idx_t duckdb_arrow_row_count(duckdb_arrow result);
idx_t duckdb_arrow_rows_changed(duckdb_arrow result);
const char *duckdb_query_arrow_error(duckdb_arrow result);
void duckdb_destroy_arrow(duckdb_arrow *result);
void duckdb_destroy_arrow_stream(duckdb_arrow_stream *stream_p);
duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement, duckdb_arrow *out_result);
duckdb_state duckdb_arrow_scan(duckdb_connection connection, const char *table_name, duckdb_arrow_stream arrow);
duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *table_name, duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array, duckdb_arrow_stream *out_stream);

Threading-Informationen

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);

Streaming-Ergebnis-Schnittstelle

duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result);
duckdb_data_chunk duckdb_fetch_chunk(duckdb_result result);

Cast-Funktionen

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);

Ausdrucksschnittstelle

void duckdb_destroy_expression(duckdb_expression *expr);
duckdb_logical_type duckdb_expression_return_type(duckdb_expression expr);
bool duckdb_expression_is_foldable(duckdb_expression expr);
duckdb_error_data duckdb_expression_fold(duckdb_client_context context, duckdb_expression expr, duckdb_value *out_value);

`duckdb_create_instance_cache`

Erzeugt einen neuen Datenbank-Instanz-Cache. Der Instanz-Cache ist erforderlich, wenn ein Client/Programm mehrere Datenbanken zur selben Datei im selben Prozess (erneut) öffnet. Muss mit ‘duckdb_destroy_instance_cache’ zerstört werden.

Rückgabewert

Der Datenbank-Instanz-Cache.

Syntax

duckdb_instance_cache duckdb_create_instance_cache(
  
);

`duckdb_get_or_create_from_cache`

Erzeugt eine neue Datenbankinstanz im Instanz-Cache oder ruft eine vorhandene Datenbankinstanz ab. Muss mit ‘duckdb_close’ geschlossen werden.

Syntax

duckdb_state duckdb_get_or_create_from_cache(
  duckdb_instance_cache instance_cache,
  const char *path,
  duckdb_database *out_database,
  duckdb_config config,
  char **out_error
);

Parameter

instance_cache: Der Instanzcache, in dem die Datenbank erzeugt oder aus dem sie geholt wird.
path: Pfad zur Datenbankdatei auf der Festplatte. Both nullptr and :memory: open or retrieve an in-memory database.
out_database: Die resultierende gecachte Datenbank.
config: (Optional) configuration used to create the database.
out_error: Falls gesetzt und die Funktion DuckDBError zurückgibt, enthält dies die Fehlermeldung. Note that the error message must be freed using duckdb_free.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_destroy_instance_cache`

Zerstört einen vorhandenen Datenbank-Instanz-Cache und gibt seinen Speicher frei.

Syntax

void duckdb_destroy_instance_cache(
  duckdb_instance_cache *instance_cache
);

Parameter

instance_cache: Der zu zerstörende Instanzcache.

`duckdb_open`

Erzeugt eine neue Datenbank oder öffnet eine vorhandene Datenbankdatei am angegebenen Pfad. Wenn kein Pfad angegeben ist, wird stattdessen eine neue In-Memory-Datenbank erzeugt. Die Datenbank muss mit ‘duckdb_close’ geschlossen werden.

Syntax

duckdb_state duckdb_open(
  const char *path,
  duckdb_database *out_database
);

Parameter

path: Pfad zur Datenbankdatei auf der Festplatte. Both nullptr and :memory: open an in-memory database.
out_database: Das resultierende Datenbankobjekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_open_ext`

Erweiterte Version von duckdb_open. Erzeugt eine neue Datenbank oder öffnet eine vorhandene Datenbankdatei am angegebenen Pfad. Die Datenbank muss mit ‘duckdb_close’ geschlossen werden.

Syntax

duckdb_state duckdb_open_ext(
  const char *path,
  duckdb_database *out_database,
  duckdb_config config,
  char **out_error
);

Parameter

path: Pfad zur Datenbankdatei auf der Festplatte. Both nullptr and :memory: open an in-memory database.
out_database: Das resultierende Datenbankobjekt.
config: (Optional) configuration used to start up the database.
out_error: Falls gesetzt und die Funktion DuckDBError zurückgibt, enthält dies die Fehlermeldung. Note that the error message must be freed using duckdb_free.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_close`

Schließt die angegebene Datenbank und gibt den gesamten dafür allokierten Speicher frei. Dies sollte aufgerufen werden, wenn Sie mit einer über duckdb_open oder duckdb_open_ext allokierten Datenbank fertig sind. Beachten Sie, dass das Unterlassen von duckdb_close (z. B. bei einem Programmabsturz) keine Datenkorruption verursacht. Dennoch wird empfohlen, ein Datenbankobjekt stets korrekt zu schließen, wenn Sie damit fertig sind.

Syntax

void duckdb_close(
  duckdb_database *database
);

Parameter

database: Das herunterzufahrende Datenbankobjekt.

`duckdb_connect`

Öffnet eine Verbindung zu einer Datenbank. Verbindungen sind erforderlich, um die Datenbank abzufragen, und speichern den transaktionalen Zustand der Verbindung. Die erzeugte Verbindung sollte mit ‘duckdb_disconnect’ geschlossen werden.

Syntax

duckdb_state duckdb_connect(
  duckdb_database database,
  duckdb_connection *out_connection
);

Parameter

database: Die Datenbankdatei, mit der verbunden wird.
out_connection: Das resultierende Verbindungsobjekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_interrupt`

Laufende Abfrage unterbrechen

Syntax

void duckdb_interrupt(
  duckdb_connection connection
);

Parameter

connection: Die zu unterbrechende Verbindung

`duckdb_query_progress`

Fortschritt der laufenden Abfrage abrufen

Syntax

duckdb_query_progress_type duckdb_query_progress(
  duckdb_connection connection
);

Parameter

connection: Die aktive Verbindung

Rückgabewert

-1, wenn kein Fortschritt vorliegt, sonst ein Prozentwert des Fortschritts

`duckdb_disconnect`

Schließt die angegebene Verbindung und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_disconnect(
  duckdb_connection *connection
);

Parameter

connection: Die zu schließende Verbindung.

`duckdb_connection_get_client_context`

Ruft den Client-Kontext der Verbindung ab.

Syntax

void duckdb_connection_get_client_context(
  duckdb_connection connection,
  duckdb_client_context *out_context
);

Parameter

connection: Die Verbindung.
out_context: Der Client-Kontext der Verbindung. Must be destroyed with duckdb_destroy_client_context.

`duckdb_connection_get_arrow_options`

Ruft die Arrow-Optionen der Verbindung ab.

Syntax

void duckdb_connection_get_arrow_options(
  duckdb_connection connection,
  duckdb_arrow_options *out_arrow_options
);

Parameter

connection: Die Verbindung.

`duckdb_client_context_get_connection_id`

Gibt die Verbindungs-ID des Client-Kontexts zurück.

Syntax

idx_t duckdb_client_context_get_connection_id(
  duckdb_client_context context
);

Parameter

context: Der Client-Kontext.

Rückgabewert

Die Verbindungs-ID des Client-Kontexts.

`duckdb_destroy_client_context`

Zerstört den Client-Kontext und gibt seinen Speicher frei.

Syntax

void duckdb_destroy_client_context(
  duckdb_client_context *context
);

Parameter

context: Der zu zerstörende Client-Kontext.

`duckdb_destroy_arrow_options`

Zerstört die Arrow-Optionen und gibt ihren Speicher frei.

Syntax

void duckdb_destroy_arrow_options(
  duckdb_arrow_options *arrow_options
);

Parameter

arrow_options: Die zu zerstörenden Arrow-Optionen.

`duckdb_library_version`

Gibt die Version der eingebundenen DuckDB zurück, mit einem Versionspostfix für Entwicklungsversionen

Wird üblicherweise für die Entwicklung von C-Erweiterungen verwendet, die dies für eine Kompatibilitätsprüfung zurückgeben müssen.

Syntax

const char *duckdb_library_version(
  
);

`duckdb_get_table_names`

Gibt die Liste der (vollständig qualifizierten) Tabellennamen der Abfrage zurück.

Syntax

duckdb_value duckdb_get_table_names(
  duckdb_connection connection,
  const char *query,
  bool qualified
);

Parameter

connection: Die Verbindung, für die die Tabellennamen ermittelt werden.
query: Die Abfrage, für die die Tabellennamen ermittelt werden.
qualified: Gibt vollständig qualifizierte Tabellennamen (catalog.schema.table), if set to true, else only the (not escaped) table names.

Rückgabewert

Ein duckdb_value vom Typ VARCHAR[] mit den (vollständig qualifizierten) Tabellennamen der Abfrage. Muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_config`

Initialisiert ein leeres Konfigurationsobjekt, das Startoptionen für die DuckDB-Instanz über duckdb_open_ext bereitstellt. Das duckdb_config muss mit ‘duckdb_destroy_config’ zerstört werden

Dies gelingt immer, sofern kein malloc-Fehler auftritt.

Beachten Sie, dass duckdb_destroy_config immer für die resultierende Konfiguration aufgerufen werden sollte, auch wenn die Funktion DuckDBError zurückgibt.

Syntax

duckdb_state duckdb_create_config(
  duckdb_config *out_config
);

Parameter

out_config: Das resultierende Konfigurationsobjekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_config_count`

Gibt die Gesamtzahl der Konfigurationsoptionen zurück, die mit duckdb_get_config_flag verwendet werden können.

Dies sollte nicht in einer Schleife aufgerufen werden, da intern über alle Optionen iteriert wird.

Rückgabewert

Die Anzahl der verfügbaren Konfigurationsoptionen.

Syntax

size_t duckdb_config_count(
  
);

`duckdb_get_config_flag`

Ermittelt einen menschenlesbaren Namen und eine Beschreibung einer bestimmten Konfigurationsoption. Dies kann z. B. verwendet werden, um Konfigurationsoptionen anzuzeigen. Dies gelingt, sofern index nicht außerhalb des Bereichs liegt (d. h. >= duckdb_config_count).

Der Ergebnisname oder die Beschreibung darf NICHT freigegeben werden.

Syntax

duckdb_state duckdb_get_config_flag(
  size_t index,
  const char **out_name,
  const char **out_description
);

Parameter

index: Der Index der Konfigurationsoption (zwischen 0 und duckdb_config_count)
out_name: Ein Name des Konfigurationsflags.
out_description: Eine Beschreibung des Konfigurationsflags.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_set_config`

Setzt die angegebene Option für die angegebene Konfiguration. Die Konfigurationsoption wird über den Namen angegeben. Eine Liste der Konfigurationsoptionen finden Sie unter duckdb_get_config_flag.

Im Quellcode sind Konfigurationsoptionen in config.cpp definiert.

Dies kann fehlschlagen, wenn der Name ungültig ist oder der für die Option angegebene Wert ungültig ist.

Syntax

duckdb_state duckdb_set_config(
  duckdb_config config,
  const char *name,
  const char *option
);

Parameter

config: Das Konfigurationsobjekt, für das die Option gesetzt wird.
name: Der Name des zu setzenden Konfigurationsflags.
option: Der Wert, auf den das Konfigurationsflag gesetzt wird.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_destroy_config`

Zerstört das angegebene Konfigurationsobjekt und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_destroy_config(
  duckdb_config *config
);

Parameter

config: Das zu zerstörende Konfigurationsobjekt.

`duckdb_create_error_data`

Erzeugt duckdb_error_data. Muss mit duckdb_destroy_error_data zerstört werden.

Syntax

duckdb_error_data duckdb_create_error_data(
  duckdb_error_type type,
  const char *message
);

Parameter

type: Der Fehlertyp.
message: Die Fehlermeldung.

Rückgabewert

Die Fehlerdaten.

`duckdb_destroy_error_data`

Zerstört die Fehlerdaten und gibt ihren Speicher frei.

Syntax

void duckdb_destroy_error_data(
  duckdb_error_data *error_data
);

Parameter

error_data: Die zu zerstörenden Fehlerdaten.

`duckdb_error_data_error_type`

Gibt den duckdb_error_type der Fehlerdaten zurück.

Syntax

duckdb_error_type duckdb_error_data_error_type(
  duckdb_error_data error_data
);

Parameter

error_data: Die Fehlerdaten.

Rückgabewert

Der Fehlertyp.

`duckdb_error_data_message`

Gibt die Fehlermeldung der Fehlerdaten zurück. Darf nicht freigegeben werden.

Syntax

const char *duckdb_error_data_message(
  duckdb_error_data error_data
);

Parameter

error_data: Die Fehlerdaten.

Rückgabewert

Die Fehlermeldung.

`duckdb_error_data_has_error`

Gibt zurück, ob die Fehlerdaten einen Fehler enthalten.

Syntax

bool duckdb_error_data_has_error(
  duckdb_error_data error_data
);

Parameter

error_data: Die Fehlerdaten.

Rückgabewert

True, wenn die Fehlerdaten eine Exception enthalten, sonst false.

`duckdb_query`

Führt eine SQL-Abfrage in einer Verbindung aus und speichert das vollständige (materialisierte) Ergebnis im Zeiger out_result. Wenn die Abfrage fehlschlägt, wird DuckDBError zurückgegeben, und die Fehlermeldung kann durch Aufruf von duckdb_result_error abgerufen werden.

Beachten Sie, dass nach duckdb_query duckdb_destroy_result für das Ergebnisobjekt aufgerufen werden muss, auch wenn die Abfrage fehlschlägt, andernfalls wird der im Ergebnis gespeicherte Fehler nicht korrekt freigegeben.

Syntax

duckdb_state duckdb_query(
  duckdb_connection connection,
  const char *query,
  duckdb_result *out_result
);

Parameter

connection: Die Verbindung, in der die Abfrage ausgeführt wird.
query: Die auszuführende SQL-Abfrage.
out_result: Das Abfrageergebnis.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_destroy_result`

Schließt das Ergebnis und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_destroy_result(
  duckdb_result *result
);

Parameter

result: Das zu zerstörende Ergebnis.

`duckdb_column_name`

Gibt den Spaltennamen der angegebenen Spalte zurück. Das Ergebnis muss nicht freigegeben werden; die Spaltennamen werden automatisch zerstört, wenn das Ergebnis zerstört wird.

Gibt NULL zurück, wenn die Spalte außerhalb des Bereichs liegt.

Syntax

const char *duckdb_column_name(
  duckdb_result *result,
  idx_t col
);

Parameter

result: Das Ergebnisobjekt, von dem der Spaltenname geholt wird.
col: Der Spaltenindex.

Rückgabewert

Der Spaltenname der angegebenen Spalte.

`duckdb_column_type`

Gibt den Spaltentyp der angegebenen Spalte zurück.

Gibt DUCKDB_TYPE_INVALID zurück, wenn die Spalte außerhalb des Bereichs liegt.

Syntax

duckdb_type duckdb_column_type(
  duckdb_result *result,
  idx_t col
);

Parameter

result: Das Ergebnisobjekt, von dem der Spaltentyp geholt wird.
col: Der Spaltenindex.

Rückgabewert

Der Spaltentyp der angegebenen Spalte.

`duckdb_result_statement_type`

Gibt den Anweisungstyp der ausgeführten Anweisung zurück

Syntax

duckdb_statement_type duckdb_result_statement_type(
  duckdb_result result
);

Parameter

result: Das Ergebnisobjekt, von dem der Statement-Typ geholt wird.

Rückgabewert

duckdb_statement_type-Wert oder DUCKDB_STATEMENT_TYPE_INVALID

`duckdb_column_logical_type`

Gibt den logischen Spaltentyp der angegebenen Spalte zurück.

Der Rückgabetyp dieses Aufrufs sollte mit duckdb_destroy_logical_type zerstört werden.

Gibt NULL zurück, wenn die Spalte außerhalb des Bereichs liegt.

Syntax

duckdb_logical_type duckdb_column_logical_type(
  duckdb_result *result,
  idx_t col
);

Parameter

result: Das Ergebnisobjekt, von dem der Spaltentyp geholt wird.
col: Der Spaltenindex.

Rückgabewert

Der logische Spaltentyp der angegebenen Spalte.

`duckdb_result_get_arrow_options`

Gibt die dem angegebenen Ergebnis zugeordneten Arrow-Optionen zurück. Diese Optionen definieren, wie die Arrow-Arrays/das Schema erzeugt werden sollen.

Syntax

duckdb_arrow_options duckdb_result_get_arrow_options(
  duckdb_result *result
);

Parameter

result: Das Ergebnisobjekt, von dem die Arrow-Optionen geholt werden.

Rückgabewert

Die dem angegebenen Ergebnis zugeordneten Arrow-Optionen. Diese müssen mit duckdb_destroy_arrow_options zerstört werden.

`duckdb_column_count`

Gibt die Anzahl der Spalten im Ergebnisobjekt zurück.

Syntax

idx_t duckdb_column_count(
  duckdb_result *result
);

Parameter

result: Das Ergebnisobjekt.

Rückgabewert

Die Anzahl der Spalten im Ergebnisobjekt.

`duckdb_row_count`

Gibt die Anzahl der Zeilen im Ergebnisobjekt zurück.

Syntax

idx_t duckdb_row_count(
  duckdb_result *result
);

Parameter

result: Das Ergebnisobjekt.

Rückgabewert

Die Anzahl der Zeilen im Ergebnisobjekt.

`duckdb_rows_changed`

Gibt die Anzahl der von der im Ergebnis gespeicherten Abfrage geänderten Zeilen zurück. Dies ist nur für INSERT/UPDATE/DELETE- Abfragen relevant. Bei anderen Abfragen ist rows_changed 0.

Syntax

idx_t duckdb_rows_changed(
  duckdb_result *result
);

Parameter

result: Das Ergebnisobjekt.

Rückgabewert

Die Anzahl der geänderten Zeilen.

`duckdb_column_data`

Gibt die Daten einer bestimmten Spalte eines Ergebnisses im spaltenorientierten Format zurück.

Die Funktion gibt ein dichtes Array mit den Ergebnisdaten zurück. Der genaue im Array gespeicherte Typ hängt vom entsprechenden duckdb_type ab (bereitgestellt von duckdb_column_type). Den genauen Typ für den Zugriff auf die Daten finden Sie in den Kommentaren im Abschnitt Typen oder in der Enum DUCKDB_TYPE.

For example, for a column of type DUCKDB_TYPE_INTEGER, rows can be accessed in the following manner:

int32_t *data = (int32_t *) duckdb_column_data(&result, 0);
printf("Data for row %d: %d\n", row, data[row]);

Syntax

void *duckdb_column_data(
  duckdb_result *result,
  idx_t col
);

Parameter

result: Das Ergebnisobjekt, von dem die Spaltendaten geholt werden.
col: Der Spaltenindex.

Rückgabewert

Die Spaltendaten der angegebenen Spalte.

`duckdb_nullmask_data`

Gibt die Nullmaske einer bestimmten Spalte eines Ergebnisses im spaltenorientierten Format zurück. Die Nullmaske gibt für jede Zeile an, ob die entsprechende Zeile NULL ist. Wenn eine Zeile NULL ist, sind die Werte im von duckdb_column_data bereitgestellten Array undefiniert.

int32_t *data = (int32_t *) duckdb_column_data(&result, 0);
bool *nullmask = duckdb_nullmask_data(&result, 0);
if (nullmask[row]) {
    printf("Data for row %d: NULL\n", row);
} else {
    printf("Data for row %d: %d\n", row, data[row]);
}

Syntax

bool *duckdb_nullmask_data(
  duckdb_result *result,
  idx_t col
);

Parameter

result: Das Ergebnisobjekt, von dem die Nullmask geholt wird.
col: Der Spaltenindex.

Rückgabewert

Die Nullmaske der angegebenen Spalte.

`duckdb_result_error`

Gibt die im Ergebnis enthaltene Fehlermeldung zurück. Der Fehler ist nur gesetzt, wenn duckdb_query DuckDBError zurückgibt.

Das Ergebnis dieser Funktion darf nicht freigegeben werden. Es wird bereinigt, wenn duckdb_destroy_result aufgerufen wird.

Syntax

const char *duckdb_result_error(
  duckdb_result *result
);

Parameter

result: Das Ergebnisobjekt, von dem der Fehler geholt wird.

Rückgabewert

Der Fehler des Ergebnisses.

`duckdb_result_error_type`

Gibt den im Ergebnis enthaltenen Ergebnisfehlertyp zurück. Der Fehler ist nur gesetzt, wenn duckdb_query DuckDBError zurückgibt.

Syntax

duckdb_error_type duckdb_result_error_type(
  duckdb_result *result
);

Parameter

result: Das Ergebnisobjekt, von dem der Fehler geholt wird.

Rückgabewert

Der Fehlertyp des Ergebnisses.

`duckdb_result_get_chunk`

Holt einen Data-Chunk aus dem duckdb_result. Diese Funktion sollte wiederholt aufgerufen werden, bis das Ergebnis erschöpft ist.

Das Ergebnis muss mit duckdb_destroy_data_chunk zerstört werden.

Diese Funktion ersetzt alle duckdb_value-Funktionen sowie die Funktionen duckdb_column_data und duckdb_nullmask_data. Sie führt zu deutlich besserer Leistung und sollte in neueren Codebasen bevorzugt werden.

Wenn diese Funktion verwendet wird, können keine der anderen Ergebnisfunktionen verwendet werden und umgekehrt (d. h., diese Funktion kann nicht mit den Legacy-Ergebnisfunktionen gemischt werden).

Verwenden Sie duckdb_result_chunk_count, um festzustellen, wie viele Chunks das Ergebnis enthält.

Syntax

duckdb_data_chunk duckdb_result_get_chunk(
  duckdb_result result,
  idx_t chunk_index
);

Parameter

result: Das Ergebnisobjekt, von dem der Data Chunk geholt wird.
chunk_index: Der Chunk-Index, von dem geholt wird.

Rückgabewert

Der resultierende Data-Chunk. Gibt NULL zurück, wenn der Chunk-Index außerhalb des Bereichs liegt.

`duckdb_result_is_streaming`

Prüft, ob der Typ des internen Ergebnisses StreamQueryErgebnis ist.

Syntax

bool duckdb_result_is_streaming(
  duckdb_result result
);

Parameter

result: Das zu prüfende Ergebnisobjekt.

Rückgabewert

Ob das Ergebnisobjekt vom Typ StreamQueryErgebnis ist

`duckdb_result_chunk_count`

Gibt die Anzahl der Data-Chunks im Ergebnis zurück.

Syntax

idx_t duckdb_result_chunk_count(
  duckdb_result result
);

Parameter

result: Das Ergebnisobjekt

Rückgabewert

Anzahl der Data-Chunks im Ergebnis.

`duckdb_result_return_type`

Gibt den return_type des angegebenen Ergebnisses zurück oder DUCKDB_RETURN_TYPE_INVALID bei Fehler

Syntax

duckdb_result_type duckdb_result_return_type(
  duckdb_result result
);

Parameter

result: Das Ergebnisobjekt

Rückgabewert

Der return_type

`duckdb_value_boolean`

Rückgabewert

Der Boolean-Wert an der angegebenen Position oder false, wenn der Wert nicht konvertiert werden kann.

Syntax

bool duckdb_value_boolean(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_int8`

Rückgabewert

Der int8_t-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

int8_t duckdb_value_int8(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_int16`

Rückgabewert

Der int16_t-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

int16_t duckdb_value_int16(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_int32`

Rückgabewert

Der int32_t-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

int32_t duckdb_value_int32(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_int64`

Rückgabewert

Der int64_t-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

int64_t duckdb_value_int64(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_hugeint`

Rückgabewert

Der duckdb_hugeint-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

duckdb_hugeint duckdb_value_hugeint(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_uhugeint`

Rückgabewert

Der duckdb_uhugeint-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

duckdb_uhugeint duckdb_value_uhugeint(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_decimal`

Rückgabewert

Der duckdb_decimal-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

duckdb_decimal duckdb_value_decimal(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_uint8`

Rückgabewert

Der uint8_t-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

uint8_t duckdb_value_uint8(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_uint16`

Rückgabewert

Der uint16_t-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

uint16_t duckdb_value_uint16(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_uint32`

Rückgabewert

Der uint32_t-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

uint32_t duckdb_value_uint32(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_uint64`

Rückgabewert

Der uint64_t-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

uint64_t duckdb_value_uint64(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_float`

Rückgabewert

Der Float-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

float duckdb_value_float(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_double`

Rückgabewert

Der Double-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

double duckdb_value_double(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_date`

Rückgabewert

Der duckdb_date-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

duckdb_date duckdb_value_date(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_time`

Rückgabewert

Der duckdb_time-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

duckdb_time duckdb_value_time(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_timestamp`

Rückgabewert

Der duckdb_timestamp-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

duckdb_timestamp duckdb_value_timestamp(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_interval`

Rückgabewert

Der duckdb_interval-Wert an der angegebenen Position oder 0, wenn der Wert nicht konvertiert werden kann.

Syntax

duckdb_interval duckdb_value_interval(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_varchar`

Rückgabewert

Der Textwert an der angegebenen Position als nullterminierter String oder nullptr, wenn der Wert nicht konvertiert werden kann. Das Ergebnis muss mit duckdb_free freigegeben werden.

Syntax

char *duckdb_value_varchar(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_string`

Keine Unterstützung für verschachtelte Typen und andere komplexe Typen. Das resultierende Feld “string.data” muss mit duckdb_free. freigegeben werden.

Rückgabewert

Der Stringwert an der angegebenen Position. Versucht, den Ergebniswert in einen String zu casten.

Syntax

duckdb_string duckdb_value_string(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_varchar_internal`

Rückgabewert

Der char*-Wert an der angegebenen Position. Funktioniert NUR mit VARCHAR-Spalten und führt keinen Auto-Cast durch. Wenn die Spalte KEINE VARCHAR-Spalte ist, gibt diese Funktion NULL zurück.

Das Ergebnis darf NICHT freigegeben werden.

Syntax

char *duckdb_value_varchar_internal(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_string_internal`

Rückgabewert

Der char*-Wert an der angegebenen Position. Funktioniert NUR mit VARCHAR-Spalten und führt keinen Auto-Cast durch. Wenn die Spalte KEINE VARCHAR-Spalte ist, gibt diese Funktion NULL zurück.

Das Ergebnis darf NICHT freigegeben werden.

Syntax

duckdb_string duckdb_value_string_internal(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_blob`

Rückgabewert

Der duckdb_blob-Wert an der angegebenen Position. Gibt einen Blob mit blob.data auf nullptr zurück, wenn der Wert nicht konvertiert werden kann. Das resultierende Feld “blob.data” muss mit duckdb_free. freigegeben werden.

Syntax

duckdb_blob duckdb_value_blob(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_value_is_null`

Rückgabewert

Gibt true zurück, wenn der Wert am angegebenen Index NULL ist, sonst false.

Syntax

bool duckdb_value_is_null(
  duckdb_result *result,
  idx_t col,
  idx_t row
);

`duckdb_malloc`

Allokiert size Bytes Speicher mit der internen malloc-Funktion von DuckDB. Jeder auf diese Weise allokierte Speicher sollte mit duckdb_free freigegeben werden.

Syntax

void *duckdb_malloc(
  size_t size
);

Parameter

size: Die Anzahl der zu allokierenden Bytes.

Rückgabewert

Ein Zeiger auf den allokierten Speicherbereich.

`duckdb_free`

Gibt einen Wert frei, der von duckdb_malloc, duckdb_value_varchar, duckdb_value_blob oder duckdb_value_string zurückgegeben wurde.

Syntax

void duckdb_free(
  void *ptr
);

Parameter

ptr: Der freizugebende Speicherbereich.

`duckdb_vector_size`

Die von DuckDB verwendete interne Vektorgröße. Das ist die Anzahl der Tupel, die in einen mit duckdb_create_data_chunk erzeugten Data-Chunk passen.

Rückgabewert

Die Vektorgröße.

Syntax

idx_t duckdb_vector_size(
  
);

`duckdb_string_is_inlined`

Ob der duckdb_string_t-Wert inline gespeichert ist. Das bedeutet, dass die Stringdaten keine separate Allokation haben.

Syntax

bool duckdb_string_is_inlined(
  duckdb_string_t string
);

`duckdb_string_t_length`

Ermittelt die Stringlänge eines string_t

Syntax

uint32_t duckdb_string_t_length(
  duckdb_string_t string
);

Parameter

string: Die Zeichenkette, deren Länge ermittelt wird.

Rückgabewert

Die Länge.

`duckdb_string_t_data`

Gibt einen Zeiger auf die Stringdaten eines string_t zurück

Syntax

const char *duckdb_string_t_data(
  duckdb_string_t *string
);

Parameter

string: Die Zeichenkette, deren Zeiger ermittelt wird.

Rückgabewert

Der Zeiger.

`duckdb_from_date`

Zerlegt ein duckdb_date-Objekt in Jahr, Monat und Tag (gespeichert als duckdb_date_struct).

Syntax

duckdb_date_struct duckdb_from_date(
  duckdb_date date
);

Parameter

date: Das Datumsobjekt, wie aus einer DUCKDB_TYPE_DATE-Spalte erhalten.

Rückgabewert

Die duckdb_date_struct mit den zerlegten Elementen.

`duckdb_to_date`

Setzt ein duckdb_date aus Jahr, Monat und Tag (duckdb_date_struct) wieder zusammen.

Syntax

duckdb_date duckdb_to_date(
  duckdb_date_struct date
);

Parameter

date: Jahr, Monat und Tag, gespeichert in einem duckdb_date_struct.

Rückgabewert

Das duckdb_date-Element.

`duckdb_is_finite_date`

Prüft, ob ein duckdb_date ein endlicher Wert ist.

Syntax

bool duckdb_is_finite_date(
  duckdb_date date
);

Parameter

date: Das Datumsobjekt, wie aus einer DUCKDB_TYPE_DATE-Spalte erhalten.

Rückgabewert

True, wenn das Datum endlich ist, false bei ±infinity.

`duckdb_from_time`

Zerlegt ein duckdb_time-Objekt in Stunde, Minute, Sekunde und Mikrosekunde (gespeichert als duckdb_time_struct).

Syntax

duckdb_time_struct duckdb_from_time(
  duckdb_time time
);

Parameter

time: Das Zeitobjekt, wie aus einer DUCKDB_TYPE_TIME-Spalte erhalten.

Rückgabewert

Die duckdb_time_struct mit den zerlegten Elementen.

`duckdb_create_time_tz`

Erzeugt ein duckdb_time_tz-Objekt aus Mikrosekunden und einem Zeitzonenoffset.

Syntax

duckdb_time_tz duckdb_create_time_tz(
  int64_t micros,
  int32_t offset
);

Parameter

micros: Die Mikrosekunden-Komponente der Zeit.
offset: Die Zeitzonen-Offset-Komponente der Zeit.

Rückgabewert

Das duckdb_time_tz-Element.

`duckdb_from_time_tz`

Zerlegt ein TIME_TZ-Objekt in Mikrosekunden und einen Zeitzonenoffset.

Verwenden Sie duckdb_from_time, um die Mikrosekunden weiter in Stunde, Minute, Sekunde und Mikrosekunde zu zerlegen.

Syntax

duckdb_time_tz_struct duckdb_from_time_tz(
  duckdb_time_tz micros
);

Parameter

micros: Das Zeitobjekt, wie aus einer DUCKDB_TYPE_TIME_TZ-Spalte erhalten.

`duckdb_to_time`

Setzt ein duckdb_time aus Stunde, Minute, Sekunde und Mikrosekunde (duckdb_time_struct) wieder zusammen.

Syntax

duckdb_time duckdb_to_time(
  duckdb_time_struct time
);

Parameter

time: Stunde, Minute, Sekunde und Mikrosekunde in einem duckdb_time_struct.

Rückgabewert

Das duckdb_time-Element.

`duckdb_from_timestamp`

Zerlegt ein duckdb_timestamp-Objekt in eine duckdb_timestamp_struct.

Syntax

duckdb_timestamp_struct duckdb_from_timestamp(
  duckdb_timestamp ts
);

Parameter

ts: Das ts-Objekt, wie aus einer DUCKDB_TYPE_TIMESTAMP-Spalte erhalten.

Rückgabewert

Die duckdb_timestamp_struct mit den zerlegten Elementen.

`duckdb_to_timestamp`

Setzt einen duckdb_timestamp aus einer duckdb_timestamp_struct wieder zusammen.

Syntax

duckdb_timestamp duckdb_to_timestamp(
  duckdb_timestamp_struct ts
);

Parameter

ts: Die zerlegten Elemente in einem duckdb_timestamp_struct.

Rückgabewert

Das duckdb_timestamp-Element.

`duckdb_is_finite_timestamp`

Prüft, ob ein duckdb_timestamp ein endlicher Wert ist.

Syntax

bool duckdb_is_finite_timestamp(
  duckdb_timestamp ts
);

Parameter

ts: Das duckdb_timestamp-Objekt, wie aus einer DUCKDB_TYPE_TIMESTAMP-Spalte erhalten.

Rückgabewert

True, wenn der Timestamp endlich ist, false bei ±infinity.

`duckdb_is_finite_timestamp_s`

Prüft, ob ein duckdb_timestamp_s ein endlicher Wert ist.

Syntax

bool duckdb_is_finite_timestamp_s(
  duckdb_timestamp_s ts
);

Parameter

ts: Das duckdb_timestamp_s-Objekt, wie aus einer DUCKDB_TYPE_TIMESTAMP_S-Spalte erhalten.

Rückgabewert

True, wenn der Timestamp endlich ist, false bei ±infinity.

`duckdb_is_finite_timestamp_ms`

Prüft, ob ein duckdb_timestamp_ms ein endlicher Wert ist.

Syntax

bool duckdb_is_finite_timestamp_ms(
  duckdb_timestamp_ms ts
);

Parameter

ts: Das duckdb_timestamp_ms-Objekt, wie aus einer DUCKDB_TYPE_TIMESTAMP_MS-Spalte erhalten.

Rückgabewert

True, wenn der Timestamp endlich ist, false bei ±infinity.

`duckdb_is_finite_timestamp_ns`

Prüft, ob ein duckdb_timestamp_ns ein endlicher Wert ist.

Syntax

bool duckdb_is_finite_timestamp_ns(
  duckdb_timestamp_ns ts
);

Parameter

ts: Das duckdb_timestamp_ns-Objekt, wie aus einer DUCKDB_TYPE_TIMESTAMP_NS-Spalte erhalten.

Rückgabewert

True, wenn der Timestamp endlich ist, false bei ±infinity.

`duckdb_hugeint_to_double`

Konvertiert ein duckdb_hugeint-Objekt (aus einer DUCKDB_TYPE_HUGEINT-Spalte) in ein Double.

Syntax

double duckdb_hugeint_to_double(
  duckdb_hugeint val
);

Parameter

val: Der Hugeint-Wert.

Rückgabewert

Das konvertierte double-Element.

`duckdb_double_to_hugeint`

Konvertiert einen Double-Wert in ein duckdb_hugeint-Objekt.

Wenn die Konvertierung fehlschlägt, weil der Double-Wert zu groß ist, ist das Ergebnis 0.

Syntax

duckdb_hugeint duckdb_double_to_hugeint(
  double val
);

Parameter

val: Der Double-Wert.

Rückgabewert

Das konvertierte duckdb_hugeint-Element.

`duckdb_uhugeint_to_double`

Konvertiert ein duckdb_uhugeint-Objekt (aus einer DUCKDB_TYPE_UHUGEINT-Spalte) in ein Double.

Syntax

double duckdb_uhugeint_to_double(
  duckdb_uhugeint val
);

Parameter

val: Der Uhugeint-Wert.

Rückgabewert

Das konvertierte double-Element.

`duckdb_double_to_uhugeint`

Konvertiert einen Double-Wert in ein duckdb_uhugeint-Objekt.

Wenn die Konvertierung fehlschlägt, weil der Double-Wert zu groß ist, ist das Ergebnis 0.

Syntax

duckdb_uhugeint duckdb_double_to_uhugeint(
  double val
);

Parameter

val: Der Double-Wert.

Rückgabewert

Das konvertierte duckdb_uhugeint-Element.

`duckdb_double_to_decimal`

Konvertiert einen Double-Wert in ein duckdb_decimal-Objekt.

Wenn die Konvertierung fehlschlägt, weil der Double-Wert zu groß ist oder Breite/Nachkommastellen ungültig sind, ist das Ergebnis 0.

Syntax

duckdb_decimal duckdb_double_to_decimal(
  double val,
  uint8_t width,
  uint8_t scale
);

Parameter

val: Der Double-Wert.

Rückgabewert

Das konvertierte duckdb_decimal-Element.

`duckdb_decimal_to_double`

Konvertiert ein duckdb_decimal-Objekt (aus einer DUCKDB_TYPE_DECIMAL-Spalte) in ein Double.

Syntax

double duckdb_decimal_to_double(
  duckdb_decimal val
);

Parameter

val: Der Decimal-Wert.

Rückgabewert

Das konvertierte double-Element.

`duckdb_prepare`

Erzeugt ein Prepared-Statement-Objekt aus einer Abfrage.

Beachten Sie, dass das Prepared Statement nach dem Aufruf von duckdb_prepare immer mit duckdb_destroy_prepare zerstört werden sollte, auch wenn das Vorbereiten fehlschlägt.

Wenn das Vorbereiten fehlschlägt, kann duckdb_prepare_error aufgerufen werden, um den Grund zu ermitteln.

Syntax

duckdb_state duckdb_prepare(
  duckdb_connection connection,
  const char *query,
  duckdb_prepared_statement *out_prepared_statement
);

Parameter

connection: Das Verbindungsobjekt
query: Die vorzubereitende SQL-Abfrage
out_prepared_statement: Das resultierende Prepared-Statement-Objekt

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_destroy_prepare`

Schließt das Prepared Statement und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_destroy_prepare(
  duckdb_prepared_statement *prepared_statement
);

Parameter

prepared_statement: Das zu zerstörende Prepared Statement.

`duckdb_prepare_error`

Gibt die dem angegebenen Prepared Statement zugeordnete Fehlermeldung zurück. Wenn das Prepared Statement keine Fehlermeldung hat, wird stattdessen nullptr zurückgegeben.

Die Fehlermeldung sollte nicht freigegeben werden. Sie wird freigegeben, wenn duckdb_destroy_prepare aufgerufen wird.

Syntax

const char *duckdb_prepare_error(
  duckdb_prepared_statement prepared_statement
);

Parameter

prepared_statement: Das Prepared Statement, von dem der Fehler ermittelt wird.

Rückgabewert

Die Fehlermeldung oder nullptr, wenn keine vorhanden ist.

`duckdb_nparams`

Gibt die Anzahl der Parameter zurück, die dem angegebenen Prepared Statement übergeben werden können.

Gibt 0 zurück, wenn die Abfrage nicht erfolgreich vorbereitet wurde.

Syntax

idx_t duckdb_nparams(
  duckdb_prepared_statement prepared_statement
);

Parameter

prepared_statement: Das Prepared Statement, für das die Anzahl der Parameter ermittelt wird.

`duckdb_parameter_name`

Gibt den Namen zurück, mit dem der Parameter identifiziert wird. Der zurückgegebene String sollte mit duckdb_free freigegeben werden.

Gibt NULL zurück, wenn der Index für das angegebene Prepared Statement außerhalb des Bereichs liegt.

Syntax

const char *duckdb_parameter_name(
  duckdb_prepared_statement prepared_statement,
  idx_t index
);

Parameter

prepared_statement: Das Prepared Statement, von dem der Parametername ermittelt wird.

`duckdb_param_type`

Gibt den Parametertyp des Parameter am angegebenen Index zurück.

Gibt DUCKDB_TYPE_INVALID zurück, wenn der Parameterindex außerhalb des Bereichs liegt oder die Anweisung nicht erfolgreich vorbereitet wurde.

Syntax

duckdb_type duckdb_param_type(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx
);

Parameter

prepared_statement: Das Prepared Statement.
param_idx: Der Parameterindex.

Rückgabewert

Der Parametertyp

`duckdb_param_logical_type`

Gibt den logischen Typ des Parameter am angegebenen Index zurück.

Gibt nullptr zurück, wenn der Parameterindex außerhalb des Bereichs liegt oder die Anweisung nicht erfolgreich vorbereitet wurde.

Der Rückgabetyp dieses Aufrufs sollte mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_param_logical_type(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx
);

Parameter

prepared_statement: Das Prepared Statement.
param_idx: Der Parameterindex.

Rückgabewert

Der logische Typ des Parameter

`duckdb_clear_bindings`

Löscht die an das Prepared Statement gebundenen Parameter.

Syntax

duckdb_state duckdb_clear_bindings(
  duckdb_prepared_statement prepared_statement
);

`duckdb_prepared_statement_type`

Gibt den Anweisungstyp der auszuführenden Anweisung zurück

Syntax

duckdb_statement_type duckdb_prepared_statement_type(
  duckdb_prepared_statement statement
);

Parameter

statement: Das Prepared Statement.

Rückgabewert

duckdb_statement_type-Wert oder DUCKDB_STATEMENT_TYPE_INVALID

`duckdb_prepared_statement_column_count`

Gibt die Anzahl der Spalten im Ergebnis des Prepared Statements zurück. Wenn einer der Spaltentypen ungültig ist, ist das Ergebnis 1.

Syntax

idx_t duckdb_prepared_statement_column_count(
  duckdb_prepared_statement prepared_statement
);

Parameter

prepared_statement: Das Prepared Statement.

Rückgabewert

Die Anzahl der Spalten im Ergebnis des Prepared Statements.

`duckdb_prepared_statement_column_name`

Gibt den Namen der angegebenen Spalte im Ergebnis des prepared_statement zurück. Der zurückgegebene String sollte mit duckdb_free freigegeben werden.

Gibt nullptr zurück, wenn die Spalte außerhalb des Bereichs liegt.

Syntax

const char *duckdb_prepared_statement_column_name(
  duckdb_prepared_statement prepared_statement,
  idx_t col_idx
);

Parameter

prepared_statement: Das Prepared Statement.
col_idx: Der Spaltenindex.

Rückgabewert

Der Spaltenname der angegebenen Spalte.

`duckdb_prepared_statement_column_logical_type`

Gibt den Spaltentyp der angegebenen Spalte im Ergebnis des prepared_statement zurück.

Gibt DUCKDB_TYPE_INVALID zurück, wenn die Spalte außerhalb des Bereichs liegt. Der Rückgabetyp dieses Aufrufs sollte mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_prepared_statement_column_logical_type(
  duckdb_prepared_statement prepared_statement,
  idx_t col_idx
);

Parameter

prepared_statement: Das Prepared Statement, von dem der Spaltentyp geholt wird.
col_idx: Der Spaltenindex.

Rückgabewert

Der logische Typ der angegebenen Spalte.

`duckdb_prepared_statement_column_type`

Gibt den Spaltentyp der angegebenen Spalte im Ergebnis des prepared_statement zurück.

Gibt DUCKDB_TYPE_INVALID zurück, wenn die Spalte außerhalb des Bereichs liegt.

Syntax

duckdb_type duckdb_prepared_statement_column_type(
  duckdb_prepared_statement prepared_statement,
  idx_t col_idx
);

Parameter

prepared_statement: Das Prepared Statement, von dem der Spaltentyp geholt wird.
col_idx: Der Spaltenindex.

Rückgabewert

Der Typ der angegebenen Spalte.

`duckdb_bind_value`

Bindet einen Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_value(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_value val
);

`duckdb_bind_parameter_index`

Ruft den Index des Parameter für das Prepared Statement ab, identifiziert über den Namen

Syntax

duckdb_state duckdb_bind_parameter_index(
  duckdb_prepared_statement prepared_statement,
  idx_t *param_idx_out,
  const char *name
);

`duckdb_bind_boolean`

Bindet einen Bool-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_boolean(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  bool val
);

`duckdb_bind_int8`

Bindet einen int8_t-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_int8(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  int8_t val
);

`duckdb_bind_int16`

Bindet einen int16_t-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_int16(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  int16_t val
);

`duckdb_bind_int32`

Bindet einen int32_t-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_int32(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  int32_t val
);

`duckdb_bind_int64`

Bindet einen int64_t-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_int64(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  int64_t val
);

`duckdb_bind_hugeint`

Bindet einen duckdb_hugeint-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_hugeint(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_hugeint val
);

`duckdb_bind_uhugeint`

Bindet einen duckdb_uhugeint-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_uhugeint(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_uhugeint val
);

`duckdb_bind_decimal`

Bindet einen duckdb_decimal-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_decimal(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_decimal val
);

`duckdb_bind_uint8`

Bindet einen uint8_t-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_uint8(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  uint8_t val
);

`duckdb_bind_uint16`

Bindet einen uint16_t-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_uint16(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  uint16_t val
);

`duckdb_bind_uint32`

Bindet einen uint32_t-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_uint32(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  uint32_t val
);

`duckdb_bind_uint64`

Bindet einen uint64_t-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_uint64(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  uint64_t val
);

`duckdb_bind_float`

Bindet einen Float-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_float(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  float val
);

`duckdb_bind_double`

Bindet einen Double-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_double(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  double val
);

`duckdb_bind_date`

Bindet einen duckdb_date-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_date(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_date val
);

`duckdb_bind_time`

Bindet einen duckdb_time-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_time(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_time val
);

`duckdb_bind_timestamp`

Bindet einen duckdb_timestamp-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_timestamp(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_timestamp val
);

`duckdb_bind_timestamp_tz`

Bindet einen duckdb_timestamp-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_timestamp_tz(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_timestamp val
);

`duckdb_bind_interval`

Bindet einen duckdb_interval-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_interval(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  duckdb_interval val
);

`duckdb_bind_varchar`

Bindet einen nullterminierten VARCHAR-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_varchar(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  const char *val
);

`duckdb_bind_varchar_length`

Bindet einen VARCHAR-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_varchar_length(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  const char *val,
  idx_t length
);

`duckdb_bind_blob`

Bindet einen Blob-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_blob(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx,
  const void *data,
  idx_t length
);

`duckdb_bind_null`

Bindet einen NULL-Wert an das Prepared Statement am angegebenen Index.

Syntax

duckdb_state duckdb_bind_null(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx
);

`duckdb_execute_prepared`

Führt das Prepared Statement mit den angegebenen gebundenen Parametern aus und gibt ein materialisiertes Abfrageergebnis zurück.

Diese Methode kann für jedes Prepared Statement mehrfach aufgerufen werden, und die Parameter können zwischen Aufrufen dieser Funktion geändert werden.

Beachten Sie, dass das Ergebnis mit duckdb_destroy_result freigegeben werden muss.

Syntax

duckdb_state duckdb_execute_prepared(
  duckdb_prepared_statement prepared_statement,
  duckdb_result *out_result
);

Parameter

prepared_statement: Das auszuführende Prepared Statement.
out_result: Das Abfrageergebnis.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_execute_prepared_streaming`

Führt das Prepared Statement mit den angegebenen gebundenen Parametern aus und gibt ein optional streamendes Abfrageergebnis zurück. Um festzustellen, ob die resultierende Abfrage tatsächlich gestreamt wurde, verwenden Sie duckdb_result_is_streaming

Diese Methode kann für jedes Prepared Statement mehrfach aufgerufen werden, und die Parameter können zwischen Aufrufen dieser Funktion geändert werden.

Beachten Sie, dass das Ergebnis mit duckdb_destroy_result freigegeben werden muss.

Syntax

duckdb_state duckdb_execute_prepared_streaming(
  duckdb_prepared_statement prepared_statement,
  duckdb_result *out_result
);

Parameter

prepared_statement: Das auszuführende Prepared Statement.
out_result: Das Abfrageergebnis.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_extract_statements`

Extrahiert alle Anweisungen aus einer Abfrage. Beachten Sie, dass die extrahierten Anweisungen nach dem Aufruf von duckdb_extract_statements immer mit duckdb_destroy_extracted zerstört werden sollten, auch wenn keine Anweisungen extrahiert wurden.

Wenn das Extrahieren fehlschlägt, kann duckdb_extract_statements_error aufgerufen werden, um den Grund zu ermitteln.

Syntax

idx_t duckdb_extract_statements(
  duckdb_connection connection,
  const char *query,
  duckdb_extracted_statements *out_extracted_statements
);

Parameter

connection: Das Verbindungsobjekt
query: Die zu extrahierende SQL-Abfrage
out_extracted_statements: Das resultierende Objekt der extrahierten Anweisungen

Rückgabewert

Die Anzahl der extrahierten Anweisungen oder 0 bei Fehler.

`duckdb_prepare_extracted_statement`

Bereitet eine extrahierte Anweisung vor. Beachten Sie, dass das Prepared Statement nach dem Aufruf von duckdb_prepare_extracted_statement immer mit duckdb_destroy_prepare zerstört werden sollte, auch wenn das Vorbereiten fehlschlägt.

Wenn das Vorbereiten fehlschlägt, kann duckdb_prepare_error aufgerufen werden, um den Grund zu ermitteln.

Syntax

duckdb_state duckdb_prepare_extracted_statement(
  duckdb_connection connection,
  duckdb_extracted_statements extracted_statements,
  idx_t index,
  duckdb_prepared_statement *out_prepared_statement
);

Parameter

connection: Das Verbindungsobjekt
extracted_statements: Das Objekt der extrahierten Anweisungen
index: Der Index der vorzubereitenden extrahierten Anweisung
out_prepared_statement: Das resultierende Prepared-Statement-Objekt

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_extract_statements_error`

Gibt die in den extrahierten Anweisungen enthaltene Fehlermeldung zurück. Das Ergebnis dieser Funktion darf nicht freigegeben werden. Es wird bereinigt, wenn duckdb_destroy_extracted aufgerufen wird.

Syntax

const char *duckdb_extract_statements_error(
  duckdb_extracted_statements extracted_statements
);

Parameter

extracted_statements: Die extrahierten Anweisungen, von denen der Fehler geholt wird.

Rückgabewert

Der Fehler der extrahierten Anweisungen.

`duckdb_destroy_extracted`

Gibt den gesamten für die extrahierten Anweisungen allokierten Speicher frei.

Syntax

void duckdb_destroy_extracted(
  duckdb_extracted_statements *extracted_statements
);

Parameter

extracted_statements: Die zu zerstörenden extrahierten Anweisungen.

`duckdb_pending_prepared`

Führt das Prepared Statement mit den angegebenen gebundenen Parametern aus und gibt ein Pending-Ergebnis zurück. Das Pending-Ergebnis ist eine Zwischenstruktur für eine noch nicht vollständig ausgeführte Abfrage. Das Pending-Ergebnis kann verwendet werden, um eine Abfrage schrittweise auszuführen und die Kontrolle zwischen Aufgaben an den Client zurückzugeben.

Beachten Sie, dass das Pending-Ergebnis nach dem Aufruf von duckdb_pending_prepared immer mit duckdb_destroy_pending zerstört werden sollte, auch wenn diese Funktion DuckDBError zurückgibt.

Syntax

duckdb_state duckdb_pending_prepared(
  duckdb_prepared_statement prepared_statement,
  duckdb_pending_result *out_result
);

Parameter

prepared_statement: Das auszuführende Prepared Statement.
out_result: Das Pending-Abfrageergebnis.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_pending_prepared_streaming`

Führt das Prepared Statement mit den angegebenen gebundenen Parametern aus und gibt ein Pending-Ergebnis zurück. Dieses Pending-Ergebnis erzeugt bei der Ausführung ein streamendes duckdb_result. Das Pending-Ergebnis ist eine Zwischenstruktur für eine noch nicht vollständig ausgeführte Abfrage.

Beachten Sie, dass das Pending-Ergebnis nach dem Aufruf von duckdb_pending_prepared_streaming immer mit duckdb_destroy_pending zerstört werden sollte, auch wenn diese Funktion DuckDBError zurückgibt.

Syntax

duckdb_state duckdb_pending_prepared_streaming(
  duckdb_prepared_statement prepared_statement,
  duckdb_pending_result *out_result
);

Parameter

prepared_statement: Das auszuführende Prepared Statement.
out_result: Das Pending-Abfrageergebnis.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_destroy_pending`

Schließt das Pending-Ergebnis und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_destroy_pending(
  duckdb_pending_result *pending_result
);

Parameter

pending_result: Das zu zerstörende Pending-Ergebnis.

`duckdb_pending_error`

Gibt die im Pending-Ergebnis enthaltene Fehlermeldung zurück.

Das Ergebnis dieser Funktion darf nicht freigegeben werden. Es wird bereinigt, wenn duckdb_destroy_pending aufgerufen wird.

Syntax

const char *duckdb_pending_error(
  duckdb_pending_result pending_result
);

Parameter

pending_result: Das Pending-Ergebnis, von dem der Fehler geholt wird.

Rückgabewert

Der Fehler des Pending-Ergebniss.

`duckdb_pending_execute_task`

Führt eine einzelne Aufgabe innerhalb der Abfrage aus und gibt zurück, ob die Abfrage bereit ist.

Wenn dies DUCKDB_PENDING_RESULT_READY zurückgibt, kann duckdb_execute_pending aufgerufen werden, um das Ergebnis zu holen. Wenn dies DUCKDB_PENDING_RESULT_NOT_READY zurückgibt, sollte duckdb_pending_execute_task erneut aufgerufen werden. Wenn dies DUCKDB_PENDING_ERROR zurückgibt, ist bei der Ausführung ein Fehler aufgetreten.

Die Fehlermeldung kann durch Aufruf von duckdb_pending_error auf dem pending_result ermittelt werden.

Syntax

duckdb_pending_state duckdb_pending_execute_task(
  duckdb_pending_result pending_result
);

Parameter

pending_result: Das Pending-Ergebnis, in dem ein Task ausgeführt wird.

Rückgabewert

Der Zustand des Pending-Ergebniss nach der Ausführung.

`duckdb_pending_execute_check_state`

Wenn dies DUCKDB_PENDING_RESULT_READY zurückgibt, kann duckdb_execute_pending aufgerufen werden, um das Ergebnis zu holen. Wenn dies DUCKDB_PENDING_RESULT_NOT_READY zurückgibt, sollte duckdb_pending_execute_check_state erneut aufgerufen werden. Wenn dies DUCKDB_PENDING_ERROR zurückgibt, ist bei der Ausführung ein Fehler aufgetreten.

Die Fehlermeldung kann durch Aufruf von duckdb_pending_error auf dem pending_result ermittelt werden.

Syntax

duckdb_pending_state duckdb_pending_execute_check_state(
  duckdb_pending_result pending_result
);

Parameter

pending_result: Das Pending-Ergebnis.

Rückgabewert

Der Zustand des Pending-Ergebniss.

`duckdb_execute_pending`

Führt ein Pending-Query-Ergebnis vollständig aus und gibt das endgültige Abfrageergebnis zurück.

Wenn duckdb_pending_execute_task aufgerufen wurde, bis DUCKDB_PENDING_RESULT_READY zurückgegeben wurde, kehrt dies schnell zurück. Andernfalls müssen zuerst alle verbleibenden Aufgaben ausgeführt werden.

Beachten Sie, dass das Ergebnis mit duckdb_destroy_result freigegeben werden muss.

Syntax

duckdb_state duckdb_execute_pending(
  duckdb_pending_result pending_result,
  duckdb_result *out_result
);

Parameter

pending_result: Das auszuführende Pending-Ergebnis.
out_result: Das Ergebnisobjekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_pending_execution_is_finished`

Gibt zurück, ob ein duckdb_pending_state die Ausführung beendet hat. Wenn pending_state beispielsweise DUCKDB_PENDING_RESULT_READY ist, gibt diese Funktion true zurück.

Syntax

bool duckdb_pending_execution_is_finished(
  duckdb_pending_state pending_state
);

Parameter

pending_state: Der Pending-Status, anhand dessen entschieden wird, ob die Ausführung beendet wird.

Rückgabewert

Boolean, der angibt, dass die ausstehende Ausführung als beendet gelten soll.

`duckdb_destroy_value`

Zerstört den Wert und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_destroy_value(
  duckdb_value *value
);

Parameter

value: Der zu zerstörende Wert.

`duckdb_create_varchar`

Erzeugt einen Wert aus einem nullterminierten String

Syntax

duckdb_value duckdb_create_varchar(
  const char *text
);

Parameter

text: Die null-terminierte Zeichenkette

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_varchar_length`

Erzeugt einen Wert aus einem String

Syntax

duckdb_value duckdb_create_varchar_length(
  const char *text,
  idx_t length
);

Parameter

text: The text
length: Die Länge des Texts

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_bool`

Erzeugt einen Wert aus einem Boolean

Syntax

duckdb_value duckdb_create_bool(
  bool input
);

Parameter

input: Der Boolean-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_int8`

Erzeugt einen Wert aus einem int8_t (einem Tinyint)

Syntax

duckdb_value duckdb_create_int8(
  int8_t input
);

Parameter

input: Der Tinyint-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_uint8`

Erzeugt einen Wert aus einem uint8_t (einem Utinyint)

Syntax

duckdb_value duckdb_create_uint8(
  uint8_t input
);

Parameter

input: Der Utinyint-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_int16`

Erzeugt einen Wert aus einem int16_t (einem Smallint)

Syntax

duckdb_value duckdb_create_int16(
  int16_t input
);

Parameter

input: Der Smallint-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_uint16`

Erzeugt einen Wert aus einem uint16_t (einem Usmallint)

Syntax

duckdb_value duckdb_create_uint16(
  uint16_t input
);

Parameter

input: Der Usmallint-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_int32`

Erzeugt einen Wert aus einem int32_t (einem Integer)

Syntax

duckdb_value duckdb_create_int32(
  int32_t input
);

Parameter

input: Der Integer-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_uint32`

Erzeugt einen Wert aus einem uint32_t (einem Uinteger)

Syntax

duckdb_value duckdb_create_uint32(
  uint32_t input
);

Parameter

input: Der Uinteger-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_uint64`

Erzeugt einen Wert aus einem uint64_t (einem Ubigint)

Syntax

duckdb_value duckdb_create_uint64(
  uint64_t input
);

Parameter

input: Der Ubigint-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_int64`

Erzeugt einen Wert aus einem int64

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_create_int64(
  int64_t val
);

`duckdb_create_hugeint`

Erzeugt einen Wert aus einem Hugeint

Syntax

duckdb_value duckdb_create_hugeint(
  duckdb_hugeint input
);

Parameter

input: Der Hugeint-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_uhugeint`

Erzeugt einen Wert aus einem Uhugeint

Syntax

duckdb_value duckdb_create_uhugeint(
  duckdb_uhugeint input
);

Parameter

input: Der Uhugeint-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_bignum`

Erzeugt einen BIGNUM-Wert aus einem duckdb_bignum

Syntax

duckdb_value duckdb_create_bignum(
  duckdb_bignum input
);

Parameter

input: Der duckdb_bignum-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_decimal`

Erzeugt einen DECIMAL-Wert aus einem duckdb_decimal

Syntax

duckdb_value duckdb_create_decimal(
  duckdb_decimal input
);

Parameter

input: Der duckdb_decimal-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_float`

Erzeugt einen Wert aus einem Float

Syntax

duckdb_value duckdb_create_float(
  float input
);

Parameter

input: Der Float-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_double`

Erzeugt einen Wert aus einem Double

Syntax

duckdb_value duckdb_create_double(
  double input
);

Parameter

input: Der Double-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_date`

Erzeugt einen Wert aus einem Date

Syntax

duckdb_value duckdb_create_date(
  duckdb_date input
);

Parameter

input: Der Date-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_time`

Erzeugt einen Wert aus einer Time

Syntax

duckdb_value duckdb_create_time(
  duckdb_time input
);

Parameter

input: Der Time-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_time_ns`

Erzeugt einen Wert aus einer time_ns

Syntax

duckdb_value duckdb_create_time_ns(
  duckdb_time_ns input
);

Parameter

input: Der Time-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_time_tz_value`

Erzeugt einen Wert aus einer time_tz. Nicht zu verwechseln mit duckdb_create_time_tz, das ein duckdb_time_tz_t erzeugt.

Syntax

duckdb_value duckdb_create_time_tz_value(
  duckdb_time_tz value
);

Parameter

value: Der time_tz-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_timestamp`

Erzeugt einen TIMESTAMP-Wert aus einem duckdb_timestamp

Syntax

duckdb_value duckdb_create_timestamp(
  duckdb_timestamp input
);

Parameter

input: Der duckdb_timestamp-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_timestamp_tz`

Erzeugt einen TIMESTAMP_TZ-Wert aus einem duckdb_timestamp

Syntax

duckdb_value duckdb_create_timestamp_tz(
  duckdb_timestamp input
);

Parameter

input: Der duckdb_timestamp-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_timestamp_s`

Erzeugt einen TIMESTAMP_S-Wert aus einem duckdb_timestamp_s

Syntax

duckdb_value duckdb_create_timestamp_s(
  duckdb_timestamp_s input
);

Parameter

input: Der duckdb_timestamp_s-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_timestamp_ms`

Erzeugt einen TIMESTAMP_MS-Wert aus einem duckdb_timestamp_ms

Syntax

duckdb_value duckdb_create_timestamp_ms(
  duckdb_timestamp_ms input
);

Parameter

input: Der duckdb_timestamp_ms-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_timestamp_ns`

Erzeugt einen TIMESTAMP_NS-Wert aus einem duckdb_timestamp_ns

Syntax

duckdb_value duckdb_create_timestamp_ns(
  duckdb_timestamp_ns input
);

Parameter

input: Der duckdb_timestamp_ns-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_interval`

Erzeugt einen Wert aus einem Interval

Syntax

duckdb_value duckdb_create_interval(
  duckdb_interval input
);

Parameter

input: Der Interval-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_blob`

Erzeugt einen Wert aus einem Blob

Syntax

duckdb_value duckdb_create_blob(
  const uint8_t *data,
  idx_t length
);

Parameter

data: Die Blob-Daten
length: Die Länge der Blob-Daten

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_bit`

Erzeugt einen BIT-Wert aus einem duckdb_bit

Syntax

duckdb_value duckdb_create_bit(
  duckdb_bit input
);

Parameter

input: Der duckdb_bit-Wert

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_create_uuid`

Erzeugt einen UUID-Wert aus einem Uhugeint

Syntax

duckdb_value duckdb_create_uuid(
  duckdb_uhugeint input
);

Parameter

input: Das duckdb_uhugeint, das die UUID enthält

Rückgabewert

Der Wert. Dieser muss mit duckdb_destroy_value zerstört werden.

`duckdb_get_bool`

Gibt den Boolean-Wert des angegebenen Werts zurück.

Syntax

bool duckdb_get_bool(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das einen Boolean enthält

Rückgabewert

Ein Boolean oder false, wenn der Wert nicht konvertiert werden kann

`duckdb_get_int8`

Gibt den int8_t-Wert des angegebenen Werts zurück.

Syntax

int8_t duckdb_get_int8(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Tinyint enthält

Rückgabewert

Ein int8_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_uint8`

Gibt den uint8_t-Wert des angegebenen Werts zurück.

Syntax

uint8_t duckdb_get_uint8(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Utinyint enthält

Rückgabewert

Ein uint8_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_int16`

Gibt den int16_t-Wert des angegebenen Werts zurück.

Syntax

int16_t duckdb_get_int16(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Smallint enthält

Rückgabewert

Ein int16_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_uint16`

Gibt den uint16_t-Wert des angegebenen Werts zurück.

Syntax

uint16_t duckdb_get_uint16(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Usmallint enthält

Rückgabewert

Ein uint16_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_int32`

Gibt den int32_t-Wert des angegebenen Werts zurück.

Syntax

int32_t duckdb_get_int32(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Integer enthält

Rückgabewert

Ein int32_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_uint32`

Gibt den uint32_t-Wert des angegebenen Werts zurück.

Syntax

uint32_t duckdb_get_uint32(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Uinteger enthält

Rückgabewert

Ein uint32_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_int64`

Gibt den int64_t-Wert des angegebenen Werts zurück.

Syntax

int64_t duckdb_get_int64(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Bigint enthält

Rückgabewert

Ein int64_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_uint64`

Gibt den uint64_t-Wert des angegebenen Werts zurück.

Syntax

uint64_t duckdb_get_uint64(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Ubigint enthält

Rückgabewert

Ein uint64_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_hugeint`

Gibt den Hugeint-Wert des angegebenen Werts zurück.

Syntax

duckdb_hugeint duckdb_get_hugeint(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Hugeint enthält

Rückgabewert

Ein duckdb_hugeint oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_uhugeint`

Gibt den Uhugeint-Wert des angegebenen Werts zurück.

Syntax

duckdb_uhugeint duckdb_get_uhugeint(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Uhugeint enthält

Rückgabewert

Ein duckdb_uhugeint oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_bignum`

Gibt den duckdb_bignum-Wert des angegebenen Werts zurück. Das Feld data muss mit duckdb_free zerstört werden.

Syntax

duckdb_bignum duckdb_get_bignum(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein BIGNUM enthält

Rückgabewert

Ein duckdb_bignum. Das Feld data muss mit duckdb_free zerstört werden.

`duckdb_get_decimal`

Gibt den duckdb_decimal-Wert des angegebenen Werts zurück.

Syntax

duckdb_decimal duckdb_get_decimal(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein DECIMAL enthält

Rückgabewert

Ein duckdb_decimal oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_float`

Gibt den Float-Wert des angegebenen Werts zurück.

Syntax

float duckdb_get_float(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das einen Float enthält

Rückgabewert

Ein Float oder NAN, wenn der Wert nicht konvertiert werden kann

`duckdb_get_double`

Gibt den Double-Wert des angegebenen Werts zurück.

Syntax

double duckdb_get_double(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das einen Double enthält

Rückgabewert

Ein Double oder NAN, wenn der Wert nicht konvertiert werden kann

`duckdb_get_date`

Gibt den Date-Wert des angegebenen Werts zurück.

Syntax

duckdb_date duckdb_get_date(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Date enthält

Rückgabewert

Ein duckdb_date oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_time`

Gibt den Time-Wert des angegebenen Werts zurück.

Syntax

duckdb_time duckdb_get_time(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das eine Time enthält

Rückgabewert

Ein duckdb_time oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_time_ns`

Gibt den time_ns-Wert des angegebenen Werts zurück.

Syntax

duckdb_time_ns duckdb_get_time_ns(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das eine time_ns enthält

Rückgabewert

Ein duckdb_time_ns oder MinValue<time_ns>, wenn der Wert nicht konvertiert werden kann

`duckdb_get_time_tz`

Gibt den time_tz-Wert des angegebenen Werts zurück.

Syntax

duckdb_time_tz duckdb_get_time_tz(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das eine time_tz enthält

Rückgabewert

Ein duckdb_time_tz oder MinValue<time_tz>, wenn der Wert nicht konvertiert werden kann

`duckdb_get_timestamp`

Gibt den TIMESTAMP-Wert des angegebenen Werts zurück.

Syntax

duckdb_timestamp duckdb_get_timestamp(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das einen TIMESTAMP enthält

Rückgabewert

Ein duckdb_timestamp oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_timestamp_tz`

Gibt den TIMESTAMP_TZ-Wert des angegebenen Werts zurück.

Syntax

duckdb_timestamp duckdb_get_timestamp_tz(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das einen TIMESTAMP_TZ enthält

Rückgabewert

Ein duckdb_timestamp oder MinValue<timestamp_tz>, wenn der Wert nicht konvertiert werden kann

`duckdb_get_timestamp_s`

Gibt den duckdb_timestamp_s-Wert des angegebenen Werts zurück.

Syntax

duckdb_timestamp_s duckdb_get_timestamp_s(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das einen TIMESTAMP_S enthält

Rückgabewert

Ein duckdb_timestamp_s oder MinValue<timestamp_s>, wenn der Wert nicht konvertiert werden kann

`duckdb_get_timestamp_ms`

Gibt den duckdb_timestamp_ms-Wert des angegebenen Werts zurück.

Syntax

duckdb_timestamp_ms duckdb_get_timestamp_ms(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das einen TIMESTAMP_MS enthält

Rückgabewert

Ein duckdb_timestamp_ms oder MinValue<timestamp_ms>, wenn der Wert nicht konvertiert werden kann

`duckdb_get_timestamp_ns`

Gibt den duckdb_timestamp_ns-Wert des angegebenen Werts zurück.

Syntax

duckdb_timestamp_ns duckdb_get_timestamp_ns(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das einen TIMESTAMP_NS enthält

Rückgabewert

Ein duckdb_timestamp_ns oder MinValue<timestamp_ns>, wenn der Wert nicht konvertiert werden kann

`duckdb_get_interval`

Gibt den Interval-Wert des angegebenen Werts zurück.

Syntax

duckdb_interval duckdb_get_interval(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Interval enthält

Rückgabewert

Ein duckdb_interval oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_value_type`

Gibt den Typ des angegebenen Werts zurück. Der Typ ist gültig, solange der Wert nicht zerstört wird. Der Typ selbst darf nicht zerstört werden.

Syntax

duckdb_logical_type duckdb_get_value_type(
  duckdb_value val
);

Parameter

val: Ein duckdb_value

Rückgabewert

Ein duckdb_logical_type.

`duckdb_get_blob`

Gibt den Blob-Wert des angegebenen Werts zurück.

Syntax

duckdb_blob duckdb_get_blob(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein Blob enthält

Rückgabewert

Ein duckdb_blob

`duckdb_get_bit`

Gibt den duckdb_bit-Wert des angegebenen Werts zurück. Das Feld data muss mit duckdb_free zerstört werden.

Syntax

duckdb_bit duckdb_get_bit(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das ein BIT enthält

Rückgabewert

Ein duckdb_bit

`duckdb_get_uuid`

Gibt einen duckdb_uhugeint zurück, der den UUID-Wert des angegebenen Werts darstellt.

Syntax

duckdb_uhugeint duckdb_get_uuid(
  duckdb_value val
);

Parameter

val: Ein duckdb_value, das eine UUID enthält

Rückgabewert

Ein duckdb_uhugeint, der den UUID-Wert darstellt

`duckdb_get_varchar`

Ermittelt eine Stringdarstellung des angegebenen Werts. Das Ergebnis muss mit duckdb_free zerstört werden.

Syntax

char *duckdb_get_varchar(
  duckdb_value value
);

Parameter

value: Der Wert

Rückgabewert

Der Stringwert. Dieser muss mit duckdb_free zerstört werden.

`duckdb_create_struct_value`

Erzeugt einen Struct-Wert aus einem Typ und einem Array von Werten. Muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_create_struct_value(
  duckdb_logical_type type,
  duckdb_value *values
);

Parameter

type: Der Typ des Structs
values: Die Werte für die Struct-Felder

Rückgabewert

Der Struct-Wert oder nullptr, wenn ein Kindtyp DUCKDB_TYPE_ANY oder DUCKDB_TYPE_INVALID ist.

`duckdb_create_list_value`

Erzeugt einen Listenwert aus einem Kind- (Element-) Typ und einem Array von Werten der Länge value_count. Muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_create_list_value(
  duckdb_logical_type type,
  duckdb_value *values,
  idx_t value_count
);

Parameter

type: Der Typ der Liste
values: Die Werte für die Liste
value_count: Die Anzahl der Werte in der Liste

Rückgabewert

Der Listenwert oder nullptr, wenn der Kindtyp DUCKDB_TYPE_ANY oder DUCKDB_TYPE_INVALID ist.

`duckdb_create_array_value`

Erzeugt einen Array-Wert aus einem Kind- (Element-) Typ und einem Array von Werten der Länge value_count. Muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_create_array_value(
  duckdb_logical_type type,
  duckdb_value *values,
  idx_t value_count
);

Parameter

type: Der Typ des Arrays
values: Die Werte für das Array
value_count: Die Anzahl der Werte im Array

Rückgabewert

Der Array-Wert oder nullptr, wenn der Kindtyp DUCKDB_TYPE_ANY oder DUCKDB_TYPE_INVALID ist.

`duckdb_create_map_value`

Erzeugt einen Map-Wert aus einem Map-Typ und zwei Arrays, eines für die Schlüssel und eines für die Werte, jeweils der Länge entry_count. Muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_create_map_value(
  duckdb_logical_type map_type,
  duckdb_value *keys,
  duckdb_value *values,
  idx_t entry_count
);

Parameter

map_type: Der Map-Typ
keys: Die Keys der Map
values: Die Values der Map
entry_count: Die Anzahl der Einträge (Key-Value-Paare) in der Map

Rückgabewert

Der Map-Wert oder nullptr, wenn die Parameter ungültig sind.

`duckdb_create_union_value`

Erzeugt einen Union-Wert aus einem Union-Typ, einem Tag-Index und einem Wert. Muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_create_union_value(
  duckdb_logical_type union_type,
  idx_t tag_index,
  duckdb_value value
);

Parameter

union_type: Der Union-Typ
tag_index: Der Index des Tags der Union
value: Der Wert der Union für dieses Tag

Rückgabewert

Der Union-Wert oder nullptr, wenn die Parameter ungültig sind.

`duckdb_get_map_size`

Gibt die Anzahl der Elemente in einem MAP-Wert zurück.

Syntax

idx_t duckdb_get_map_size(
  duckdb_value value
);

Parameter

value: Der MAP-Wert.

Rückgabewert

Die Anzahl der Elemente in der Map.

`duckdb_get_map_key`

Gibt den MAP-Schlüssel am Index als duckdb_value zurück.

Syntax

duckdb_value duckdb_get_map_key(
  duckdb_value value,
  idx_t index
);

Parameter

value: Der MAP-Wert.
index: Der Index des Keys.

Rückgabewert

Der Schlüssel als duckdb_value.

`duckdb_get_map_value`

Gibt den MAP-Wert am Index als duckdb_value zurück.

Syntax

duckdb_value duckdb_get_map_value(
  duckdb_value value,
  idx_t index
);

Parameter

value: Der MAP-Wert.
index: Der Index des Values.

Rückgabewert

Der Wert als duckdb_value.

`duckdb_is_null_value`

Gibt zurück, ob der Typ des Werts SQLNULL ist.

Syntax

bool duckdb_is_null_value(
  duckdb_value value
);

Parameter

value: Der zu prüfende Wert.

Rückgabewert

True, wenn der Typ des Werts SQLNULL ist, sonst false.

`duckdb_create_null_value`

Erzeugt einen Wert vom Typ SQLNULL.

Rückgabewert

Der duckdb_value, der SQLNULL darstellt. Dieser muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_create_null_value(
  
);

`duckdb_get_list_size`

Gibt die Anzahl der Elemente in einem LIST-Wert zurück.

Syntax

idx_t duckdb_get_list_size(
  duckdb_value value
);

Parameter

value: Der LIST-Wert.

Rückgabewert

Die Anzahl der Elemente in der Liste.

`duckdb_get_list_child`

Gibt das LIST-Kind am Index als duckdb_value zurück.

Syntax

duckdb_value duckdb_get_list_child(
  duckdb_value value,
  idx_t index
);

Parameter

value: Der LIST-Wert.
index: Der Index des Childs.

Rückgabewert

Das Kind als duckdb_value.

`duckdb_create_enum_value`

Erzeugt einen Enum-Wert aus einem Typ und einem Wert. Muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_create_enum_value(
  duckdb_logical_type type,
  uint64_t value
);

Parameter

type: Der Typ des Enums
value: Der Wert für das Enum

Rückgabewert

Der Enum-Wert oder nullptr.

`duckdb_get_enum_value`

Gibt den Enum-Wert des angegebenen Werts zurück.

Syntax

uint64_t duckdb_get_enum_value(
  duckdb_value value
);

Parameter

value: Ein duckdb_value, das ein Enum enthält

Rückgabewert

Ein uint64_t oder MinValue, wenn der Wert nicht konvertiert werden kann

`duckdb_get_struct_child`

Gibt das STRUCT-Kind am Index als duckdb_value zurück.

Syntax

duckdb_value duckdb_get_struct_child(
  duckdb_value value,
  idx_t index
);

Parameter

value: Der STRUCT-Wert.
index: Der Index des Childs.

Rückgabewert

Das Kind als duckdb_value.

`duckdb_value_to_string`

Gibt die SQL-Stringdarstellung des angegebenen Werts zurück.

Syntax

char *duckdb_value_to_string(
  duckdb_value value
);

Parameter

value: Ein duckdb_value.

Rückgabewert

Die SQL-Stringdarstellung als nullterminierter String. Das Ergebnis muss mit duckdb_free freigegeben werden.

`duckdb_create_logical_type`

Erzeugt einen duckdb_logical_type aus einem primitiven Typ. Der resultierende logische Typ muss mit duckdb_destroy_logical_type zerstört werden.

Gibt einen ungültigen logischen Typ zurück, wenn type einer der folgenden ist: DUCKDB_TYPE_INVALID, DUCKDB_TYPE_DECIMAL, DUCKDB_TYPE_ENUM, DUCKDB_TYPE_LIST, DUCKDB_TYPE_STRUCT, DUCKDB_TYPE_MAP, DUCKDB_TYPE_ARRAY oder DUCKDB_TYPE_UNION.

Syntax

duckdb_logical_type duckdb_create_logical_type(
  duckdb_type type
);

Parameter

type: Der zu erzeugende primitive Typ.

Rückgabewert

Der logische Typ.

`duckdb_logical_type_get_alias`

Gibt den Alias eines duckdb_logical_type zurück, falls gesetzt, sonst nullptr. Das Ergebnis muss mit duckdb_free zerstört werden.

Syntax

char *duckdb_logical_type_get_alias(
  duckdb_logical_type type
);

Parameter

type: Der logische Typ

Rückgabewert

Der Alias oder nullptr

`duckdb_logical_type_set_alias`

Setzt den Alias eines duckdb_logical_type.

Syntax

void duckdb_logical_type_set_alias(
  duckdb_logical_type type,
  const char *alias
);

Parameter

type: Der logische Typ
alias: Der zu setzende Alias

`duckdb_create_list_type`

Erzeugt einen LIST-Typ aus seinem Kindtyp. Der Rückgabetyp muss mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_create_list_type(
  duckdb_logical_type type
);

Parameter

type: Der Child-Typ der Liste

Rückgabewert

Der logische Typ.

`duckdb_create_array_type`

Erzeugt einen ARRAY-Typ aus seinem Kindtyp. Der Rückgabetyp muss mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_create_array_type(
  duckdb_logical_type type,
  idx_t array_size
);

Parameter

type: Der Child-Typ des Arrays.
array_size: Die Anzahl der Elemente im Array.

Rückgabewert

Der logische Typ.

`duckdb_create_map_type`

Erzeugt einen MAP-Typ aus seinem Schlüsseltyp und Wertetyp. Der Rückgabetyp muss mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_create_map_type(
  duckdb_logical_type key_type,
  duckdb_logical_type value_type
);

Parameter

key_type: Der Key-Typ der Map.
value_type: Der Value-Typ der Map.

Rückgabewert

Der logische Typ.

`duckdb_create_union_type`

Erzeugt einen UNION-Typ aus den übergebenen Arrays. Der Rückgabetyp muss mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_create_union_type(
  duckdb_logical_type *member_types,
  const char **member_names,
  idx_t member_count
);

Parameter

member_types: Das Array der Union-Member-Typen.
member_names: Die Union-Member-Namen.
member_count: Die Anzahl der Union-Member.

Rückgabewert

Der logische Typ.

`duckdb_create_struct_type`

Erzeugt einen STRUCT-Typ aus den Mitgliedstypen und -namen. Der resultierende Typ muss mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_create_struct_type(
  duckdb_logical_type *member_types,
  const char **member_names,
  idx_t member_count
);

Parameter

member_types: Das Array der Typen der Struct-Member.
member_names: Das Array der Namen der Struct-Member.
member_count: Die Anzahl der Member des Structs.

Rückgabewert

Der logische Typ.

`duckdb_create_enum_type`

Erzeugt einen ENUM-Typ aus dem übergebenen Mitgliedsnamen-Array. Der resultierende Typ sollte mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_create_enum_type(
  const char **member_names,
  idx_t member_count
);

Parameter

member_names: Das Array der Namen, aus denen das Enum bestehen soll.
member_count: Die Anzahl der Elemente, die im Array angegeben wurden.

Rückgabewert

Der logische Typ.

`duckdb_create_decimal_type`

Erzeugt einen DECIMAL-Typ mit der angegebenen Breite und Nachkommastellen. Der resultierende Typ sollte mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_create_decimal_type(
  uint8_t width,
  uint8_t scale
);

Parameter

width: Die Breite des Decimal-Typs
scale: Die Nachkommastellen des Decimal-Typs

Rückgabewert

Der logische Typ.

`duckdb_get_type_id`

Ruft den Enum-duckdb_type eines duckdb_logical_type ab.

Syntax

duckdb_type duckdb_get_type_id(
  duckdb_logical_type type
);

Parameter

type: Der logische Typ.

Rückgabewert

Die duckdb_type-ID.

`duckdb_decimal_width`

Ruft die Breite eines Decimal-Typs ab.

Syntax

uint8_t duckdb_decimal_width(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Die Breite des Decimal-Typs

`duckdb_decimal_scale`

Ruft die Nachkommastellen eines Decimal-Typs ab.

Syntax

uint8_t duckdb_decimal_scale(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Die Nachkommastellen des Decimal-Typs

`duckdb_decimal_internal_type`

Ruft den internen Speichertyp eines Decimal-Typs ab.

Syntax

duckdb_type duckdb_decimal_internal_type(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Der interne Typ des Decimal-Typs

`duckdb_enum_internal_type`

Ruft den internen Speichertyp eines Enum-Typs ab.

Syntax

duckdb_type duckdb_enum_internal_type(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Der interne Typ des Enum-Typs

`duckdb_enum_dictionary_size`

Ruft die Dictionary-Größe des Enum-Typs ab.

Syntax

uint32_t duckdb_enum_dictionary_size(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Die Dictionary-Größe des Enum-Typs

`duckdb_enum_dictionary_value`

Ruft den Dictionary-Wert an der angegebenen Position aus dem Enum ab.

Das Ergebnis muss mit duckdb_free freigegeben werden.

Syntax

char *duckdb_enum_dictionary_value(
  duckdb_logical_type type,
  idx_t index
);

Parameter

type: Das logische Typobjekt
index: Der Index im Dictionary

Rückgabewert

Der Stringwert des Enum-Typs. Muss mit duckdb_free freigegeben werden.

`duckdb_list_type_child_type`

Ruft den Kindtyp des angegebenen LIST-Typs ab. Akzeptiert auch MAP-Typen. Das Ergebnis muss mit duckdb_destroy_logical_type freigegeben werden.

Syntax

duckdb_logical_type duckdb_list_type_child_type(
  duckdb_logical_type type
);

Parameter

type: Der logische Typ, entweder LIST oder MAP.

Rückgabewert

Der Kindtyp des LIST- oder MAP-Typs.

`duckdb_array_type_child_type`

Ruft den Kindtyp des angegebenen ARRAY-Typs ab.

Das Ergebnis muss mit duckdb_destroy_logical_type freigegeben werden.

Syntax

duckdb_logical_type duckdb_array_type_child_type(
  duckdb_logical_type type
);

Parameter

type: Der logische Typ. Must be ARRAY.

Rückgabewert

Der Kindtyp des ARRAY-Typs.

`duckdb_array_type_array_size`

Ruft die Array-Größe des angegebenen Array-Typs ab.

Syntax

idx_t duckdb_array_type_array_size(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Die feste Anzahl der Elemente, die Werte dieses Array-Typs speichern können.

`duckdb_map_type_key_type`

Ruft den Schlüsseltyp des angegebenen Map-Typs ab.

Das Ergebnis muss mit duckdb_destroy_logical_type freigegeben werden.

Syntax

duckdb_logical_type duckdb_map_type_key_type(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Der Schlüsseltyp des Map-Typs. Muss mit duckdb_destroy_logical_type zerstört werden.

`duckdb_map_type_value_type`

Ruft den Wertetyp des angegebenen Map-Typs ab.

Das Ergebnis muss mit duckdb_destroy_logical_type freigegeben werden.

Syntax

duckdb_logical_type duckdb_map_type_value_type(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Der Wertetyp des Map-Typs. Muss mit duckdb_destroy_logical_type zerstört werden.

`duckdb_struct_type_child_count`

Gibt die Anzahl der Kinder eines Struct-Typs zurück.

Syntax

idx_t duckdb_struct_type_child_count(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt

Rückgabewert

Die Anzahl der Kinder eines Struct-Typs.

`duckdb_struct_type_child_name`

Ruft den Namen des Struct-Kinds ab.

Das Ergebnis muss mit duckdb_free freigegeben werden.

Syntax

char *duckdb_struct_type_child_name(
  duckdb_logical_type type,
  idx_t index
);

Parameter

type: Das logische Typobjekt
index: Der Child-Index

Rückgabewert

Der Name des Struct-Typs. Muss mit duckdb_free freigegeben werden.

`duckdb_struct_type_child_type`

Ruft den Kindtyp des angegebenen Struct-Typs am angegebenen Index ab.

Das Ergebnis muss mit duckdb_destroy_logical_type freigegeben werden.

Syntax

duckdb_logical_type duckdb_struct_type_child_type(
  duckdb_logical_type type,
  idx_t index
);

Parameter

type: Das logische Typobjekt
index: Der Child-Index

Rückgabewert

Der Kindtyp des Struct-Typs. Muss mit duckdb_destroy_logical_type zerstört werden.

`duckdb_union_type_member_count`

Gibt die Anzahl der Mitglieder des Union-Typs zurück.

Syntax

idx_t duckdb_union_type_member_count(
  duckdb_logical_type type
);

Parameter

type: Das logische Typobjekt (Union)

Rückgabewert

Die Anzahl der Mitglieder eines Union-Typs.

`duckdb_union_type_member_name`

Ruft den Namen des Union-Mitglieds ab.

Das Ergebnis muss mit duckdb_free freigegeben werden.

Syntax

char *duckdb_union_type_member_name(
  duckdb_logical_type type,
  idx_t index
);

Parameter

type: Das logische Typobjekt
index: Der Child-Index

Rückgabewert

Der Name des Union-Mitglieds. Muss mit duckdb_free freigegeben werden.

`duckdb_union_type_member_type`

Ruft den Kindtyp des angegebenen Union-Mitglieds am angegebenen Index ab.

Das Ergebnis muss mit duckdb_destroy_logical_type freigegeben werden.

Syntax

duckdb_logical_type duckdb_union_type_member_type(
  duckdb_logical_type type,
  idx_t index
);

Parameter

type: Das logische Typobjekt
index: Der Child-Index

Rückgabewert

Der Kindtyp des Union-Mitglieds. Muss mit duckdb_destroy_logical_type zerstört werden.

`duckdb_destroy_logical_type`

Zerstört den logischen Typ und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_destroy_logical_type(
  duckdb_logical_type *type
);

Parameter

type: Der zu zerstörende logische Typ.

`duckdb_register_logical_type`

Registriert einen benutzerdefinierten Typ in der angegebenen Verbindung. Der Typ muss einen Alias haben

Syntax

duckdb_state duckdb_register_logical_type(
  duckdb_connection con,
  duckdb_logical_type type,
  duckdb_create_type_info info
);

Parameter

con: Die zu verwendende Verbindung
type: Der zu registrierende benutzerdefinierte Typ

Rückgabewert

Ob die Registrierung erfolgreich war.

`duckdb_create_data_chunk`

Erzeugt einen leeren Data-Chunk mit den angegebenen Spaltentypen. Das Ergebnis muss mit duckdb_destroy_data_chunk zerstört werden.

Syntax

duckdb_data_chunk duckdb_create_data_chunk(
  duckdb_logical_type *types,
  idx_t column_count
);

Parameter

types: Ein Array von Spaltentypen. Column types can not contain ANY and INVALID types.
column_count: Die Anzahl der Spalten.

Rückgabewert

Der Data-Chunk.

`duckdb_destroy_data_chunk`

Zerstört den Data-Chunk und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_destroy_data_chunk(
  duckdb_data_chunk *chunk
);

Parameter

chunk: Der zu zerstörende Data Chunk.

`duckdb_data_chunk_reset`

Setzt einen Data-Chunk zurück, löscht die Validity-Masken und setzt die Kardinalität des Data-Chunks auf 0. Nach dem Aufruf dieser Methode müssen Sie duckdb_vector_get_validity und duckdb_vector_get_data aufrufen, um die aktuellen Daten- und Validity-Zeiger zu erhalten

Syntax

void duckdb_data_chunk_reset(
  duckdb_data_chunk chunk
);

Parameter

chunk: Der zurückzusetzende Data Chunk.

`duckdb_data_chunk_get_column_count`

Ruft die Anzahl der Spalten in einem Data-Chunk ab.

Syntax

idx_t duckdb_data_chunk_get_column_count(
  duckdb_data_chunk chunk
);

Parameter

chunk: Der Data Chunk, aus dem die Daten gelesen werden

Rückgabewert

Die Anzahl der Spalten im Data-Chunk

`duckdb_data_chunk_get_vector`

Ruft den Vektor am angegebenen Spaltenindex im Data-Chunk ab.

Der Zeiger auf den Vektor ist gültig, solange der Chunk existiert. Er muss NICHT zerstört werden.

Syntax

duckdb_vector duckdb_data_chunk_get_vector(
  duckdb_data_chunk chunk,
  idx_t col_idx
);

Parameter

chunk: Der Data Chunk, aus dem die Daten gelesen werden

Rückgabewert

Der Vektor

`duckdb_data_chunk_get_size`

Ruft die aktuelle Anzahl der Tupel in einem Data-Chunk ab.

Syntax

idx_t duckdb_data_chunk_get_size(
  duckdb_data_chunk chunk
);

Parameter

chunk: Der Data Chunk, aus dem die Daten gelesen werden

Rückgabewert

Die Anzahl der Tupel im Data-Chunk

`duckdb_data_chunk_set_size`

Setzt die aktuelle Anzahl der Tupel in einem Data-Chunk.

Syntax

void duckdb_data_chunk_set_size(
  duckdb_data_chunk chunk,
  idx_t size
);

Parameter

chunk: Der Data Chunk, in dem die Größe gesetzt wird
size: Die Anzahl der Tupel im Data-Chunk

`duckdb_create_vector`

Erzeugt einen flachen Vektor. Muss mit duckdb_destroy_vector zerstört werden.

Syntax

duckdb_vector duckdb_create_vector(
  duckdb_logical_type type,
  idx_t capacity
);

Parameter

type: Der logische Typ des Vektors.
capacity: Die Kapazität des Vektors.

Rückgabewert

Der Vektor.

`duckdb_destroy_vector`

Zerstört den Vektor und gibt seinen Speicher frei.

Syntax

void duckdb_destroy_vector(
  duckdb_vector *vector
);

Parameter

vector: Ein Zeiger auf den Vektor.

`duckdb_vector_get_column_type`

Ruft den Spaltentyp des angegebenen Vektors ab.

Das Ergebnis muss mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_vector_get_column_type(
  duckdb_vector vector
);

Parameter

vector: Der Vektor get the data from

Rückgabewert

Der Typ des Vektors

`duckdb_vector_get_data`

Ruft den Datenzeiger des Vektors ab.

Der Datenzeiger kann verwendet werden, um Werte aus dem Vektor zu lesen oder in ihn zu schreiben. Wie Werte gelesen oder geschrieben werden, hängt vom Typ des Vektors ab.

Syntax

void *duckdb_vector_get_data(
  duckdb_vector vector
);

Parameter

vector: Der Vektor to get the data from

Rückgabewert

Der Datenzeiger

`duckdb_vector_get_validity`

Ruft den Validity-Mask-Zeiger des angegebenen Vektors ab.

Wenn alle Werte gültig sind, KANN diese Funktion NULL zurückgeben!

Die Validity-Maske ist ein Bitset, das die NULL-Eigenschaft innerhalb des Data-Chunks kennzeichnet. Sie besteht aus einer Folge von uint64_t-Werten, wobei jeder uint64_t-Wert die Gültigkeit von 64 Tupeln enthält. Das Bit ist 1, wenn der Wert gültig ist (d. h. nicht NULL), oder 0, wenn der Wert ungültig ist (d. h. NULL).

Die Gültigkeit eines bestimmten Werts kann so ermittelt werden:

idx_t entry_idx = row_idx / 64; idx_t idx_in_entry = row_idx % 64; bool is_valid = validity_mask[entry_idx] & (1 << idx_in_entry);

Alternativ kann die (langsamere) Funktion duckdb_validity_row_is_valid verwendet werden.

Syntax

uint64_t *duckdb_vector_get_validity(
  duckdb_vector vector
);

Parameter

vector: Der Vektor to get the data from

Rückgabewert

Der Zeiger auf die Validity-Maske oder NULL, wenn keine Validity-Maske vorhanden ist

`duckdb_vector_ensure_validity_writable`

Stellt sicher, dass die Validity-Maske beschreibbar ist, indem sie allokiert wird.

Nach dem Aufruf dieser Funktion gibt duckdb_vector_get_validity IMMER einen Wert ungleich NULL zurück. So können NULL-Werte in den Vektor geschrieben werden, unabhängig davon, ob zuvor eine Validity-Maske vorhanden war.

Syntax

void duckdb_vector_ensure_validity_writable(
  duckdb_vector vector
);

Parameter

vector: Der Vektor to alter

`duckdb_vector_assign_string_element`

Weist dem Vektor am angegebenen Index ein Stringelement zu.

Syntax

void duckdb_vector_assign_string_element(
  duckdb_vector vector,
  idx_t index,
  const char *str
);

Parameter

vector: Der Vektor to alter
index: Die Zeilenposition im Vektor, der die Zeichenkette zugewiesen wird
str: Die null-terminierte Zeichenkette

`duckdb_vector_assign_string_element_len`

Weist dem Vektor am angegebenen Index ein Stringelement zu. Sie können diese Funktion auch zum Zuweisen von BLOBs verwenden.

Syntax

void duckdb_vector_assign_string_element_len(
  duckdb_vector vector,
  idx_t index,
  const char *str,
  idx_t str_len
);

Parameter

vector: Der Vektor to alter
index: Die Zeilenposition im Vektor, der die Zeichenkette zugewiesen wird
str: Die Zeichenkette
str_len: Die Länge der Zeichenkette (in Bytes)

`duckdb_list_vector_get_child`

Ruft den Kindvektor eines Listenvektors ab.

Der resultierende Vektor ist gültig, solange der Elternvektor gültig ist.

Syntax

duckdb_vector duckdb_list_vector_get_child(
  duckdb_vector vector
);

Parameter

vector: Der Vektor

Rückgabewert

Der Kindvektor

`duckdb_list_vector_get_size`

Gibt die Größe des Kindvektors der Liste zurück.

Syntax

idx_t duckdb_list_vector_get_size(
  duckdb_vector vector
);

Parameter

vector: Der Vektor

Rückgabewert

Die Größe der Kindliste

`duckdb_list_vector_set_size`

Setzt die Gesamtgröße des zugrunde liegenden Kindvektors eines Listenvektors.

Syntax

duckdb_state duckdb_list_vector_set_size(
  duckdb_vector vector,
  idx_t size
);

Parameter

vector: Der Listenvektor.
size: Die Größe der Kindliste.

Rückgabewert

Der DuckDB-Status. Gibt DuckDBError zurück, wenn der Vektor nullptr ist.

`duckdb_list_vector_reserve`

Setzt die Gesamtkapazität des zugrunde liegenden Kindvektors einer Liste.

Nach dem Aufruf dieser Methode müssen Sie duckdb_vector_get_validity und duckdb_vector_get_data aufrufen, um die aktuellen Daten- und Validity-Zeiger zu erhalten

Syntax

duckdb_state duckdb_list_vector_reserve(
  duckdb_vector vector,
  idx_t required_capacity
);

Parameter

vector: Der Listenvektor.
required_capacity: the total capacity to reserve.

Rückgabewert

Der DuckDB-Status. Gibt DuckDBError zurück, wenn der Vektor nullptr ist.

`duckdb_struct_vector_get_child`

Ruft den Kindvektor eines Struct-Vektors ab. Der resultierende Vektor ist gültig, solange der Elternvektor gültig ist.

Syntax

duckdb_vector duckdb_struct_vector_get_child(
  duckdb_vector vector,
  idx_t index
);

Parameter

vector: Der Vektor
index: Der Child-Index

Rückgabewert

Der Kindvektor

`duckdb_array_vector_get_child`

Ruft den Kindvektor eines Array-Vektors ab. Der resultierende Vektor ist gültig, solange der Elternvektor gültig ist. Der resultierende Vektor hat die Größe des Elternvektors multipliziert mit der Array-Größe.

Syntax

duckdb_vector duckdb_array_vector_get_child(
  duckdb_vector vector
);

Parameter

vector: Der Vektor

Rückgabewert

Der Kindvektor

`duckdb_slice_vector`

Schneidet einen Vektor mit einem Selection-Vektor zu. Die Länge des Selection-Vektors muss kleiner oder gleich der Länge des Vektors sein. Macht den Vektor zu einem Dictionary-Vektor.

Syntax

void duckdb_slice_vector(
  duckdb_vector vector,
  duckdb_selection_vector sel,
  idx_t len
);

Parameter

vector: Der Vektor to slice.
sel: Der Selection-Vektor.
len: Die Länge des Selektionsvektors.

`duckdb_vector_copy_sel`

Kopiert den src-Vektor nach dst mit einem Selection-Vektor, der die zu kopierenden Indizes angibt.

Syntax

void duckdb_vector_copy_sel(
  duckdb_vector src,
  duckdb_vector dst,
  duckdb_selection_vector sel,
  idx_t src_count,
  idx_t src_offset,
  idx_t dst_offset
);

Parameter

src: Der Vektor to copy from.
dst: Der Vektor to copy to.
sel: Der Selection-Vektor. The length of the selection vector should not be more than the length of the src vector
src_count: Die Anzahl der aus dem Selektionsvektor zu kopierenden Einträge. Think of this as the effective length of the selection vector starting from index 0
src_offset: Der Offset im Selektionsvektor, ab dem kopiert wird (wichtig: tatsächliche Anzahl kopierter Elemente = src_count - src_offset).
dst_offset: Der Offset im Zielvektor, ab dem kopiert wird.

`duckdb_vector_reference_value`

Kopiert den Wert von value nach vector.

Syntax

void duckdb_vector_reference_value(
  duckdb_vector vector,
  duckdb_value value
);

Parameter

vector: Der empfangende Vektor.
value: Der in den Vektor zu kopierende Wert.

`duckdb_vector_reference_vector`

Ändert to_vector so, dass er from_vector referenziert. Anschließend teilen sich die Vektoren das Eigentum an den Daten.

Syntax

void duckdb_vector_reference_vector(
  duckdb_vector to_vector,
  duckdb_vector from_vector
);

Parameter

to_vector: Der empfangende Vektor.
from_vector: Der Vektor to reference.

`duckdb_validity_row_is_valid`

Gibt zurück, ob eine Zeile in der angegebenen Validity-Maske gültig (d. h. nicht NULL) ist.

Syntax

bool duckdb_validity_row_is_valid(
  uint64_t *validity,
  idx_t row
);

Parameter

validity: Die Gültigkeitsmaske, wie über duckdb_vector_get_validity ermittelt
row: Der Zeilenindex

Rückgabewert

true, wenn die Zeile gültig ist, sonst false

`duckdb_validity_set_row_validity`

Setzt in einer Validity-Maske eine bestimmte Zeile auf gültig oder ungültig.

Beachten Sie, dass duckdb_vector_ensure_validity_writable vor duckdb_vector_get_validity aufgerufen werden sollte, um sicherzustellen, dass eine Validity-Maske zum Schreiben vorhanden ist.

Syntax

void duckdb_validity_set_row_validity(
  uint64_t *validity,
  idx_t row,
  bool valid
);

Parameter

validity: Die Gültigkeitsmaske, wie über duckdb_vector_get_validity ermittelt.
row: Der Zeilenindex
valid: Ob die Zeile auf gültig oder ungültig gesetzt werden soll

`duckdb_validity_set_row_invalid`

Setzt in einer Validity-Maske eine bestimmte Zeile auf ungültig.

Entspricht duckdb_validity_set_row_validity mit valid auf false gesetzt.

Syntax

void duckdb_validity_set_row_invalid(
  uint64_t *validity,
  idx_t row
);

Parameter

validity: Die Gültigkeitsmaske
row: Der Zeilenindex

`duckdb_validity_set_row_valid`

Setzt in einer Validity-Maske eine bestimmte Zeile auf gültig.

Entspricht duckdb_validity_set_row_validity mit valid auf true gesetzt.

Syntax

void duckdb_validity_set_row_valid(
  uint64_t *validity,
  idx_t row
);

Parameter

validity: Die Gültigkeitsmaske
row: Der Zeilenindex

`duckdb_create_scalar_function`

Erzeugt eine neue leere Skalarfunktion.

Der Rückgabewert muss mit duckdb_destroy_scalar_function zerstört werden.

Rückgabewert

Das Skalarfunktionsobjekt.

Syntax

duckdb_scalar_function duckdb_create_scalar_function(
  
);

`duckdb_destroy_scalar_function`

Zerstört das angegebene Skalarfunktionsobjekt.

Syntax

void duckdb_destroy_scalar_function(
  duckdb_scalar_function *scalar_function
);

Parameter

scalar_function: Die zu zerstörende Skalarfunktion

`duckdb_scalar_function_set_name`

Setzt den Namen der angegebenen Skalarfunktion.

Syntax

void duckdb_scalar_function_set_name(
  duckdb_scalar_function scalar_function,
  const char *name
);

Parameter

scalar_function: Die Skalarfunktion
name: Der Name der Skalarfunktion

`duckdb_scalar_function_set_varargs`

Setzt die Parameter der angegebenen Skalarfunktion auf Varargs. Es ist nicht erforderlich, Parameter mit duckdb_scalar_function_add_parameter hinzuzufügen.

Syntax

void duckdb_scalar_function_set_varargs(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);

Parameter

scalar_function: Die Skalarfunktion.
type: Der Typ der Argumente.

Rückgabewert

Der Parametertyp. Darf nicht INVALID enthalten.

`duckdb_scalar_function_set_special_handling`

Setzt das NULL-Verhalten der Skalarfunktion auf special.

Syntax

void duckdb_scalar_function_set_special_handling(
  duckdb_scalar_function scalar_function
);

Parameter

scalar_function: Die Skalarfunktion.

`duckdb_scalar_function_set_volatile`

Setzt die Funktionsstabilität der Skalarfunktion auf VOLATILE, d. h. die Funktion sollte für jede Zeile erneut ausgeführt werden. Dies schränkt die mögliche Optimierung der Funktion ein.

Syntax

void duckdb_scalar_function_set_volatile(
  duckdb_scalar_function scalar_function
);

Parameter

scalar_function: Die Skalarfunktion.

`duckdb_scalar_function_add_parameter`

Fügt der Skalarfunktion einen Parameter hinzu.

Syntax

void duckdb_scalar_function_add_parameter(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);

Parameter

scalar_function: Die Skalarfunktion.
type: Der Parametertyp. Darf nicht INVALID enthalten.

`duckdb_scalar_function_set_return_type`

Setzt den Rückgabetyp der Skalarfunktion.

Syntax

void duckdb_scalar_function_set_return_type(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);

Parameter

scalar_function: Die Skalarfunktion
type: Darf kein INVALID oder ANY enthalten.

`duckdb_scalar_function_set_extra_info`

Weist der Skalarfunktion Extra-Informationen zu, die z. B. während des Bindens abgerufen werden können.

Syntax

void duckdb_scalar_function_set_extra_info(
  duckdb_scalar_function scalar_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);

Parameter

scalar_function: Die Skalarfunktion
extra_info: Die Extra-Informationenrmation
destroy: Der Callback, der aufgerufen wird, um die Extra-Informationen zu zerstören (falls vorhanden)

`duckdb_scalar_function_set_bind`

Setzt die (optionale) Bind-Funktion der Skalarfunktion.

Syntax

void duckdb_scalar_function_set_bind(
  duckdb_scalar_function scalar_function,
  duckdb_scalar_function_bind_t bind
);

Parameter

scalar_function: Die Skalarfunktion.
bind: Die Bind-Funktion.

`duckdb_scalar_function_set_bind_data`

Setzt die benutzerdefinierten Bind-Daten im Bind-Objekt der Skalarfunktion. Das Bind-Datenobjekt kann während der Ausführung wieder abgerufen werden. In den meisten Fällen müssen Sie auch den Copy-Callback Ihrer Bind-Daten über duckdb_scalar_function_set_bind_data_copy setzen.

Syntax

void duckdb_scalar_function_set_bind_data(
  duckdb_bind_info info,
  void *bind_data,
  duckdb_delete_callback_t destroy
);

Parameter

info: Die Bind-Infos der Skalarfunktion.
bind_data: Das Bind-Datenobjekt.
destroy: Der Callback zum Zerstören der Bind-Daten (falls vorhanden).

`duckdb_scalar_function_set_bind_data_copy`

Setzt den Copy-Callback für die benutzerdefinierten Bind-Daten im Bind-Objekt der Skalarfunktion.

Syntax

void duckdb_scalar_function_set_bind_data_copy(
  duckdb_bind_info info,
  duckdb_copy_callback_t copy
);

Parameter

info: Die Bind-Infos der Skalarfunktion.
copy: Der Callback zum Kopieren der Bind-Daten (falls vorhanden).

`duckdb_scalar_function_bind_set_error`

Meldet, dass beim Aufruf von bind einer Skalarfunktion ein Fehler aufgetreten ist.

Syntax

void duckdb_scalar_function_bind_set_error(
  duckdb_bind_info info,
  const char *error
);

Parameter

info: Das Bind-Info-Objekt.
error: Die Fehlermeldung.

`duckdb_scalar_function_set_function`

Setzt die Hauptfunktion der Skalarfunktion.

Syntax

void duckdb_scalar_function_set_function(
  duckdb_scalar_function scalar_function,
  duckdb_scalar_function_t function
);

Parameter

scalar_function: Die Skalarfunktion
function: Die Funktion

`duckdb_register_scalar_function`

Registriert das Skalarfunktionsobjekt in der angegebenen Verbindung.

Die Funktion erfordert mindestens einen Namen, eine Funktion und einen Rückgabetyp.

Wenn die Funktion unvollständig ist oder bereits eine Funktion mit diesem Namen existiert, wird DuckDBError zurückgegeben.

Syntax

duckdb_state duckdb_register_scalar_function(
  duckdb_connection con,
  duckdb_scalar_function scalar_function
);

Parameter

con: Die Verbindung, in der registriert wird.
scalar_function: Der Funktionszeiger

Rückgabewert

Ob die Registrierung erfolgreich war.

`duckdb_scalar_function_get_extra_info`

Ruft die Extra-Informationen der Funktion ab, wie in duckdb_scalar_function_set_extra_info gesetzt.

Syntax

void *duckdb_scalar_function_get_extra_info(
  duckdb_function_info info
);

Parameter

info: Das Info-Objekt.

Rückgabewert

Die Extra-Informationen.

`duckdb_scalar_function_bind_get_extra_info`

Ruft die Extra-Informationen der Funktion ab, wie in den Bind-Informationen gesetzt.

Syntax

void *duckdb_scalar_function_bind_get_extra_info(
  duckdb_bind_info info
);

Parameter

info: Das Info-Objekt.

Rückgabewert

Die Extra-Informationen.

`duckdb_scalar_function_get_bind_data`

Ruft die mit duckdb_scalar_function_set_bind_data gesetzten Bind-Daten der Skalarfunktion ab. Beachten Sie, dass die Bind-Daten schreibgeschützt sind.

Syntax

void *duckdb_scalar_function_get_bind_data(
  duckdb_function_info info
);

Parameter

info: Die Funktions-Infos.

Rückgabewert

Das Bind-Datenobjekt.

`duckdb_scalar_function_get_client_context`

Ruft den Client-Kontext der Bind-Informationen einer Skalarfunktion ab.

Syntax

void duckdb_scalar_function_get_client_context(
  duckdb_bind_info info,
  duckdb_client_context *out_context
);

Parameter

info: Das Bind-Info-Objekt der Skalarfunktion.
out_context: Der Client-Kontext der Bind-Infos. Must be destroyed with duckdb_destroy_client_context.

`duckdb_scalar_function_set_error`

Meldet, dass bei der Ausführung der Skalarfunktion ein Fehler aufgetreten ist.

Syntax

void duckdb_scalar_function_set_error(
  duckdb_function_info info,
  const char *error
);

Parameter

info: Das Info-Objekt.
error: Die Fehlermeldung

`duckdb_create_scalar_function_set`

Erzeugt einen neuen leeren Skalarfunktionssatz.

Der Rückgabewert muss mit duckdb_destroy_scalar_function_set zerstört werden.

Rückgabewert

Das Skalarfunktionssatz-Objekt.

Syntax

duckdb_scalar_function_set duckdb_create_scalar_function_set(
  const char *name
);

`duckdb_destroy_scalar_function_set`

Zerstört das angegebene Skalarfunktionssatz-Objekt.

Syntax

void duckdb_destroy_scalar_function_set(
  duckdb_scalar_function_set *scalar_function_set
);

`duckdb_add_scalar_function_to_set`

Fügt die Skalarfunktion als neue Überladung zum Skalarfunktionssatz hinzu.

Gibt DuckDBError zurück, wenn die Funktion nicht hinzugefügt werden konnte, z. B. wenn die Überladung bereits existiert.

Syntax

duckdb_state duckdb_add_scalar_function_to_set(
  duckdb_scalar_function_set set,
  duckdb_scalar_function function
);

Parameter

set: Der Skalarfunktionssatz
function: Die hinzuzufügende Funktion

`duckdb_register_scalar_function_set`

Registriert den Skalarfunktionssatz in der angegebenen Verbindung.

Der Satz erfordert mindestens eine gültige Überladung.

Wenn der Satz unvollständig ist oder bereits eine Funktion mit diesem Namen existiert, wird DuckDBError zurückgegeben.

Syntax

duckdb_state duckdb_register_scalar_function_set(
  duckdb_connection con,
  duckdb_scalar_function_set set
);

Parameter

con: Die Verbindung, in der registriert wird.
set: Der zu registrierende Funktionssatz

Rückgabewert

Ob die Registrierung erfolgreich war.

`duckdb_scalar_function_bind_get_argument_count`

Gibt die Anzahl der Eingabeargumente der Skalarfunktion zurück.

Syntax

idx_t duckdb_scalar_function_bind_get_argument_count(
  duckdb_bind_info info
);

Parameter

info: Die Bind-Infos.

Rückgabewert

Die Anzahl der Eingabeargumente.

`duckdb_scalar_function_bind_get_argument`

Gibt das Eingabeargument am Index der Skalarfunktion zurück.

Syntax

duckdb_expression duckdb_scalar_function_bind_get_argument(
  duckdb_bind_info info,
  idx_t index
);

Parameter

info: Die Bind-Infos.
index: Der Argumentindex.

Rückgabewert

Das Eingabeargument am Index. Muss mit duckdb_destroy_expression zerstört werden.

`duckdb_create_selection_vector`

Erzeugt einen neuen Selection-Vektor der Größe size. Muss mit duckdb_destroy_selection_vector zerstört werden.

Syntax

duckdb_selection_vector duckdb_create_selection_vector(
  idx_t size
);

Parameter

size: Die Größe des Selektionsvektors.

Rückgabewert

Der Selection-Vektor.

`duckdb_destroy_selection_vector`

Zerstört den Selection-Vektor und gibt seinen Speicher frei.

Syntax

void duckdb_destroy_selection_vector(
  duckdb_selection_vector sel
);

Parameter

sel: Der Selection-Vektor.

`duckdb_selection_vector_get_data_ptr`

Greift auf den Datenzeiger eines Selection-Vektors zu.

Syntax

sel_t *duckdb_selection_vector_get_data_ptr(
  duckdb_selection_vector sel
);

Parameter

sel: Der Selection-Vektor.

Rückgabewert

Der Datenzeiger.

`duckdb_create_aggregate_function`

Erzeugt eine neue leere Aggregatfunktion.

Der Rückgabewert sollte mit duckdb_destroy_aggregate_function zerstört werden.

Rückgabewert

Das Aggregatfunktionsobjekt.

Syntax

duckdb_aggregate_function duckdb_create_aggregate_function(
  
);

`duckdb_destroy_aggregate_function`

Zerstört das angegebene Aggregatfunktionsobjekt.

Syntax

void duckdb_destroy_aggregate_function(
  duckdb_aggregate_function *aggregate_function
);

`duckdb_aggregate_function_set_name`

Setzt den Namen der angegebenen Aggregatfunktion.

Syntax

void duckdb_aggregate_function_set_name(
  duckdb_aggregate_function aggregate_function,
  const char *name
);

Parameter

aggregate_function: Die Aggregatfunktion
name: Der Name der Aggregatfunktion

`duckdb_aggregate_function_add_parameter`

Fügt der Aggregatfunktion einen Parameter hinzu.

Syntax

void duckdb_aggregate_function_add_parameter(
  duckdb_aggregate_function aggregate_function,
  duckdb_logical_type type
);

Parameter

aggregate_function: Die Aggregatfunktion.
type: Der Parametertyp. Darf nicht INVALID enthalten.

`duckdb_aggregate_function_set_return_type`

Setzt den Rückgabetyp der Aggregatfunktion.

Syntax

void duckdb_aggregate_function_set_return_type(
  duckdb_aggregate_function aggregate_function,
  duckdb_logical_type type
);

Parameter

aggregate_function: Die Aggregatfunktion.
type: Der Rückgabetyp. Darf kein INVALID oder ANY enthalten.

`duckdb_aggregate_function_set_functions`

Setzt die Hauptfunktionen der Aggregatfunktion.

Syntax

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
);

Parameter

aggregate_function: Die Aggregatfunktion
state_size: state size
state_init: state init function
update: update states
combine: combine states
finalize: finalize states

`duckdb_aggregate_function_set_destructor`

Setzt den State-Destruktor-Callback der Aggregatfunktion (optional)

Syntax

void duckdb_aggregate_function_set_destructor(
  duckdb_aggregate_function aggregate_function,
  duckdb_aggregate_destroy_t destroy
);

Parameter

aggregate_function: Die Aggregatfunktion
destroy: state destroy callback

`duckdb_register_aggregate_function`

Registriert das Aggregatfunktionsobjekt in der angegebenen Verbindung.

Die Funktion erfordert mindestens einen Namen, Funktionen und einen Rückgabetyp.

Wenn die Funktion unvollständig ist oder bereits eine Funktion mit diesem Namen existiert, wird DuckDBError zurückgegeben.

Syntax

duckdb_state duckdb_register_aggregate_function(
  duckdb_connection con,
  duckdb_aggregate_function aggregate_function
);

Parameter

con: Die Verbindung, in der registriert wird.

Rückgabewert

Ob die Registrierung erfolgreich war.

`duckdb_aggregate_function_set_special_handling`

Setzt die NULL-Behandlung der Aggregatfunktion auf SPECIAL_HANDLING.

Syntax

void duckdb_aggregate_function_set_special_handling(
  duckdb_aggregate_function aggregate_function
);

Parameter

aggregate_function: Die Aggregatfunktion

`duckdb_aggregate_function_set_extra_info`

Weist der Skalarfunktion Extra-Informationen zu, die z. B. während des Bindens abgerufen werden können.

Syntax

void duckdb_aggregate_function_set_extra_info(
  duckdb_aggregate_function aggregate_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);

Parameter

aggregate_function: Die Aggregatfunktion
extra_info: Die Extra-Informationenrmation
destroy: Der Callback, der aufgerufen wird, um die Extra-Informationen zu zerstören (falls vorhanden)

`duckdb_aggregate_function_get_extra_info`

Ruft die Extra-Informationen der Funktion ab, wie in duckdb_aggregate_function_set_extra_info gesetzt.

Syntax

void *duckdb_aggregate_function_get_extra_info(
  duckdb_function_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Die Extra-Informationen

`duckdb_aggregate_function_set_error`

Meldet, dass bei der Ausführung der Aggregatfunktion ein Fehler aufgetreten ist.

Syntax

void duckdb_aggregate_function_set_error(
  duckdb_function_info info,
  const char *error
);

Parameter

info: Das Info-Objekt
error: Die Fehlermeldung

`duckdb_create_aggregate_function_set`

Erzeugt einen neuen leeren Aggregatfunktionssatz.

Der Rückgabewert sollte mit duckdb_destroy_aggregate_function_set zerstört werden.

Rückgabewert

Das Aggregatfunktionssatz-Objekt.

Syntax

duckdb_aggregate_function_set duckdb_create_aggregate_function_set(
  const char *name
);

`duckdb_destroy_aggregate_function_set`

Zerstört das angegebene Aggregatfunktionssatz-Objekt.

Syntax

void duckdb_destroy_aggregate_function_set(
  duckdb_aggregate_function_set *aggregate_function_set
);

`duckdb_add_aggregate_function_to_set`

Fügt die Aggregatfunktion als neue Überladung zum Aggregatfunktionssatz hinzu.

Gibt DuckDBError zurück, wenn die Funktion nicht hinzugefügt werden konnte, z. B. wenn die Überladung bereits existiert.

Syntax

duckdb_state duckdb_add_aggregate_function_to_set(
  duckdb_aggregate_function_set set,
  duckdb_aggregate_function function
);

Parameter

set: Der Aggregatfunktionssatz
function: Die hinzuzufügende Funktion

`duckdb_register_aggregate_function_set`

Registriert den Aggregatfunktionssatz in der angegebenen Verbindung.

Der Satz erfordert mindestens eine gültige Überladung.

Wenn der Satz unvollständig ist oder bereits eine Funktion mit diesem Namen existiert, wird DuckDBError zurückgegeben.

Syntax

duckdb_state duckdb_register_aggregate_function_set(
  duckdb_connection con,
  duckdb_aggregate_function_set set
);

Parameter

con: Die Verbindung, in der registriert wird.
set: Der zu registrierende Funktionssatz

Rückgabewert

Ob die Registrierung erfolgreich war.

`duckdb_create_table_function`

Erzeugt eine neue leere Tabellenfunktion.

Der Rückgabewert sollte mit duckdb_destroy_table_function zerstört werden.

Rückgabewert

Das Tabellenfunktionsobjekt.

Syntax

duckdb_table_function duckdb_create_table_function(
  
);

`duckdb_destroy_table_function`

Zerstört das angegebene Tabellenfunktionsobjekt.

Syntax

void duckdb_destroy_table_function(
  duckdb_table_function *table_function
);

Parameter

table_function: Die zu zerstörende Tabellenfunktion

`duckdb_table_function_set_name`

Setzt den Namen der angegebenen Tabellenfunktion.

Syntax

void duckdb_table_function_set_name(
  duckdb_table_function table_function,
  const char *name
);

Parameter

table_function: Die Tabellenfunktion
name: Der Name der Tabellenfunktion

`duckdb_table_function_add_parameter`

Fügt der Tabellenfunktion einen Parameter hinzu.

Syntax

void duckdb_table_function_add_parameter(
  duckdb_table_function table_function,
  duckdb_logical_type type
);

Parameter

table_function: Die Tabellenfunktion.
type: Der Parametertyp. Darf nicht INVALID enthalten.

`duckdb_table_function_add_named_parameter`

Fügt der Tabellenfunktion einen benannten Parameter hinzu.

Syntax

void duckdb_table_function_add_named_parameter(
  duckdb_table_function table_function,
  const char *name,
  duckdb_logical_type type
);

Parameter

table_function: Die Tabellenfunktion.
name: Der Parametername.
type: Der Parametertyp. Darf nicht INVALID enthalten.

`duckdb_table_function_set_extra_info`

Weist der Tabellenfunktion Extra-Informationen zu, die z. B. während des Bindens abgerufen werden können.

Syntax

void duckdb_table_function_set_extra_info(
  duckdb_table_function table_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);

Parameter

table_function: Die Tabellenfunktion
extra_info: Die Extra-Informationenrmation
destroy: Der Callback, der aufgerufen wird, um die Extra-Informationen zu zerstören (falls vorhanden)

`duckdb_table_function_set_bind`

Setzt die Bind-Funktion der Tabellenfunktion.

Syntax

void duckdb_table_function_set_bind(
  duckdb_table_function table_function,
  duckdb_table_function_bind_t bind
);

Parameter

table_function: Die Tabellenfunktion
bind: Die Bind-Funktion

`duckdb_table_function_set_init`

Setzt die Init-Funktion der Tabellenfunktion.

Syntax

void duckdb_table_function_set_init(
  duckdb_table_function table_function,
  duckdb_table_function_init_t init
);

Parameter

table_function: Die Tabellenfunktion
init: Die Init-Funktion

`duckdb_table_function_set_local_init`

Setzt die threadlokale Init-Funktion der Tabellenfunktion.

Syntax

void duckdb_table_function_set_local_init(
  duckdb_table_function table_function,
  duckdb_table_function_init_t init
);

Parameter

table_function: Die Tabellenfunktion
init: Die Init-Funktion

`duckdb_table_function_set_function`

Setzt die Hauptfunktion der Tabellenfunktion.

Syntax

void duckdb_table_function_set_function(
  duckdb_table_function table_function,
  duckdb_table_function_t function
);

Parameter

table_function: Die Tabellenfunktion
function: Die Funktion

`duckdb_table_function_supports_projection_pushdown`

Setzt, ob die angegebene Tabellenfunktion Projection Pushdown unterstützt.

Wenn dies auf true gesetzt ist, stellt das System in der init-Phase eine Liste aller benötigten Spalten über die Funktionen duckdb_init_get_column_count und duckdb_init_get_column_index bereit. Wenn dies auf false gesetzt ist (der Standard), erwartet das System, dass alle Spalten projiziert werden.

Syntax

void duckdb_table_function_supports_projection_pushdown(
  duckdb_table_function table_function,
  bool pushdown
);

Parameter

table_function: Die Tabellenfunktion
pushdown: True, wenn die Tabellenfunktion Projection Pushdown unterstützt, andernfalls false.

`duckdb_register_table_function`

Registriert das Tabellenfunktionsobjekt in der angegebenen Verbindung.

Die Funktion erfordert mindestens einen Namen, eine Bind-Funktion, eine Init-Funktion und eine Hauptfunktion.

Wenn die Funktion unvollständig ist oder bereits eine Funktion mit diesem Namen existiert, wird DuckDBError zurückgegeben.

Syntax

duckdb_state duckdb_register_table_function(
  duckdb_connection con,
  duckdb_table_function function
);

Parameter

con: Die Verbindung, in der registriert wird.
function: Der Funktionszeiger

Rückgabewert

Ob die Registrierung erfolgreich war.

`duckdb_bind_get_extra_info`

Ruft die Extra-Informationen der Funktion ab, wie in duckdb_table_function_set_extra_info gesetzt.

Syntax

void *duckdb_bind_get_extra_info(
  duckdb_bind_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Die Extra-Informationen

`duckdb_table_function_get_client_context`

Ruft den Client-Kontext der Bind-Informationen einer Tabellenfunktion ab.

Syntax

void duckdb_table_function_get_client_context(
  duckdb_bind_info info,
  duckdb_client_context *out_context
);

Parameter

info: Das Bind-Info-Objekt der Tabellenfunktion.
out_context: Der Client-Kontext der Bind-Infos. Must be destroyed with duckdb_destroy_client_context.

`duckdb_bind_add_result_column`

Fügt dem Ausgabeergebnis der Tabellenfunktion eine Ergebnis-Spalte hinzu.

Syntax

void duckdb_bind_add_result_column(
  duckdb_bind_info info,
  const char *name,
  duckdb_logical_type type
);

Parameter

info: Die Bind-Infos der Tabellenfunktion.
name: Der Spaltenname.
type: Der logische Spaltentyp.

`duckdb_bind_get_parameter_count`

Ruft die Anzahl der regulären (nicht benannten) Parameter der Funktion ab.

Syntax

idx_t duckdb_bind_get_parameter_count(
  duckdb_bind_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Die Anzahl der Parameter

`duckdb_bind_get_parameter`

Ruft den Parameter am angegebenen Index ab.

Das Ergebnis muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_bind_get_parameter(
  duckdb_bind_info info,
  idx_t index
);

Parameter

info: Das Info-Objekt
index: Der Index des zu holenden Parameters

Rückgabewert

Der Wert des Parameter. Muss mit duckdb_destroy_value zerstört werden.

`duckdb_bind_get_named_parameter`

Ruft einen benannten Parameter mit dem angegebenen Namen ab.

Das Ergebnis muss mit duckdb_destroy_value zerstört werden.

Syntax

duckdb_value duckdb_bind_get_named_parameter(
  duckdb_bind_info info,
  const char *name
);

Parameter

info: Das Info-Objekt
name: Der Name des Parameters

Rückgabewert

Der Wert des Parameter. Muss mit duckdb_destroy_value zerstört werden.

`duckdb_bind_set_bind_data`

Setzt die benutzerdefinierten Bind-Daten im Bind-Objekt der Tabellenfunktion. Dieses Objekt kann während der Ausführung wieder abgerufen werden.

Syntax

void duckdb_bind_set_bind_data(
  duckdb_bind_info info,
  void *bind_data,
  duckdb_delete_callback_t destroy
);

Parameter

info: Die Bind-Infos der Tabellenfunktion.
bind_data: Das Bind-Datenobjekt.
destroy: Der Callback zum Zerstören der Bind-Daten (falls vorhanden).

`duckdb_bind_set_cardinality`

Setzt die Kardinalitätsschätzung der Tabellenfunktion, die für die Optimierung verwendet wird.

Syntax

void duckdb_bind_set_cardinality(
  duckdb_bind_info info,
  idx_t cardinality,
  bool is_exact
);

Parameter

info: Das Bind-Datenobjekt.
is_exact: Ob die Kardinalitätsschätzung exakt oder eine Näherung ist

`duckdb_bind_set_error`

Meldet, dass beim Aufruf von bind einer Tabellenfunktion ein Fehler aufgetreten ist.

Syntax

void duckdb_bind_set_error(
  duckdb_bind_info info,
  const char *error
);

Parameter

info: Das Info-Objekt
error: Die Fehlermeldung

`duckdb_init_get_extra_info`

Ruft die Extra-Informationen der Funktion ab, wie in duckdb_table_function_set_extra_info gesetzt.

Syntax

void *duckdb_init_get_extra_info(
  duckdb_init_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Die Extra-Informationen

`duckdb_init_get_bind_data`

Ruft die mit duckdb_bind_set_bind_data während des Bindens gesetzten Bind-Daten ab.

Beachten Sie, dass die Bind-Daten als schreibgeschützt betrachtet werden sollten. Für Zustandsverfolgung verwenden Sie stattdessen die Init-Daten.

Syntax

void *duckdb_init_get_bind_data(
  duckdb_init_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Das Bind-Datenobjekt

`duckdb_init_set_init_data`

Setzt die benutzerdefinierten Init-Daten im Init-Objekt. Dieses Objekt kann während der Ausführung wieder abgerufen werden.

Syntax

void duckdb_init_set_init_data(
  duckdb_init_info info,
  void *init_data,
  duckdb_delete_callback_t destroy
);

Parameter

info: Das Info-Objekt
init_data: Das Init-Datenobjekt.
destroy: Der Callback, der aufgerufen wird, um die Init-Daten zu zerstören (falls vorhanden)

`duckdb_init_get_column_count`

Gibt die Anzahl der projizierten Spalten zurück.

Diese Funktion muss verwendet werden, wenn Projection Pushdown aktiviert ist, um festzustellen, welche Spalten ausgegeben werden sollen.

Syntax

idx_t duckdb_init_get_column_count(
  duckdb_init_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Die Anzahl der projizierten Spalten.

`duckdb_init_get_column_index`

Gibt den Spaltenindex der projizierten Spalte an der angegebenen Position zurück.

Diese Funktion muss verwendet werden, wenn Projection Pushdown aktiviert ist, um festzustellen, welche Spalten ausgegeben werden sollen.

Syntax

idx_t duckdb_init_get_column_index(
  duckdb_init_info info,
  idx_t column_index
);

Parameter

info: Das Info-Objekt
column_index: Der Index, an dem der projizierte Spaltenindex geholt wird, von 0..duckdb_init_get_column_count(info)

Rückgabewert

Der Spaltenindex der projizierten Spalte.

`duckdb_init_set_max_threads`

Setzt, wie viele Threads diese Tabellenfunktion parallel verarbeiten können (Standard: 1)

Syntax

void duckdb_init_set_max_threads(
  duckdb_init_info info,
  idx_t max_threads
);

Parameter

info: Das Info-Objekt
max_threads: Die maximale Anzahl von Threads, die diese Tabellenfunktion verarbeiten können

`duckdb_init_set_error`

Meldet, dass beim Aufruf von init ein Fehler aufgetreten ist.

Syntax

void duckdb_init_set_error(
  duckdb_init_info info,
  const char *error
);

Parameter

info: Das Info-Objekt
error: Die Fehlermeldung

`duckdb_function_get_extra_info`

Ruft die Extra-Informationen der Funktion ab, wie in duckdb_table_function_set_extra_info gesetzt.

Syntax

void *duckdb_function_get_extra_info(
  duckdb_function_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Die Extra-Informationen

`duckdb_function_get_bind_data`

Ruft die mit duckdb_bind_set_bind_data gesetzten Bind-Daten der Tabellenfunktion ab.

Beachten Sie, dass die Bind-Daten schreibgeschützt sind. Für Zustandsverfolgung verwenden Sie stattdessen die Init-Daten.

Syntax

void *duckdb_function_get_bind_data(
  duckdb_function_info info
);

Parameter

info: Das Funktions-Info-Objekt.

Rückgabewert

Das Bind-Datenobjekt.

`duckdb_function_get_init_data`

Ruft die mit duckdb_init_set_init_data während der Initialisierung gesetzten Init-Daten ab.

Syntax

void *duckdb_function_get_init_data(
  duckdb_function_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Das Init-Datenobjekt

`duckdb_function_get_local_init_data`

Ruft die threadlokalen Init-Daten ab, die mit duckdb_init_set_init_data während local_init gesetzt wurden.

Syntax

void *duckdb_function_get_local_init_data(
  duckdb_function_info info
);

Parameter

info: Das Info-Objekt

Rückgabewert

Das Init-Datenobjekt

`duckdb_function_set_error`

Meldet, dass bei der Ausführung der Funktion ein Fehler aufgetreten ist.

Syntax

void duckdb_function_set_error(
  duckdb_function_info info,
  const char *error
);

Parameter

info: Das Info-Objekt
error: Die Fehlermeldung

`duckdb_add_replacement_scan`

Fügt der angegebenen Datenbank eine Replacement-Scan-Definition hinzu.

Syntax

void duckdb_add_replacement_scan(
  duckdb_database db,
  duckdb_replacement_callback_t replacement,
  void *extra_data,
  duckdb_delete_callback_t delete_callback
);

Parameter

db: Das Datenbankobjekt, dem der Replacement Scan hinzugefügt wird
replacement: Der Replacement-Scan-Callback
extra_data: Extra-Daten, die an den angegebenen Callback zurückgegeben werden
delete_callback: Der Delete-Callback, der für die Extra-Daten aufgerufen wird, falls vorhanden

`duckdb_replacement_scan_set_function_name`

Setzt den Namen der Replacement-Funktion. Wird diese Funktion im Replacement-Callback aufgerufen, wird der Replacement Scan ausgeführt. Wird sie nicht aufgerufen, wird der Replacement-Callback nicht ausgeführt.

Syntax

void duckdb_replacement_scan_set_function_name(
  duckdb_replacement_scan_info info,
  const char *function_name
);

Parameter

info: Das Info-Objekt
function_name: Der Funktionsname, der eingesetzt werden soll.

`duckdb_replacement_scan_add_parameter`

Fügt der Replacement-Scan-Funktion einen Parameter hinzu.

Syntax

void duckdb_replacement_scan_add_parameter(
  duckdb_replacement_scan_info info,
  duckdb_value parameter
);

Parameter

info: Das Info-Objekt
parameter: Der hinzuzufügende Parameter.

`duckdb_replacement_scan_set_error`

Meldet, dass bei der Ausführung des Replacement Scans ein Fehler aufgetreten ist.

Syntax

void duckdb_replacement_scan_set_error(
  duckdb_replacement_scan_info info,
  const char *error
);

Parameter

info: Das Info-Objekt
error: Die Fehlermeldung

`duckdb_get_profiling_info`

Gibt den Wurzelknoten der Profiling-Informationen zurück. Gibt nullptr zurück, wenn Profiling nicht aktiviert ist.

Syntax

duckdb_profiling_info duckdb_get_profiling_info(
  duckdb_connection connection
);

Parameter

connection: Ein Verbindungsobjekt.

Rückgabewert

Ein Profiling-Informationsobjekt.

`duckdb_profiling_info_get_value`

Gibt den Wert der Metrik des aktuellen Profiling-Info-Knotens zurück. Gibt nullptr zurück, wenn die Metrik nicht existiert oder nicht aktiviert ist. Derzeit enthält der Wert einen String, den Sie über die entsprechende Funktion abrufen können: char *duckdb_get_varchar(duckdb_value value).

Syntax

duckdb_value duckdb_profiling_info_get_value(
  duckdb_profiling_info info,
  const char *key
);

Parameter

info: Ein Profiling-Informationsobjekt.
key: Der Name der angeforderten Metrik.

Rückgabewert

Der Wert der Metrik. Muss mit duckdb_destroy_value freigegeben werden

`duckdb_profiling_info_get_metrics`

Gibt die Key-Value-Metrik-Map dieses Profiling-Knotens als MAP-duckdb_value zurück. Die einzelnen Elemente sind über die duckdb_value-MAP-Funktionen zugänglich.

Syntax

duckdb_value duckdb_profiling_info_get_metrics(
  duckdb_profiling_info info
);

Parameter

info: Ein Profiling-Informationsobjekt.

Rückgabewert

Die Key-Value-Metrik-Map als MAP-duckdb_value.

`duckdb_profiling_info_get_child_count`

Gibt die Anzahl der Kinder im aktuellen Profiling-Info-Knoten zurück.

Syntax

idx_t duckdb_profiling_info_get_child_count(
  duckdb_profiling_info info
);

Parameter

info: Ein Profiling-Informationsobjekt.

Rückgabewert

Die Anzahl der Kinder im aktuellen Knoten.

`duckdb_profiling_info_get_child`

Gibt den Kindknoten am angegebenen Index zurück.

Syntax

duckdb_profiling_info duckdb_profiling_info_get_child(
  duckdb_profiling_info info,
  idx_t index
);

Parameter

info: Ein Profiling-Informationsobjekt.
index: Der Index des Kindknotens.

Rückgabewert

Der Kindknoten am angegebenen Index.

`duckdb_appender_create`

Erzeugt ein Appender-Objekt.

Beachten Sie, dass das Objekt mit duckdb_appender_destroy zerstört werden muss.

Syntax

duckdb_state duckdb_appender_create(
  duckdb_connection connection,
  const char *schema,
  const char *table,
  duckdb_appender *out_appender
);

Parameter

connection: Der Verbindungskontext, in dem der Appender erzeugt wird.
schema: Das Schema der Tabelle, an die angehängt wird, oder nullptr für das Standardschema.
table: Der Tabellenname, an den angehängt wird.
out_appender: Das resultierende Appender-Objekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_appender_create_ext`

Erzeugt ein Appender-Objekt.

Beachten Sie, dass das Objekt mit duckdb_appender_destroy zerstört werden muss.

Syntax

duckdb_state duckdb_appender_create_ext(
  duckdb_connection connection,
  const char *catalog,
  const char *schema,
  const char *table,
  duckdb_appender *out_appender
);

Parameter

connection: Der Verbindungskontext, in dem der Appender erzeugt wird.
catalog: Der Katalog der Tabelle, an die angehängt wird, oder nullptr für den Standardkatalog.
schema: Das Schema der Tabelle, an die angehängt wird, oder nullptr für das Standardschema.
table: Der Tabellenname, an den angehängt wird.
out_appender: Das resultierende Appender-Objekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_appender_create_query`

Erzeugt ein Appender-Objekt, das die angegebene Abfrage mit allen daran angehängten Daten ausführt.

Beachten Sie, dass das Objekt mit duckdb_appender_destroy zerstört werden muss.

Syntax

duckdb_state duckdb_appender_create_query(
  duckdb_connection connection,
  const char *query,
  idx_t column_count,
  duckdb_logical_type *types,
  const char *table_name,
  const char **column_names,
  duckdb_appender *out_appender
);

Parameter

connection: Der Verbindungskontext, in dem der Appender erzeugt wird.
query: Die auszuführende Abfrage, kann eine INSERT-, DELETE-, UPDATE- oder MERGE INTO-Anweisung sein.
column_count: Die Anzahl der anzuhängenden Spalten.
types: Die Typen der anzuhängenden Spalten.
table_name: (optionally) the table name used to refer to the appended data, defaults to “appended_data”.
column_names: (optionally) the list of column names, defaults to “col1”, “col2”, …
out_appender: Das resultierende Appender-Objekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_appender_column_count`

Gibt die Anzahl der Spalten zurück, die zum Appender gehören. Wenn keine aktive Spaltenliste vorhanden ist, entspricht dies den physischen Spalten der Tabelle.

Syntax

idx_t duckdb_appender_column_count(
  duckdb_appender appender
);

Parameter

appender: Der Appender, von dem die Spaltenanzahl geholt wird.

Rückgabewert

Die Anzahl der Spalten in den Data-Chunks.

`duckdb_appender_column_type`

Gibt den Typ der Spalte am angegebenen Index zurück. Dies ist entweder ein Typ in der aktiven Spaltenliste oder derselbe Typ wie eine Spalte in der Empfängertabelle.

Hinweis: Der resultierende Typ muss mit duckdb_destroy_logical_type zerstört werden.

Syntax

duckdb_logical_type duckdb_appender_column_type(
  duckdb_appender appender,
  idx_t col_idx
);

Parameter

appender: Der Appender, von dem der Spaltentyp geholt wird.
col_idx: Der Index der Spalte, deren Typ geholt wird.

Rückgabewert

Der duckdb_logical_type der Spalte.

`duckdb_appender_error`

Gibt die dem Appender zugeordnete Fehlermeldung zurück. Wenn der Appender keine Fehlermeldung hat, wird stattdessen nullptr zurückgegeben.

Die Fehlermeldung sollte nicht freigegeben werden. Sie wird freigegeben, wenn duckdb_appender_destroy aufgerufen wird.

Syntax

const char *duckdb_appender_error(
  duckdb_appender appender
);

Parameter

appender: Der Appender, von dem der Fehler geholt wird.

Rückgabewert

Die Fehlermeldung oder nullptr, wenn keine vorhanden ist.

`duckdb_appender_error_data`

Gibt die dem Appender zugeordneten Fehlerdaten zurück. Müssen mit duckdb_destroy_error_data zerstört werden.

Syntax

duckdb_error_data duckdb_appender_error_data(
  duckdb_appender appender
);

Parameter

appender: Der Appender, von dem die Fehlerdaten geholt werden.

Rückgabewert

Die Fehlerdaten.

`duckdb_appender_flush`

Schreibt den Appender in die Tabelle fort und leert dabei den Cache des Appenders. Wenn das Fortschreiben eine Constraint-Verletzung oder einen anderen Fehler auslöst, werden alle Daten ungültig, und diese Funktion gibt DuckDBError zurück. Es können keine weiteren Werte angehängt werden. Rufen Sie duckdb_appender_error_data auf, um die Fehlerdaten zu holen, und anschließend duckdb_appender_destroy, um den ungültigen Appender zu zerstören.

Syntax

duckdb_state duckdb_appender_flush(
  duckdb_appender appender
);

Parameter

appender: Der zu leerende Appender.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_appender_close`

Schließt den Appender, indem alle Zwischenzustände fortgeschrieben werden, und sperrt ihn für weitere Anhängungen. Wenn das Fortschreiben eine Constraint-Verletzung oder einen anderen Fehler auslöst, werden alle Daten ungültig, und diese Funktion gibt DuckDBError zurück. Rufen Sie duckdb_appender_error_data auf, um die Fehlerdaten zu holen, und anschließend duckdb_appender_destroy, um den ungültigen Appender zu zerstören.

Syntax

duckdb_state duckdb_appender_close(
  duckdb_appender appender
);

Parameter

appender: Der zu leerende und zu schließende Appender.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_appender_destroy`

Schließt den Appender, indem alle Zwischenzustände in die Tabelle fortgeschrieben und der Appender zerstört wird. Durch die Zerstörung gibt diese Funktion den gesamten dem Appender zugeordneten Speicher frei. Wenn das Fortschreiben eine Constraint-Verletzung auslöst, werden alle Daten ungültig, und diese Funktion gibt DuckDBError zurück. Durch die Zerstörung des Appenders ist es nicht mehr möglich, die konkrete Fehlermeldung mit duckdb_appender_error zu holen. Rufen Sie daher duckdb_appender_close auf, bevor Sie den Appender zerstören, wenn Sie die konkrete Fehlermeldung benötigen.

Syntax

duckdb_state duckdb_appender_destroy(
  duckdb_appender *appender
);

Parameter

appender: Der zu leerende, zu schließende und zu zerstörende Appender.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_appender_add_column`

Hängt eine Spalte an die aktive Spaltenliste des Appenders an. Schreibt alle bisherigen Daten sofort fort.

Die aktive Spaltenliste gibt alle Spalten an, die beim Fortschreiben der Daten erwartet werden. Inaktive Spalten werden mit ihrem Standardwert oder NULL gefüllt.

Syntax

duckdb_state duckdb_appender_add_column(
  duckdb_appender appender,
  const char *name
);

Parameter

appender: Der Appender, dem die Spalte hinzugefügt wird.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_appender_clear_columns`

Entfernt alle Spalten aus der aktiven Spaltenliste des Appenders und setzt den Appender so zurück, dass alle Spalten als aktiv gelten. Schreibt alle bisherigen Daten sofort fort.

Syntax

duckdb_state duckdb_appender_clear_columns(
  duckdb_appender appender
);

Parameter

appender: Der Appender, von dem die Spalten geleert werden.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_appender_begin_row`

Eine No-Op-Funktion aus Gründen der Rückwärtskompatibilität. Tut nichts. Nur duckdb_appender_end_row ist erforderlich.

Syntax

duckdb_state duckdb_appender_begin_row(
  duckdb_appender appender
);

`duckdb_appender_end_row`

Beendet die aktuelle Zeile der Anhängungen. Nach dem Aufruf von end_row kann die nächste Zeile angehängt werden.

Syntax

duckdb_state duckdb_appender_end_row(
  duckdb_appender appender
);

Parameter

appender: Der Appender.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_append_default`

Hängt einen DEFAULT-Wert (NULL, wenn DEFAULT für die Spalte nicht verfügbar ist) an den Appender an.

Syntax

duckdb_state duckdb_append_default(
  duckdb_appender appender
);

`duckdb_append_default_to_chunk`

Hängt einen DEFAULT-Wert an der angegebenen Zeile und Spalte (NULL, wenn DEFAULT für die Spalte nicht verfügbar ist) an den aus dem angegebenen Appender erzeugten Chunk an. Der Standardwert der Spalte muss ein konstanter Wert sein. Nichtdeterministische Ausdrücke wie nextval(‘seq’) oder random() werden nicht unterstützt.

Syntax

duckdb_state duckdb_append_default_to_chunk(
  duckdb_appender appender,
  duckdb_data_chunk chunk,
  idx_t col,
  idx_t row
);

Parameter

appender: Der Appender, von dem der Standardwert geholt wird.
chunk: Der Data Chunk, an den der Standardwert angehängt wird.
col: Der Chunk-Spaltenindex, an den der Standardwert angehängt wird.
row: Der Chunk-Zeilenindex, an den der Standardwert angehängt wird.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_append_bool`

Hängt einen Bool-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_bool(
  duckdb_appender appender,
  bool value
);

`duckdb_append_int8`

Hängt einen int8_t-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_int8(
  duckdb_appender appender,
  int8_t value
);

`duckdb_append_int16`

Hängt einen int16_t-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_int16(
  duckdb_appender appender,
  int16_t value
);

`duckdb_append_int32`

Hängt einen int32_t-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_int32(
  duckdb_appender appender,
  int32_t value
);

`duckdb_append_int64`

Hängt einen int64_t-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_int64(
  duckdb_appender appender,
  int64_t value
);

`duckdb_append_hugeint`

Hängt einen duckdb_hugeint-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_hugeint(
  duckdb_appender appender,
  duckdb_hugeint value
);

`duckdb_append_uint8`

Hängt einen uint8_t-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_uint8(
  duckdb_appender appender,
  uint8_t value
);

`duckdb_append_uint16`

Hängt einen uint16_t-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_uint16(
  duckdb_appender appender,
  uint16_t value
);

`duckdb_append_uint32`

Hängt einen uint32_t-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_uint32(
  duckdb_appender appender,
  uint32_t value
);

`duckdb_append_uint64`

Hängt einen uint64_t-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_uint64(
  duckdb_appender appender,
  uint64_t value
);

`duckdb_append_uhugeint`

Hängt einen duckdb_uhugeint-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_uhugeint(
  duckdb_appender appender,
  duckdb_uhugeint value
);

`duckdb_append_float`

Hängt einen Float-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_float(
  duckdb_appender appender,
  float value
);

`duckdb_append_double`

Hängt einen Double-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_double(
  duckdb_appender appender,
  double value
);

`duckdb_append_date`

Hängt einen duckdb_date-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_date(
  duckdb_appender appender,
  duckdb_date value
);

`duckdb_append_time`

Hängt einen duckdb_time-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_time(
  duckdb_appender appender,
  duckdb_time value
);

`duckdb_append_timestamp`

Hängt einen duckdb_timestamp-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_timestamp(
  duckdb_appender appender,
  duckdb_timestamp value
);

`duckdb_append_interval`

Hängt einen duckdb_interval-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_interval(
  duckdb_appender appender,
  duckdb_interval value
);

`duckdb_append_varchar`

Hängt einen VARCHAR-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_varchar(
  duckdb_appender appender,
  const char *val
);

`duckdb_append_varchar_length`

Hängt einen VARCHAR-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_varchar_length(
  duckdb_appender appender,
  const char *val,
  idx_t length
);

`duckdb_append_blob`

Hängt einen Blob-Wert an den Appender an.

Syntax

duckdb_state duckdb_append_blob(
  duckdb_appender appender,
  const void *data,
  idx_t length
);

`duckdb_append_null`

Hängt einen NULL-Wert (beliebigen Typs) an den Appender an.

Syntax

duckdb_state duckdb_append_null(
  duckdb_appender appender
);

`duckdb_append_value`

Hängt einen duckdb_value an den Appender an.

Syntax

duckdb_state duckdb_append_value(
  duckdb_appender appender,
  duckdb_value value
);

`duckdb_append_data_chunk`

Hängt einen vorausgefüllten Data-Chunk an den angegebenen Appender an. Versucht zu casten, wenn die Data-Chunk-Typen nicht mit den aktiven Appender-Typen übereinstimmen.

Syntax

duckdb_state duckdb_append_data_chunk(
  duckdb_appender appender,
  duckdb_data_chunk chunk
);

Parameter

appender: Der Appender, an den angehängt wird.
chunk: Der anzuhängende Data Chunk.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_table_description_create`

Erzeugt ein Tabellenbeschreibungsobjekt. Beachten Sie, dass duckdb_table_description_destroy immer für das resultierende table_description aufgerufen werden sollte, auch wenn die Funktion DuckDBError zurückgibt.

Syntax

duckdb_state duckdb_table_description_create(
  duckdb_connection connection,
  const char *schema,
  const char *table,
  duckdb_table_description *out
);

Parameter

connection: Der Verbindungskontext.
schema: Das Schema der Tabelle oder nullptr für das Standardschema.
table: Der Tabellenname.
out: Das resultierende Tabellenbeschreibungsobjekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_table_description_create_ext`

Erzeugt ein Tabellenbeschreibungsobjekt. Beachten Sie, dass duckdb_table_description_destroy für das resultierende table_description aufgerufen werden muss, auch wenn die Funktion DuckDBError zurückgibt.

Syntax

duckdb_state duckdb_table_description_create_ext(
  duckdb_connection connection,
  const char *catalog,
  const char *schema,
  const char *table,
  duckdb_table_description *out
);

Parameter

connection: Der Verbindungskontext.
catalog: Der Katalog- (Datenbank-)Name der Tabelle oder nullptr für den Standardkatalog.
schema: Das Schema der Tabelle oder nullptr für das Standardschema.
table: Der Tabellenname.
out: Das resultierende Tabellenbeschreibungsobjekt.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_table_description_destroy`

Zerstört das TableBeschreibung-Objekt.

Syntax

void duckdb_table_description_destroy(
  duckdb_table_description *table_description
);

Parameter

table_description: Die zu zerstörende table_description.

`duckdb_table_description_error`

Gibt die dem angegebenen table_description zugeordnete Fehlermeldung zurück. Wenn table_description keine Fehlermeldung hat, wird stattdessen nullptr zurückgegeben. Die Fehlermeldung sollte nicht freigegeben werden. Sie wird freigegeben, wenn duckdb_table_description_destroy aufgerufen wird.

Syntax

const char *duckdb_table_description_error(
  duckdb_table_description table_description
);

Parameter

table_description: Die table_description, von der der Fehler geholt wird.

Rückgabewert

Die Fehlermeldung oder nullptr, wenn keine vorhanden ist.

`duckdb_column_has_default`

Prüft, ob die Spalte am Index ‘index’ der Tabelle einen DEFAULT-Ausdruck hat.

Syntax

duckdb_state duckdb_column_has_default(
  duckdb_table_description table_description,
  idx_t index,
  bool *out
);

Parameter

table_description: Die abzufragende table_description.
index: Der Index der abzufragenden Spalte.
out: Der Out-Parameter, in dem das Ergebnis gespeichert wird.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_table_description_get_column_name`

Ermittelt den Spaltennamen am Index ‘index’. Das Ausgabeergebnis muss mit duckdb_free zerstört werden.

Syntax

char *duckdb_table_description_get_column_name(
  duckdb_table_description table_description,
  idx_t index
);

Parameter

table_description: Die abzufragende table_description.
index: Der Index der abzufragenden Spalte.

Rückgabewert

Der Spaltenname.

`duckdb_to_arrow_schema`

Wandelt ein DuckDB-Schema in ein Arrow-Schema um

Syntax

duckdb_error_data duckdb_to_arrow_schema(
  duckdb_arrow_options arrow_options,
  duckdb_logical_type *types,
  const char **names,
  idx_t column_count,
  struct ArrowSchema *out_schema
);

Parameter

arrow_options: Die Arrow-Einstellungen, die zur Erzeugung von Arrow verwendet werden.
types: Die logischen DuckDB-Typen für jede Spalte im Schema.
names: Die Namen jeder Spalte im Schema.
column_count: Die Anzahl der Spalten, die im Schema vorhanden sind.
out_schema: Das resultierende Arrow-Schema. Must be destroyed with out_schema->release(out_schema).

Rückgabewert

Die Fehlerdaten. Müssen mit duckdb_destroy_error_data zerstört werden.

`duckdb_data_chunk_to_arrow`

Wandelt einen DuckDB-Data-Chunk in ein Arrow-Array um.

Syntax

duckdb_error_data duckdb_data_chunk_to_arrow(
  duckdb_arrow_options arrow_options,
  duckdb_data_chunk chunk,
  struct ArrowArray *out_arrow_array
);

Parameter

arrow_options: Die Arrow-Einstellungen, die zur Erzeugung von Arrow verwendet werden.
chunk: Der zu konvertierende DuckDB-Data-Chunk.
out_arrow_array: Die Ausgabe-Arrow-Struktur, die die konvertierten Daten enthält. Must be released with out_arrow_array->release(out_arrow_array)

Rückgabewert

Die Fehlerdaten. Müssen mit duckdb_destroy_error_data zerstört werden.

`duckdb_schema_from_arrow`

Wandelt ein Arrow-Schema in ein DuckDB-Schema um.

Syntax

duckdb_error_data duckdb_schema_from_arrow(
  duckdb_connection connection,
  struct ArrowSchema *schema,
  duckdb_arrow_converted_schema *out_types
);

Parameter

connection: Die Verbindung, von der die Transformationseinstellungen geholt werden.
schema: Das Eingabe-Arrow-Schema. Must be released with schema->release(schema).
out_types: Das konvertierte Arrow-Schema mit Extra-Informationen über die Arrow-Typen. Must be destroyed with duckdb_destroy_arrow_converted_schema.

Rückgabewert

Die Fehlerdaten. Müssen mit duckdb_destroy_error_data zerstört werden.

`duckdb_data_chunk_from_arrow`

Wandelt ein Arrow-Array in einen DuckDB-Data-Chunk um. Der Data-Chunk behält das Eigentum an den zugrunde liegenden Arrow-Daten.

Syntax

duckdb_error_data duckdb_data_chunk_from_arrow(
  duckdb_connection connection,
  struct ArrowArray *arrow_array,
  duckdb_arrow_converted_schema converted_schema,
  duckdb_data_chunk *out_chunk
);

Parameter

connection: Die Verbindung, von der die Transformationseinstellungen geholt werden.
arrow_array: Das Eingabe-Arrow-Array. Data ownership is passed on to DuckDB’s DataChunk, the underlying object does not need to be released and won’t have ownership of the data.
converted_schema: Das konvertierte Arrow-Schema mit Extra-Informationen über die Arrow-Typen.
out_chunk: Der resultierende DuckDB-Data-Chunk. Must be destroyed by duckdb_destroy_data_chunk.

Rückgabewert

Die Fehlerdaten. Müssen mit duckdb_destroy_error_data zerstört werden.

`duckdb_destroy_arrow_converted_schema`

Zerstört das konvertierte Arrow-Schema und gibt den gesamten dafür allokierten Speicher frei.

Syntax

void duckdb_destroy_arrow_converted_schema(
  duckdb_arrow_converted_schema *arrow_converted_schema
);

Parameter

arrow_converted_schema: Das zu zerstörende konvertierte Arrow-Schema.

`duckdb_query_arrow`

Führt eine SQL-Abfrage in einer Verbindung aus und speichert das vollständige (materialisierte) Ergebnis in einer Arrow-Struktur. Wenn die Abfrage fehlschlägt, wird DuckDBError zurückgegeben, und die Fehlermeldung kann durch Aufruf von duckdb_query_arrow_error abgerufen werden.

Beachten Sie, dass nach duckdb_query_arrow duckdb_destroy_arrow für das Ergebnisobjekt aufgerufen werden muss, auch wenn die Abfrage fehlschlägt, andernfalls wird der im Ergebnis gespeicherte Fehler nicht korrekt freigegeben.

Syntax

duckdb_state duckdb_query_arrow(
  duckdb_connection connection,
  const char *query,
  duckdb_arrow *out_result
);

Parameter

connection: Die Verbindung, in der die Abfrage ausgeführt wird.
query: Die auszuführende SQL-Abfrage.
out_result: Das Abfrageergebnis.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_query_arrow_schema`

Holt das interne Arrow-Schema aus dem Arrow-Ergebnis. Denken Sie daran, release für das jeweilige ArrowSchema-Objekt aufzurufen.

Syntax

duckdb_state duckdb_query_arrow_schema(
  duckdb_arrow result,
  duckdb_arrow_schema *out_schema
);

Parameter

result: Das Ergebnis, von dem das Schema geholt wird.
out_schema: Das Ausgabe-Schema.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_prepared_arrow_schema`

Holt das interne Arrow-Schema aus dem Prepared Statement. Denken Sie daran, release für das jeweilige ArrowSchema-Objekt aufzurufen.

Syntax

duckdb_state duckdb_prepared_arrow_schema(
  duckdb_prepared_statement prepared,
  duckdb_arrow_schema *out_schema
);

Parameter

prepared: Das Prepared Statement, von dem das Schema geholt wird.
out_schema: Das Ausgabe-Schema.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_result_arrow_array`

Konvertiert einen Data-Chunk in ein Arrow-Struct-Array. Denken Sie daran, release für das jeweilige ArrowArray-Objekt aufzurufen.

Syntax

void duckdb_result_arrow_array(
  duckdb_result result,
  duckdb_data_chunk chunk,
  duckdb_arrow_array *out_array
);

Parameter

result: Das Ergebnisobjekt, von dem der Data Chunk geholt wurde.
chunk: Der zu konvertierende Data Chunk.
out_array: Das Ausgabe-Array.

`duckdb_query_arrow_array`

Holt ein internes Arrow-Struct-Array aus dem Arrow-Ergebnis. Denken Sie daran, release für das jeweilige ArrowArray-Objekt aufzurufen.

Diese Funktion kann mehrfach aufgerufen werden, um weitere Chunks zu holen, wodurch das vorherige out_array freigegeben wird. Verbrauchen Sie daher das out_array, bevor Sie diese Funktion erneut aufrufen.

Syntax

duckdb_state duckdb_query_arrow_array(
  duckdb_arrow result,
  duckdb_arrow_array *out_array
);

Parameter

result: Das Ergebnis, von dem das Array geholt wird.
out_array: Das Ausgabe-Array.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_arrow_column_count`

Gibt die Anzahl der Spalten im Arrow-Ergebnisobjekt zurück.

Syntax

idx_t duckdb_arrow_column_count(
  duckdb_arrow result
);

Parameter

result: Das Ergebnisobjekt.

Rückgabewert

Die Anzahl der Spalten im Ergebnisobjekt.

`duckdb_arrow_row_count`

Gibt die Anzahl der Zeilen im Arrow-Ergebnisobjekt zurück.

Syntax

idx_t duckdb_arrow_row_count(
  duckdb_arrow result
);

Parameter

result: Das Ergebnisobjekt.

Rückgabewert

Die Anzahl der Zeilen im Ergebnisobjekt.

`duckdb_arrow_rows_changed`

Gibt die Anzahl der von der im Arrow-Ergebnis gespeicherten Abfrage geänderten Zeilen zurück. Dies ist nur für INSERT/UPDATE/DELETE-Abfragen relevant. Bei anderen Abfragen ist rows_changed 0.

Syntax

idx_t duckdb_arrow_rows_changed(
  duckdb_arrow result
);

Parameter

result: Das Ergebnisobjekt.

Rückgabewert

Die Anzahl der geänderten Zeilen.

`duckdb_query_arrow_error`

Gibt die im Ergebnis enthaltene Fehlermeldung zurück. Der Fehler ist nur gesetzt, wenn duckdb_query_arrow DuckDBError zurückgibt.

Die Fehlermeldung sollte nicht freigegeben werden. Sie wird freigegeben, wenn duckdb_destroy_arrow aufgerufen wird.

Syntax

const char *duckdb_query_arrow_error(
  duckdb_arrow result
);

Parameter

result: Das Ergebnisobjekt, von dem der Fehler geholt wird.

Rückgabewert

Der Fehler des Ergebnisses.

`duckdb_destroy_arrow`

Schließt das Ergebnis und gibt den gesamten für das Arrow-Ergebnis allokierten Speicher frei.

Syntax

void duckdb_destroy_arrow(
  duckdb_arrow *result
);

Parameter

result: Das zu zerstörende Ergebnis.

`duckdb_destroy_arrow_stream`

Gibt den Arrow-Array-Stream frei und deallokiert seinen Speicher.

Syntax

void duckdb_destroy_arrow_stream(
  duckdb_arrow_stream *stream_p
);

Parameter

stream_p: Der zu zerstörende Arrow-Array-Stream.

`duckdb_execute_prepared_arrow`

Führt das Prepared Statement mit den angegebenen gebundenen Parametern aus und gibt ein Arrow-Abfrageergebnis zurück. Beachten Sie, dass nach duckdb_execute_prepared_arrow duckdb_destroy_arrow für das Ergebnisobjekt aufgerufen werden muss.

Syntax

duckdb_state duckdb_execute_prepared_arrow(
  duckdb_prepared_statement prepared_statement,
  duckdb_arrow *out_result
);

Parameter

prepared_statement: Das auszuführende Prepared Statement.
out_result: Das Abfrageergebnis.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_arrow_scan`

Scannt den Arrow-Stream und erzeugt eine View mit dem angegebenen Namen.

Syntax

duckdb_state duckdb_arrow_scan(
  duckdb_connection connection,
  const char *table_name,
  duckdb_arrow_stream arrow
);

Parameter

connection: Die Verbindung, auf der der Scan ausgeführt wird.
table_name: Name der zu erzeugenden temporären View.
arrow: Arrow-Stream-Wrapper.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_arrow_array_scan`

Scannt das Arrow-Array und erzeugt eine View mit dem angegebenen Namen. Beachten Sie, dass nach duckdb_arrow_array_scan duckdb_destroy_arrow_stream für den Ausgabe-Stream aufgerufen werden muss.

Syntax

duckdb_state duckdb_arrow_array_scan(
  duckdb_connection connection,
  const char *table_name,
  duckdb_arrow_schema arrow_schema,
  duckdb_arrow_array arrow_array,
  duckdb_arrow_stream *out_stream
);

Parameter

connection: Die Verbindung, auf der der Scan ausgeführt wird.
table_name: Name der zu erzeugenden temporären View.
arrow_schema: Arrow-Schema-Wrapper.
arrow_array: Arrow-Array-Wrapper.
out_stream: Ausgabe-Array-Stream, der das übergebene Schema umschließt, zum Freigeben/Löschen nach Abschluss.

Rückgabewert

DuckDBSuccess on success or DuckDBError on failure.

`duckdb_execute_tasks`

Führt DuckDB-Aufgaben auf diesem Thread aus.

Kehrt zurück, nachdem max_tasks ausgeführt wurden oder keine weiteren Aufgaben vorhanden sind.

Syntax

void duckdb_execute_tasks(
  duckdb_database database,
  idx_t max_tasks
);

Parameter

database: Das Datenbankobjekt, für das Tasks ausgeführt werden
max_tasks: Die maximale Anzahl auszuführender Tasks

`duckdb_create_task_state`

Erzeugt einen Task-State, der mit duckdb_execute_tasks_state verwendet werden kann, um Aufgaben auszuführen, bis duckdb_finish_execution für den State aufgerufen wird.

duckdb_destroy_state must be called on the result.

Syntax

duckdb_task_state duckdb_create_task_state(
  duckdb_database database
);

Parameter

database: Das Datenbankobjekt, für das der Task-State erzeugt wird

Rückgabewert

Der Task-State, der mit duckdb_execute_tasks_state verwendet werden kann.

`duckdb_execute_tasks_state`

Führt DuckDB-Aufgaben auf diesem Thread aus.

Der Thread führt Aufgaben fortlaufend aus, bis duckdb_finish_execution für den State aufgerufen wird. Mehrere Threads können denselben duckdb_task_state teilen.

Syntax

void duckdb_execute_tasks_state(
  duckdb_task_state state
);

Parameter

state: Der Task-State des Executors

`duckdb_execute_n_tasks_state`

Führt DuckDB-Aufgaben auf diesem Thread aus.

Der Thread führt Aufgaben aus, bis entweder duckdb_finish_execution für den State aufgerufen wird, max_tasks Aufgaben ausgeführt wurden oder keine weiteren Aufgaben auszuführen sind.

Mehrere Threads können denselben duckdb_task_state teilen.

Syntax

idx_t duckdb_execute_n_tasks_state(
  duckdb_task_state state,
  idx_t max_tasks
);

Parameter

state: Der Task-State des Executors
max_tasks: Die maximale Anzahl auszuführender Tasks

Rückgabewert

Die Anzahl der tatsächlich ausgeführten Aufgaben

`duckdb_finish_execution`

Beendet die Ausführung einer bestimmten Aufgabe.

Syntax

void duckdb_finish_execution(
  duckdb_task_state state
);

Parameter

state: Der Task-State, dessen Ausführung beendet wird

`duckdb_task_state_is_finished`

Prüft, ob der angegebene duckdb_task_state die Ausführung beendet hat

Syntax

bool duckdb_task_state_is_finished(
  duckdb_task_state state
);

Parameter

state: Der zu prüfende Task-State

Rückgabewert

Ob duckdb_finish_execution für den Task-State aufgerufen wurde

`duckdb_destroy_task_state`

Zerstört den von duckdb_create_task_state zurückgegebenen Task-State.

Beachten Sie, dass dies nicht aufgerufen werden sollte, während ein aktiver duckdb_execute_tasks_state auf dem Task-State läuft.

Syntax

void duckdb_destroy_task_state(
  duckdb_task_state state
);

Parameter

state: Der aufzuräumende Task-State

`duckdb_execution_is_finished`

Gibt true zurück, wenn die Ausführung der aktuellen Abfrage beendet ist.

Syntax

bool duckdb_execution_is_finished(
  duckdb_connection con
);

Parameter

con: Die Verbindung, auf der geprüft wird

`duckdb_stream_fetch_chunk`

Holt einen Data-Chunk aus dem (streaming) duckdb_result. Diese Funktion sollte wiederholt aufgerufen werden, bis das Ergebnis erschöpft ist.

Das Ergebnis muss mit duckdb_destroy_data_chunk zerstört werden.

Diese Funktion kann nur auf duckdb_results verwendet werden, die mit ‘duckdb_pending_prepared_streaming’ erzeugt wurden

Wenn diese Funktion verwendet wird, können keine der anderen Ergebnisfunktionen verwendet werden und umgekehrt (d. h., diese Funktion kann nicht mit den Legacy-Ergebnisfunktionen oder den materialisierten Ergebnisfunktionen gemischt werden).

Es ist im Voraus nicht bekannt, wie viele Chunks dieses Ergebnis zurückgibt.

Syntax

duckdb_data_chunk duckdb_stream_fetch_chunk(
  duckdb_result result
);

Parameter

result: Das Ergebnisobjekt, von dem der Data Chunk geholt wird.

Rückgabewert

Der resultierende Data-Chunk. Gibt NULL zurück, wenn das Ergebnis einen Fehler hat.

`duckdb_fetch_chunk`

Holt einen Data-Chunk aus einem duckdb_result. Diese Funktion sollte wiederholt aufgerufen werden, bis das Ergebnis erschöpft ist.

Das Ergebnis muss mit duckdb_destroy_data_chunk zerstört werden.

Es ist im Voraus nicht bekannt, wie viele Chunks dieses Ergebnis zurückgibt.

Syntax

duckdb_data_chunk duckdb_fetch_chunk(
  duckdb_result result
);

Parameter

result: Das Ergebnisobjekt, von dem der Data Chunk geholt wird.

Rückgabewert

Der resultierende Data-Chunk. Gibt NULL zurück, wenn das Ergebnis einen Fehler hat.

`duckdb_create_cast_function`

Erzeugt ein neues Cast-Funktionsobjekt.

Rückgabewert

Das Cast-Funktionsobjekt.

Syntax

duckdb_cast_function duckdb_create_cast_function(
  
);

`duckdb_cast_function_set_source_type`

Setzt den Quelltyp der Cast-Funktion.

Syntax

void duckdb_cast_function_set_source_type(
  duckdb_cast_function cast_function,
  duckdb_logical_type source_type
);

Parameter

cast_function: Das Cast-Funktionsobjekt.
source_type: Der zu setzende Quelltyp.

`duckdb_cast_function_set_target_type`

Setzt den Zieltyp der Cast-Funktion.

Syntax

void duckdb_cast_function_set_target_type(
  duckdb_cast_function cast_function,
  duckdb_logical_type target_type
);

Parameter

cast_function: Das Cast-Funktionsobjekt.
target_type: Der zu setzende Zieltyp.

`duckdb_cast_function_set_implicit_cast_cost`

Setzt die “Kosten” des impliziten Casts vom Quelltyp zum Zieltyp mit dieser Funktion.

Syntax

void duckdb_cast_function_set_implicit_cast_cost(
  duckdb_cast_function cast_function,
  int64_t cost
);

Parameter

cast_function: Das Cast-Funktionsobjekt.
cost: Die zu setzenden Kosten.

`duckdb_cast_function_set_function`

Setzt die zu verwendende Cast-Funktion.

Syntax

void duckdb_cast_function_set_function(
  duckdb_cast_function cast_function,
  duckdb_cast_function_t function
);

Parameter

cast_function: Das Cast-Funktionsobjekt.
function: Die zu setzende Funktion.

`duckdb_cast_function_set_extra_info`

Weist der Cast-Funktion Extra-Informationen zu, die z. B. während der Ausführung abgerufen werden können.

Syntax

void duckdb_cast_function_set_extra_info(
  duckdb_cast_function cast_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);

Parameter

extra_info: Die Extra-Informationenrmation
destroy: Der Callback, der aufgerufen wird, um die Extra-Informationen zu zerstören (falls vorhanden)

`duckdb_cast_function_get_extra_info`

Ruft die Extra-Informationen der Funktion ab, wie in duckdb_cast_function_set_extra_info gesetzt.

Syntax

void *duckdb_cast_function_get_extra_info(
  duckdb_function_info info
);

Parameter

info: Das Info-Objekt.

Rückgabewert

Die Extra-Informationen.

`duckdb_cast_function_get_cast_mode`

Ruft den Cast-Ausführungsmodus aus den angegebenen Funktionsinformationen ab.

Syntax

duckdb_cast_mode duckdb_cast_function_get_cast_mode(
  duckdb_function_info info
);

Parameter

info: Das Info-Objekt.

Rückgabewert

The cast mode.

`duckdb_cast_function_set_error`

Meldet, dass bei der Ausführung der Cast-Funktion ein Fehler aufgetreten ist.

Syntax

void duckdb_cast_function_set_error(
  duckdb_function_info info,
  const char *error
);

Parameter

info: Das Info-Objekt.
error: Die Fehlermeldung.

`duckdb_cast_function_set_row_error`

Meldet, dass bei der Ausführung der Cast-Funktion ein Fehler aufgetreten ist, und setzt die entsprechende Ausgabezeile auf NULL.

Syntax

void duckdb_cast_function_set_row_error(
  duckdb_function_info info,
  const char *error,
  idx_t row,
  duckdb_vector output
);

Parameter

info: Das Info-Objekt.
error: Die Fehlermeldung.
row: Der Index der Zeile im Ausgabevektor, die auf NULL gesetzt wird.
output: Der Ausgabevektor.

`duckdb_register_cast_function`

Registriert eine Cast-Funktion in der angegebenen Verbindung.

Syntax

duckdb_state duckdb_register_cast_function(
  duckdb_connection con,
  duckdb_cast_function cast_function
);

Parameter

con: Die zu verwendende Verbindung.
cast_function: Die zu registrierende Cast-Funktion.

Rückgabewert

Ob die Registrierung erfolgreich war.

`duckdb_destroy_cast_function`

Zerstört das Cast-Funktionsobjekt.

Syntax

void duckdb_destroy_cast_function(
  duckdb_cast_function *cast_function
);

Parameter

cast_function: Das Cast-Funktionsobjekt.

`duckdb_destroy_expression`

Zerstört den Ausdruck und gibt seinen Speicher frei.

Syntax

void duckdb_destroy_expression(
  duckdb_expression *expr
);

Parameter

expr: Ein Zeiger auf den Ausdruck.

`duckdb_expression_return_type`

Gibt den Rückgabetyp eines Ausdrucks zurück.

Syntax

duckdb_logical_type duckdb_expression_return_type(
  duckdb_expression expr
);

Parameter

expr: Der Ausdruck.

Rückgabewert

Der Rückgabetyp. Muss mit duckdb_destroy_logical_type zerstört werden.

`duckdb_expression_is_foldable`

Gibt zurück, ob der Ausdruck zu einem Wert faltbar ist.

Syntax

bool duckdb_expression_is_foldable(
  duckdb_expression expr
);

Parameter

expr: Der Ausdruck.

Rückgabewert

True, wenn der Ausdruck faltbar ist, sonst false.

`duckdb_expression_fold`

Faltet einen Ausdruck und erzeugt einen gefalteten Wert.

Syntax

duckdb_error_data duckdb_expression_fold(
  duckdb_client_context context,
  duckdb_expression expr,
  duckdb_value *out_value
);

Parameter

context: Der Client-Kontext.
expr: Der Ausdruck. Must be foldable.
out_value: Der gefaltete Wert, wenn die Faltung erfolgreich war. Must be destroyed with duckdb_destroy_value.

Rückgabewert

Die Fehlerdaten. Müssen mit duckdb_destroy_error_data zerstört werden.