⌘+k ctrl+k
1.1.3 (stable)
Search Shortcut cmd + k | ctrl + k
Complete API

本页面包含DuckDB的C API参考。

已弃用 该参考包含多个弃用通知。这些通知涉及那些长期可用性无法保证的方法，因为它们可能在将来被移除。也就是说，DuckDB 的开发人员计划缓慢执行弃用，因为一些已弃用的方法尚未有完全功能的替代方案。因此，在替代方案可用之前，它们不会被移除，即使在那时，也会有几个小版本的宽限期才会移除它们。这些方法在 v1.0 中已被弃用的原因是表明它们不是 v1.0 稳定 API 的一部分，该 API 包含长期可用的方法。

API Reference Overview

Open Connect 

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);
const char *duckdb_library_version();

Configuration 

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

Query Execution 

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

结果函数 

duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_index);
bool duckdb_result_is_streaming(duckdb_result result);
idx_t duckdb_result_chunk_count(duckdb_result result);
duckdb_result_type duckdb_result_return_type(duckdb_result result);

安全获取函数 

bool duckdb_value_boolean(duckdb_result *result, idx_t col, idx_t row);
int8_t duckdb_value_int8(duckdb_result *result, idx_t col, idx_t row);
int16_t duckdb_value_int16(duckdb_result *result, idx_t col, idx_t row);
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);

Helpers 

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

Date Time Timestamp Helpers 

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

Hugeint Helpers 

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

无符号大整数助手 

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

Decimal Helpers 

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_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement);
duckdb_statement_type duckdb_prepared_statement_type(duckdb_prepared_statement statement);

绑定值到预处理语句 

duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val);
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);

执行预编译语句 

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

Extract Statements 

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

待处理结果接口 

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 Interface 

void duckdb_destroy_value(duckdb_value *value);
duckdb_value duckdb_create_varchar(const char *text);
duckdb_value duckdb_create_varchar_length(const char *text, idx_t length);
duckdb_value duckdb_create_bool(bool input);
duckdb_value duckdb_create_int8(int8_t input);
duckdb_value duckdb_create_uint8(uint8_t input);
duckdb_value duckdb_create_int16(int16_t input);
duckdb_value duckdb_create_uint16(uint16_t input);
duckdb_value duckdb_create_int32(int32_t input);
duckdb_value duckdb_create_uint32(uint32_t input);
duckdb_value duckdb_create_uint64(uint64_t input);
duckdb_value duckdb_create_int64(int64_t val);
duckdb_value duckdb_create_hugeint(duckdb_hugeint input);
duckdb_value duckdb_create_uhugeint(duckdb_uhugeint input);
duckdb_value duckdb_create_float(float input);
duckdb_value duckdb_create_double(double input);
duckdb_value duckdb_create_date(duckdb_date input);
duckdb_value duckdb_create_time(duckdb_time input);
duckdb_value duckdb_create_time_tz_value(duckdb_time_tz value);
duckdb_value duckdb_create_timestamp(duckdb_timestamp input);
duckdb_value duckdb_create_interval(duckdb_interval input);
duckdb_value duckdb_create_blob(const uint8_t *data, idx_t length);
bool duckdb_get_bool(duckdb_value val);
int8_t duckdb_get_int8(duckdb_value val);
uint8_t duckdb_get_uint8(duckdb_value val);
int16_t duckdb_get_int16(duckdb_value val);
uint16_t duckdb_get_uint16(duckdb_value val);
int32_t duckdb_get_int32(duckdb_value val);
uint32_t duckdb_get_uint32(duckdb_value val);
int64_t duckdb_get_int64(duckdb_value val);
uint64_t duckdb_get_uint64(duckdb_value val);
duckdb_hugeint duckdb_get_hugeint(duckdb_value val);
duckdb_uhugeint duckdb_get_uhugeint(duckdb_value val);
float duckdb_get_float(duckdb_value val);
double duckdb_get_double(duckdb_value val);
duckdb_date duckdb_get_date(duckdb_value val);
duckdb_time duckdb_get_time(duckdb_value val);
duckdb_time_tz duckdb_get_time_tz(duckdb_value val);
duckdb_timestamp duckdb_get_timestamp(duckdb_value val);
duckdb_interval duckdb_get_interval(duckdb_value val);
duckdb_logical_type duckdb_get_value_type(duckdb_value val);
duckdb_blob duckdb_get_blob(duckdb_value val);
char *duckdb_get_varchar(duckdb_value value);
duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value *values);
duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
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);

Logical Type Interface 

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

数据块接口 

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

向量接口 

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

Validity Mask Functions 

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

Scalar Functions 

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_function(duckdb_scalar_function scalar_function, duckdb_scalar_function_t function);
duckdb_state duckdb_register_scalar_function(duckdb_connection con, duckdb_scalar_function scalar_function);
void *duckdb_scalar_function_get_extra_info(duckdb_function_info info);
void duckdb_scalar_function_set_error(duckdb_function_info info, const char *error);
duckdb_scalar_function_set duckdb_create_scalar_function_set(const char *name);
void duckdb_destroy_scalar_function_set(duckdb_scalar_function_set *scalar_function_set);
duckdb_state duckdb_add_scalar_function_to_set(duckdb_scalar_function_set set, duckdb_scalar_function function);
duckdb_state duckdb_register_scalar_function_set(duckdb_connection con, duckdb_scalar_function_set set);

Aggregate Functions 

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

Table Functions 

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

表函数绑定 

void *duckdb_bind_get_extra_info(duckdb_bind_info info);
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);

表格函数初始化 

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

Table Function 

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

替换扫描 

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

性能分析信息 

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);
idx_t duckdb_appender_column_count(duckdb_appender appender);
duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t col_idx);
const char *duckdb_appender_error(duckdb_appender appender);
duckdb_state duckdb_appender_flush(duckdb_appender appender);
duckdb_state duckdb_appender_close(duckdb_appender appender);
duckdb_state duckdb_appender_destroy(duckdb_appender *appender);
duckdb_state duckdb_appender_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_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_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk);

表格描述 

duckdb_state duckdb_table_description_create(duckdb_connection connection, const char *schema, const char *table, duckdb_table_description *out);
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);

Arrow Interface 

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

线程信息 

void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks);
duckdb_task_state duckdb_create_task_state(duckdb_database database);
void duckdb_execute_tasks_state(duckdb_task_state state);
idx_t duckdb_execute_n_tasks_state(duckdb_task_state state, idx_t max_tasks);
void duckdb_finish_execution(duckdb_task_state state);
bool duckdb_task_state_is_finished(duckdb_task_state state);
void duckdb_destroy_task_state(duckdb_task_state state);
bool duckdb_execution_is_finished(duckdb_connection con);

流式结果接口 

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

转换函数 

duckdb_cast_function duckdb_create_cast_function();
void duckdb_cast_function_set_source_type(duckdb_cast_function cast_function, duckdb_logical_type source_type);
void duckdb_cast_function_set_target_type(duckdb_cast_function cast_function, duckdb_logical_type target_type);
void duckdb_cast_function_set_implicit_cast_cost(duckdb_cast_function cast_function, int64_t cost);
void duckdb_cast_function_set_function(duckdb_cast_function cast_function, duckdb_cast_function_t function);
void duckdb_cast_function_set_extra_info(duckdb_cast_function cast_function, void *extra_info, duckdb_delete_callback_t destroy);
void *duckdb_cast_function_get_extra_info(duckdb_function_info info);
duckdb_cast_mode duckdb_cast_function_get_cast_mode(duckdb_function_info info);
void duckdb_cast_function_set_error(duckdb_function_info info, const char *error);
void duckdb_cast_function_set_row_error(duckdb_function_info info, const char *error, idx_t row, duckdb_vector output);
duckdb_state duckdb_register_cast_function(duckdb_connection con, duckdb_cast_function cast_function);
void duckdb_destroy_cast_function(duckdb_cast_function *cast_function);

duckdb_open

创建一个新的数据库或打开存储在给定路径的现有数据库文件。 如果没有给出路径，则会创建一个新的内存数据库。 实例化的数据库应使用'duckdb_close'关闭。

Syntax 
duckdb_state duckdb_open(
  const char *path,
  duckdb_database *out_database
);
Parameters
  • path: 磁盘上数据库文件的路径，或 nullptr 或 :memory: 以打开内存数据库。
  • out_database: 结果数据库对象。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_open_ext

duckdb_open 的扩展版本。创建一个新的数据库或打开存储在给定路径的现有数据库文件。 实例化的数据库应使用 'duckdb_close' 关闭。

Syntax 
duckdb_state duckdb_open_ext(
  const char *path,
  duckdb_database *out_database,
  duckdb_config config,
  char **out_error
);
Parameters
  • path: 磁盘上数据库文件的路径，或 nullptr 或 :memory: 以打开内存数据库。
  • out_database: 结果数据库对象。
  • config: （可选）用于启动数据库系统的配置。
  • out_error: 如果设置并且函数返回DuckDBError，这将包含启动失败的原因。 请注意，必须使用duckdb_free来释放错误。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_close

Closes the specified database and de-allocates all memory allocated for that database. This should be called after you are done with any database allocated through duckdb_open or duckdb_open_ext. Note that failing to call duckdb_close (in case of e.g., a program crash) will not cause data corruption. Still, it is recommended to always correctly close a database object after you are done with it.

Syntax 
void duckdb_close(
  duckdb_database *database
);
Parameters
  • database: 要关闭的数据库对象。


duckdb_connect

打开与数据库的连接。连接是查询数据库所必需的，并且存储与连接相关的事务状态。 实例化的连接应使用'duckdb_disconnect'关闭。

Syntax 
duckdb_state duckdb_connect(
  duckdb_database database,
  duckdb_connection *out_connection
);
Parameters
  • database: 要连接的数据库文件。
  • out_connection: 结果连接对象。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_interrupt

中断正在运行的查询

Syntax 
void duckdb_interrupt(
  duckdb_connection connection
);
Parameters
  • connection: 要中断的连接


duckdb_query_progress

获取正在运行的查询的进度

Syntax 
duckdb_query_progress_type duckdb_query_progress(
  duckdb_connection connection
);
Parameters
  • connection: 工作连接
Return Value

如果没有进度则为-1，否则为进度的百分比


duckdb_disconnect

关闭指定的连接并释放为该连接分配的所有内存。

Syntax 
void duckdb_disconnect(
  duckdb_connection *connection
);
Parameters
  • connection: 要关闭的连接。


duckdb_library_version

返回链接的DuckDB版本，开发版本带有版本后缀

通常用于开发必须返回此值以进行兼容性检查的C扩展。

Syntax 
const char *duckdb_library_version(
  
);


duckdb_create_config

Initializes an empty configuration object that can be used to provide start-up options for the DuckDB instance through duckdb_open_ext. The duckdb_config must be destroyed using 'duckdb_destroy_config'

除非发生内存分配失败，否则这将始终成功。

Note that duckdb_destroy_config should always be called on the resulting config, even if the function returns DuckDBError.

Syntax 
duckdb_state duckdb_create_config(
  duckdb_config *out_config
);
Parameters
  • out_config: The result configuration object.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_config_count

This returns the total amount of configuration options available for usage with duckdb_get_config_flag.

这不应该在循环中调用，因为它内部会循环遍历所有选项。

Return Value

可用的配置选项数量。

Syntax 
size_t duckdb_config_count(
  
);


duckdb_get_config_flag

Obtains a human-readable name and description of a specific configuration option. This can be used to e.g. display configuration options. This will succeed unless index is out of range (i.e., >= duckdb_config_count).

结果名称或描述不得被释放。

Syntax 
duckdb_state duckdb_get_config_flag(
  size_t index,
  const char **out_name,
  const char **out_description
);
Parameters
  • index: The index of the configuration option (between 0 and duckdb_config_count)
  • out_name: A name of the configuration flag.
  • out_description: A description of the configuration flag.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_set_config

Sets the specified option for the specified configuration. The configuration option is indicated by name. To obtain a list of config options, see duckdb_get_config_flag.

In the source code, configuration options are defined in config.cpp.

如果名称无效，或者为选项提供的值无效，则可能会失败。

Syntax 
duckdb_state duckdb_set_config(
  duckdb_config config,
  const char *name,
  const char *option
);
Parameters
  • config: The configuration object to set the option on.
  • name: The name of the configuration flag to set.
  • option: The value to set the configuration flag to.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_destroy_config

销毁指定的配置对象并释放为该对象分配的所有内存。

Syntax 
void duckdb_destroy_config(
  duckdb_config *config
);
Parameters
  • config: The configuration object to destroy.


duckdb_query

Executes a SQL query within a connection and stores the full (materialized) result in the out_result pointer. If the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling duckdb_result_error.

Note that after running duckdb_query, duckdb_destroy_result must be called on the result object even if the query fails, otherwise the error stored within the result will not be freed correctly.

Syntax 
duckdb_state duckdb_query(
  duckdb_connection connection,
  const char *query,
  duckdb_result *out_result
);
Parameters
  • connection: The connection to perform the query in.
  • query: The SQL query to run.
  • out_result: The query result.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_destroy_result

关闭结果并释放为该连接分配的所有内存。

Syntax 
void duckdb_destroy_result(
  duckdb_result *result
);
Parameters
  • result: The result to destroy.


duckdb_column_name

返回指定列的名称。结果不需要手动释放；当结果被销毁时，列名将自动销毁。

Returns NULL if the column is out of range.

Syntax 
const char *duckdb_column_name(
  duckdb_result *result,
  idx_t col
);
Parameters
  • result: The result object to fetch the column name from.
  • col: The column index.
Return Value

指定列的名称。


duckdb_column_type

返回指定列的类型。

Returns DUCKDB_TYPE_INVALID if the column is out of range.

Syntax 
duckdb_type duckdb_column_type(
  duckdb_result *result,
  idx_t col
);
Parameters
  • result: The result object to fetch the column type from.
  • col: The column index.
Return Value

指定列的类型。


duckdb_result_statement_type

返回已执行语句的语句类型

Syntax 
duckdb_statement_type duckdb_result_statement_type(
  duckdb_result result
);
Parameters
  • result: The result object to fetch the statement type from.
Return Value

duckdb_statement_type 值或 DUCKDB_STATEMENT_TYPE_INVALID


duckdb_column_logical_type

返回指定列的逻辑列类型。

The return type of this call should be destroyed with duckdb_destroy_logical_type.

Returns NULL if the column is out of range.

Syntax 
duckdb_logical_type duckdb_column_logical_type(
  duckdb_result *result,
  idx_t col
);
Parameters
  • result: The result object to fetch the column type from.
  • col: The column index.
Return Value

指定列的逻辑列类型。


duckdb_column_count

返回结果对象中存在的列数。

Syntax 
idx_t duckdb_column_count(
  duckdb_result *result
);
Parameters
  • result: The result object.
Return Value

结果对象中存在的列数。


duckdb_row_count

警告 弃用通知。此方法计划在未来的版本中移除。

返回结果对象中存在的行数。

Syntax 
idx_t duckdb_row_count(
  duckdb_result *result
);
Parameters
  • result: The result object.
Return Value

结果对象中存在的行数。


duckdb_rows_changed

返回存储在结果中的查询更改的行数。这仅与INSERT/UPDATE/DELETE查询相关。对于其他查询，rows_changed将为0。

Syntax 
idx_t duckdb_rows_changed(
  duckdb_result *result
);
Parameters
  • result: The result object.
Return Value

更改的行数。


duckdb_column_data

Deprecated This method has been deprecated. Prefer using duckdb_result_get_chunk instead.

返回结果中特定列的数据，以列格式显示。

The function returns a dense array which contains the result data. The exact type stored in the array depends on the corresponding duckdb_type (as provided by duckdb_column_type). For the exact type by which the data should be accessed, see the comments in the types section or the DUCKDB_TYPE enum.

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
);
Parameters
  • result: 从中获取列数据的结果对象。
  • col: The column index.
Return Value

指定列的列数据。


duckdb_nullmask_data

Deprecated This method has been deprecated. Prefer using duckdb_result_get_chunk instead.

返回以列格式表示的特定列结果的空值掩码。空值掩码指示每一行是否是对应的NULL行。如果某一行是NULL，则由duckdb_column_data提供的数组中的值是未定义的。

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
);
Parameters
  • result: 从中获取空掩码的结果对象。
  • col: The column index.
Return Value

指定列的空掩码。


duckdb_result_error

返回结果中包含的错误信息。只有在duckdb_query返回DuckDBError时，才会设置错误。

此函数的结果不能被释放。它将在调用duckdb_destroy_result时被清理。

Syntax 
const char *duckdb_result_error(
  duckdb_result *result
);
Parameters
  • result: The result object to fetch the error from.
Return Value

结果的错误。


duckdb_result_error_type

返回结果中包含的错误类型。只有在duckdb_query返回DuckDBError时，错误才会被设置。

Syntax 
duckdb_error_type duckdb_result_error_type(
  duckdb_result *result
);
Parameters
  • result: The result object to fetch the error from.
Return Value

结果的错误类型。


duckdb_result_get_chunk

警告 弃用通知。此方法计划在未来的版本中移除。

从duckdb_result中获取一个数据块。此函数应重复调用，直到结果耗尽。

The result must be destroyed with duckdb_destroy_data_chunk.

This function supersedes all duckdb_value functions, as well as the duckdb_column_data and duckdb_nullmask_data functions. It results in significantly better performance, and should be preferred in newer code-bases.

如果使用此函数，则不能使用其他结果函数，反之亦然（即，此函数不能与旧的结果函数混合使用）。

Use duckdb_result_chunk_count to figure out how many chunks there are in the result.

Syntax 
duckdb_data_chunk duckdb_result_get_chunk(
  duckdb_result result,
  idx_t chunk_index
);
Parameters
  • result: The result object to fetch the data chunk from.
  • chunk_index: The chunk index to fetch from.
Return Value

The resulting data chunk. Returns NULL if the chunk index is out of bounds.


duckdb_result_is_streaming

警告 弃用通知。此方法计划在未来的版本中移除。

检查内部结果的类型是否为StreamQueryResult。

Syntax 
bool duckdb_result_is_streaming(
  duckdb_result result
);
Parameters
  • result: The result object to check.
Return Value

结果对象是否为StreamQueryResult类型


duckdb_result_chunk_count

警告 弃用通知。此方法计划在未来的版本中移除。

返回结果中存在的数据块数量。

Syntax 
idx_t duckdb_result_chunk_count(
  duckdb_result result
);
Parameters
  • result: The result object
Return Value

结果中存在的数据块数量。


duckdb_result_return_type

返回给定结果的return_type，或在错误时返回DUCKDB_RETURN_TYPE_INVALID

Syntax 
duckdb_result_type duckdb_result_return_type(
  duckdb_result result
);
Parameters
  • result: The result object
Return Value

返回类型


duckdb_value_boolean

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的布尔值，如果无法转换该值，则为 false。

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


duckdb_value_int8

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的int8_t值，如果无法转换该值，则为0。

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


duckdb_value_int16

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的int16_t值，如果无法转换该值，则为0。

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


duckdb_value_int32

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置处的int32_t值，如果无法转换该值，则为0。

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


duckdb_value_int64

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的int64_t值，如果无法转换该值，则为0。

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


duckdb_value_hugeint

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的duckdb_hugeint值，如果无法转换则为0。

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


duckdb_value_uhugeint

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的duckdb_uhugeint值，如果无法转换则为0。

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


duckdb_value_decimal

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的duckdb_decimal值，如果无法转换该值，则为0。

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


duckdb_value_uint8

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的uint8_t值，如果无法转换该值，则为0。

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


duckdb_value_uint16

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的 uint16_t 值，如果无法转换该值，则为 0。

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


duckdb_value_uint32

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的 uint32_t 值，如果无法转换该值，则为 0。

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


duckdb_value_uint64

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的 uint64_t 值，如果无法转换该值，则为 0。

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


duckdb_value_float

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置处的浮点值，如果无法转换该值，则为0。

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


duckdb_value_double

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的双精度值，如果无法转换则为0。

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


duckdb_value_date

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的duckdb_date值，如果无法转换该值，则为0。

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


duckdb_value_time

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的duckdb_time值，如果无法转换该值，则为0。

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


duckdb_value_timestamp

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的duckdb_timestamp值，如果无法转换该值，则为0。

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


duckdb_value_interval

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的duckdb_interval值，如果无法转换该值，则为0。

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


duckdb_value_varchar

已弃用 此方法已被弃用。请改用duckdb_value_string。如果字符串包含空字节，此函数无法正常工作。

Return Value

指定位置的文本值作为以空字符结尾的字符串，如果无法转换该值，则为 nullptr。结果必须使用 duckdb_free 释放。

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


duckdb_value_string

警告 弃用通知。此方法计划在未来的版本中移除。

不支持嵌套类型和其他复杂类型。 生成的字段 "string.data" 必须使用 duckdb_free 释放。

Return Value

指定位置的字符串值。尝试将结果值转换为字符串。

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


duckdb_value_varchar_internal

已弃用 此方法已被弃用。请改用duckdb_value_string_internal。如果字符串包含空字节，此函数无法正常工作。

Return Value

指定位置的char*值。仅适用于VARCHAR列，且不会自动转换。 如果列不是VARCHAR列，此函数将返回NULL。

结果不得被释放。

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


duckdb_value_string_internal

已弃用 此方法已被弃用。请改用duckdb_value_string_internal。如果字符串包含空字节，此函数无法正常工作。

Return Value

指定位置的char*值。仅适用于VARCHAR列，且不会自动转换。 如果列不是VARCHAR列，此函数将返回NULL。

结果不得被释放。

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


duckdb_value_blob

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

指定位置的duckdb_blob值。如果该值无法转换，则返回一个blob，其blob.data设置为nullptr。生成的字段“blob.data”必须使用duckdb_free释放。

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


duckdb_value_is_null

警告 弃用通知。此方法计划在未来的版本中移除。

Return Value

如果指定索引处的值为NULL，则返回true，否则返回false。

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


duckdb_malloc

使用duckdb内部的malloc函数分配size字节的内存。以这种方式分配的任何内存都应使用duckdb_free释放。

Syntax 
void *duckdb_malloc(
  size_t size
);
Parameters
  • size: 要分配的字节数。
Return Value

指向已分配内存区域的指针。


duckdb_free

释放从 duckdb_malloc、duckdb_value_varchar、duckdb_value_blob 或 duckdb_value_string 返回的值。

Syntax 
void duckdb_free(
  void *ptr
);
Parameters
  • ptr: 要释放的内存区域。


duckdb_vector_size

DuckDB 使用的内部向量大小。 这是可以放入由 duckdb_create_data_chunk 创建的数据块中的元组数量。

Return Value

向量大小。

Syntax 
idx_t duckdb_vector_size(
  
);


duckdb_string_is_inlined

duckdb_string_t 值是否内联。 这意味着字符串的数据没有单独分配。

Syntax 
bool duckdb_string_is_inlined(
  duckdb_string_t string
);


duckdb_string_t_length

获取字符串 string_t 的长度

Syntax 
uint32_t duckdb_string_t_length(
  duckdb_string_t string
);
Parameters
  • string: 要获取长度的字符串。
Return Value

长度。


duckdb_string_t_data

获取指向 string_t 字符串数据的指针

Syntax 
const char *duckdb_string_t_data(
  duckdb_string_t *string
);
Parameters
  • string: 获取指针的字符串。
Return Value

指针。


duckdb_from_date

Decompose a duckdb_date object into year, month and date (stored as duckdb_date_struct).

Syntax 
duckdb_date_struct duckdb_from_date(
  duckdb_date date
);
Parameters
  • date: The date object, as obtained from a DUCKDB_TYPE_DATE column.
Return Value

The duckdb_date_struct with the decomposed elements.


duckdb_to_date

Re-compose a duckdb_date from year, month and date (duckdb_date_struct).

Syntax 
duckdb_date duckdb_to_date(
  duckdb_date_struct date
);
Parameters
  • date: The year, month and date stored in a duckdb_date_struct.
Return Value

The duckdb_date element.


duckdb_is_finite_date

Test a duckdb_date to see if it is a finite value.

Syntax 
bool duckdb_is_finite_date(
  duckdb_date date
);
Parameters
  • date: The date object, as obtained from a DUCKDB_TYPE_DATE column.
Return Value

如果日期是有限的则为True，如果它是±无穷大则为false。


duckdb_from_time

Decompose a duckdb_time object into hour, minute, second and microsecond (stored as duckdb_time_struct).

Syntax 
duckdb_time_struct duckdb_from_time(
  duckdb_time time
);
Parameters
  • time: The time object, as obtained from a DUCKDB_TYPE_TIME column.
Return Value

The duckdb_time_struct with the decomposed elements.


duckdb_create_time_tz

Create a duckdb_time_tz object from micros and a timezone offset.

Syntax 
duckdb_time_tz duckdb_create_time_tz(
  int64_t micros,
  int32_t offset
);
Parameters
  • micros: The microsecond component of the time.
  • offset: 时间的时区偏移量部分。
Return Value

The duckdb_time_tz element.


duckdb_from_time_tz

将TIME_TZ对象分解为微秒和时区偏移量。

Use duckdb_from_time to further decompose the micros into hour, minute, second and microsecond.

Syntax 
duckdb_time_tz_struct duckdb_from_time_tz(
  duckdb_time_tz micros
);
Parameters
  • micros: 时间对象，从DUCKDB_TYPE_TIME_TZ列中获取。


duckdb_to_time

Re-compose a duckdb_time from hour, minute, second and microsecond (duckdb_time_struct).

Syntax 
duckdb_time duckdb_to_time(
  duckdb_time_struct time
);
Parameters
  • time: The hour, minute, second and microsecond in a duckdb_time_struct.
Return Value

The duckdb_time element.


duckdb_from_timestamp

Decompose a duckdb_timestamp object into a duckdb_timestamp_struct.

Syntax 
duckdb_timestamp_struct duckdb_from_timestamp(
  duckdb_timestamp ts
);
Parameters
  • ts: ts对象，从DUCKDB_TYPE_TIMESTAMP列中获取。
Return Value

The duckdb_timestamp_struct with the decomposed elements.


duckdb_to_timestamp

Re-compose a duckdb_timestamp from a duckdb_timestamp_struct.

Syntax 
duckdb_timestamp duckdb_to_timestamp(
  duckdb_timestamp_struct ts
);
Parameters
  • ts: 分解后的元素在 duckdb_timestamp_struct 中。
Return Value

The duckdb_timestamp element.


duckdb_is_finite_timestamp

Test a duckdb_timestamp to see if it is a finite value.

Syntax 
bool duckdb_is_finite_timestamp(
  duckdb_timestamp ts
);
Parameters
  • ts: 时间戳对象，从DUCKDB_TYPE_TIMESTAMP列中获取。
Return Value

如果时间戳是有限的则为True，如果它是±无穷大则为false。


duckdb_hugeint_to_double

Converts a duckdb_hugeint object (as obtained from a DUCKDB_TYPE_HUGEINT column) into a double.

Syntax 
double duckdb_hugeint_to_double(
  duckdb_hugeint val
);
Parameters
  • val: The hugeint value.
Return Value

The converted double element.


duckdb_double_to_hugeint

将双精度值转换为duckdb_hugeint对象。

如果转换失败是因为双精度值太大，结果将为0。

Syntax 
duckdb_hugeint duckdb_double_to_hugeint(
  double val
);
Parameters
  • val: The double value.
Return Value

The converted duckdb_hugeint element.


duckdb_uhugeint_to_double

将duckdb_uhugeint对象（从DUCKDB_TYPE_UHUGEINT列中获取）转换为double类型。

Syntax 
double duckdb_uhugeint_to_double(
  duckdb_uhugeint val
);
Parameters
  • val: uhugeint 值。
Return Value

The converted double element.


duckdb_double_to_uhugeint

将双精度值转换为duckdb_uhugeint对象。

如果转换失败是因为双精度值太大，结果将为0。

Syntax 
duckdb_uhugeint duckdb_double_to_uhugeint(
  double val
);
Parameters
  • val: The double value.
Return Value

转换后的 duckdb_uhugeint 元素。


duckdb_double_to_decimal

将双精度值转换为duckdb_decimal对象。

如果由于双精度值过大或宽度/比例无效而导致转换失败，结果将为0。

Syntax 
duckdb_decimal duckdb_double_to_decimal(
  double val,
  uint8_t width,
  uint8_t scale
);
Parameters
  • val: The double value.
Return Value

The converted duckdb_decimal element.


duckdb_decimal_to_double

Converts a duckdb_decimal object (as obtained from a DUCKDB_TYPE_DECIMAL column) into a double.

Syntax 
double duckdb_decimal_to_double(
  duckdb_decimal val
);
Parameters
  • val: The decimal value.
Return Value

The converted double element.


duckdb_prepare

从查询创建一个预处理语句对象。

Note that after calling duckdb_prepare, the prepared statement should always be destroyed using duckdb_destroy_prepare, even if the prepare fails.

If the prepare fails, duckdb_prepare_error can be called to obtain the reason why the prepare failed.

Syntax 
duckdb_state duckdb_prepare(
  duckdb_connection connection,
  const char *query,
  duckdb_prepared_statement *out_prepared_statement
);
Parameters
  • connection: The connection object
  • query: The SQL query to prepare
  • out_prepared_statement: The resulting prepared statement object
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_destroy_prepare

关闭准备好的语句并释放为该语句分配的所有内存。

Syntax 
void duckdb_destroy_prepare(
  duckdb_prepared_statement *prepared_statement
);
Parameters
  • prepared_statement: The prepared statement to destroy.


duckdb_prepare_error

Returns the error message associated with the given prepared statement. If the prepared statement has no error message, this returns nullptr instead.

The error message should not be freed. It will be de-allocated when duckdb_destroy_prepare is called.

Syntax 
const char *duckdb_prepare_error(
  duckdb_prepared_statement prepared_statement
);
Parameters
  • prepared_statement: The prepared statement to obtain the error from.
Return Value

The error message, or nullptr if there is none.


duckdb_nparams

返回可以提供给给定预处理语句的参数数量。

如果查询未成功准备，则返回0。

Syntax 
idx_t duckdb_nparams(
  duckdb_prepared_statement prepared_statement
);
Parameters
  • prepared_statement: The prepared statement to obtain the number of parameters for.


duckdb_parameter_name

Returns the name used to identify the parameter The returned string should be freed using duckdb_free.

如果索引超出提供的预处理语句的范围，则返回NULL。

Syntax 
const char *duckdb_parameter_name(
  duckdb_prepared_statement prepared_statement,
  idx_t index
);
Parameters
  • prepared_statement: The prepared statement for which to get the parameter name from.


duckdb_param_type

返回给定索引处参数的类型。

Returns DUCKDB_TYPE_INVALID if the parameter index is out of range or the statement was not successfully prepared.

Syntax 
duckdb_type duckdb_param_type(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx
);
Parameters
  • prepared_statement: The prepared statement.
  • param_idx: The parameter index.
Return Value

参数类型


duckdb_clear_bindings

清除绑定到预处理语句的参数。

Syntax 
duckdb_state duckdb_clear_bindings(
  duckdb_prepared_statement prepared_statement
);


duckdb_prepared_statement_type

返回要执行的语句的语句类型

Syntax 
duckdb_statement_type duckdb_prepared_statement_type(
  duckdb_prepared_statement statement
);
Parameters
  • statement: The prepared statement.
Return Value

duckdb_statement_type 值或 DUCKDB_STATEMENT_TYPE_INVALID


duckdb_bind_value

将值绑定到指定索引的预处理语句。

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


duckdb_bind_parameter_index

检索由名称标识的预处理语句参数的索引

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


duckdb_bind_boolean

将布尔值绑定到指定索引的预处理语句。

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


duckdb_bind_int8

将int8_t值绑定到指定索引处的预处理语句。

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


duckdb_bind_int16

将int16_t值绑定到指定索引处的预处理语句。

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


duckdb_bind_int32

将int32_t值绑定到指定索引处的预处理语句。

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


duckdb_bind_int64

将int64_t值绑定到指定索引的预处理语句。

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


duckdb_bind_hugeint

将duckdb_hugeint值绑定到指定索引的预处理语句。

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


duckdb_bind_uhugeint

将duckdb_uhugeint值绑定到指定索引的预处理语句。

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


duckdb_bind_decimal

将duckdb_decimal值绑定到指定索引的预处理语句。

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


duckdb_bind_uint8

将一个uint8_t值绑定到指定索引的预处理语句。

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


duckdb_bind_uint16

将一个uint16_t值绑定到指定索引的预处理语句上。

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


duckdb_bind_uint32

将一个uint32_t值绑定到指定索引的预处理语句上。

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


duckdb_bind_uint64

将uint64_t值绑定到指定索引处的预处理语句。

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


duckdb_bind_float

将浮点数值绑定到指定索引的准备语句。

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


duckdb_bind_double

将双精度值绑定到指定索引的预处理语句。

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


duckdb_bind_date

将duckdb_date值绑定到指定索引的预处理语句。

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


duckdb_bind_time

将duckdb_time值绑定到指定索引的预处理语句。

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


duckdb_bind_timestamp

将duckdb_timestamp值绑定到指定索引的预处理语句。

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


duckdb_bind_timestamp_tz

将duckdb_timestamp值绑定到指定索引的预处理语句。

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


duckdb_bind_interval

将duckdb_interval值绑定到指定索引的预处理语句。

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


duckdb_bind_varchar

将空终止的varchar值绑定到指定索引的预处理语句。

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


duckdb_bind_varchar_length

将varchar值绑定到指定索引的预处理语句。

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

将blob值绑定到指定索引的预处理语句。

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


duckdb_bind_null

将NULL值绑定到指定索引的预处理语句。

Syntax 
duckdb_state duckdb_bind_null(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx
);


duckdb_execute_prepared

使用给定的绑定参数执行准备好的语句，并返回一个物化的查询结果。

此方法可以为每个准备好的语句多次调用，并且可以在调用此函数之间修改参数。

请注意，结果必须使用duckdb_destroy_result释放。

Syntax 
duckdb_state duckdb_execute_prepared(
  duckdb_prepared_statement prepared_statement,
  duckdb_result *out_result
);
Parameters
  • prepared_statement: 要执行的预处理语句。
  • out_result: The query result.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_execute_prepared_streaming

警告 弃用通知。此方法计划在未来的版本中移除。

使用给定的绑定参数执行准备好的语句，并返回一个可选的流式查询结果。 要确定结果查询是否实际上是流式的，请使用 duckdb_result_is_streaming

此方法可以为每个准备好的语句多次调用，并且可以在调用此函数之间修改参数。

请注意，结果必须使用duckdb_destroy_result释放。

Syntax 
duckdb_state duckdb_execute_prepared_streaming(
  duckdb_prepared_statement prepared_statement,
  duckdb_result *out_result
);
Parameters
  • prepared_statement: 要执行的预处理语句。
  • out_result: The query result.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_extract_statements

从查询中提取所有语句。 请注意，在调用duckdb_extract_statements之后，提取的语句应始终使用 duckdb_destroy_extracted销毁，即使没有提取到任何语句。

如果提取失败，可以调用duckdb_extract_statements_error来获取提取失败的原因。

Syntax 
idx_t duckdb_extract_statements(
  duckdb_connection connection,
  const char *query,
  duckdb_extracted_statements *out_extracted_statements
);
Parameters
  • connection: The connection object
  • query: 用于提取的SQL查询
  • out_extracted_statements: 生成的提取语句对象
Return Value

提取的语句数量或失败时为0。


duckdb_prepare_extracted_statement

准备一个提取的语句。 请注意，在调用duckdb_prepare_extracted_statement之后，即使准备失败，也应始终使用duckdb_destroy_prepare销毁准备好的语句。

If the prepare fails, duckdb_prepare_error can be called to obtain the reason why the prepare failed.

Syntax 
duckdb_state duckdb_prepare_extracted_statement(
  duckdb_connection connection,
  duckdb_extracted_statements extracted_statements,
  idx_t index,
  duckdb_prepared_statement *out_prepared_statement
);
Parameters
  • connection: The connection object
  • extracted_statements: 提取的语句对象
  • index: 要准备的提取语句的索引
  • out_prepared_statement: The resulting prepared statement object
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_extract_statements_error

返回包含在提取语句中的错误信息。 此函数的结果不得释放。它将在调用duckdb_destroy_extracted时被清理。

Syntax 
const char *duckdb_extract_statements_error(
  duckdb_extracted_statements extracted_statements
);
Parameters
  • extracted_statements: 用于从中获取错误的提取语句。
Return Value

提取语句的错误。


duckdb_destroy_extracted

释放为提取的语句分配的所有内存。

Syntax 
void duckdb_destroy_extracted(
  duckdb_extracted_statements *extracted_statements
);
Parameters
  • extracted_statements: 要销毁的提取语句。


duckdb_pending_prepared

使用给定的绑定参数执行准备好的语句，并返回一个待处理的结果。 待处理的结果表示尚未完全执行的查询的中间结构。 待处理的结果可用于逐步执行查询，在任务之间将控制权返回给客户端。

请注意，在调用duckdb_pending_prepared之后，即使此函数返回DuckDBError，也应始终使用duckdb_destroy_pending销毁待处理的结果。

Syntax 
duckdb_state duckdb_pending_prepared(
  duckdb_prepared_statement prepared_statement,
  duckdb_pending_result *out_result
);
Parameters
  • prepared_statement: The prepared statement to execute.
  • out_result: 待处理的查询结果。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_pending_prepared_streaming

警告 弃用通知。此方法计划在未来的版本中移除。

使用给定的绑定参数执行准备好的语句，并返回一个待处理的结果。 这个待处理的结果在执行时将创建一个流式的duckdb_result。 待处理的结果表示一个尚未完全执行的查询的中间结构。

请注意，在调用duckdb_pending_prepared_streaming之后，即使此函数返回DuckDBError，也应始终使用duckdb_destroy_pending销毁挂起的结果。

Syntax 
duckdb_state duckdb_pending_prepared_streaming(
  duckdb_prepared_statement prepared_statement,
  duckdb_pending_result *out_result
);
Parameters
  • prepared_statement: The prepared statement to execute.
  • out_result: 待处理的查询结果。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_destroy_pending

关闭待处理的结果并释放为结果分配的所有内存。

Syntax 
void duckdb_destroy_pending(
  duckdb_pending_result *pending_result
);
Parameters
  • pending_result: 要销毁的待处理结果。


duckdb_pending_error

返回包含在待处理结果中的错误消息。

此函数的结果不能被释放。它将在调用duckdb_destroy_pending时被清理。

Syntax 
const char *duckdb_pending_error(
  duckdb_pending_result pending_result
);
Parameters
  • pending_result: 用于获取错误的待处理结果。
Return Value

待处理结果的错误。


duckdb_pending_execute_task

执行查询中的单个任务，返回查询是否准备就绪。

如果返回 DUCKDB_PENDING_RESULT_READY，可以调用 duckdb_execute_pending 函数来获取结果。 如果返回 DUCKDB_PENDING_RESULT_NOT_READY，应再次调用 duckdb_pending_execute_task 函数。 如果返回 DUCKDB_PENDING_ERROR，表示执行过程中发生了错误。

错误信息可以通过在pending_result上调用duckdb_pending_error来获取。

Syntax 
duckdb_pending_state duckdb_pending_execute_task(
  duckdb_pending_result pending_result
);
Parameters
  • pending_result: 用于执行任务的待处理结果。
Return Value

执行后待处理结果的状态。


duckdb_pending_execute_check_state

如果返回 DUCKDB_PENDING_RESULT_READY，可以调用 duckdb_execute_pending 函数来获取结果。 如果返回 DUCKDB_PENDING_RESULT_NOT_READY，应再次调用 duckdb_pending_execute_check_state 函数。 如果返回 DUCKDB_PENDING_ERROR，表示执行过程中发生了错误。

错误信息可以通过在pending_result上调用duckdb_pending_error来获取。

Syntax 
duckdb_pending_state duckdb_pending_execute_check_state(
  duckdb_pending_result pending_result
);
Parameters
  • pending_result: 待处理的结果。
Return Value

待处理结果的状态。


duckdb_execute_pending

完全执行一个待处理的查询结果，返回最终的查询结果。

如果已经调用了duckdb_pending_execute_task直到返回DUCKDB_PENDING_RESULT_READY，这将快速返回。 否则，必须先执行所有剩余的任务。

Note that the result must be freed with duckdb_destroy_result.

Syntax 
duckdb_state duckdb_execute_pending(
  duckdb_pending_result pending_result,
  duckdb_result *out_result
);
Parameters
  • pending_result: 要执行的待处理结果。
  • out_result: 结果对象。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_pending_execution_is_finished

返回一个duckdb_pending_state是否已完成执行。例如，如果pending_state是DUCKDB_PENDING_RESULT_READY，此函数将返回true。

Syntax 
bool duckdb_pending_execution_is_finished(
  duckdb_pending_state pending_state
);
Parameters
  • pending_state: 决定是否完成执行的待定状态。
Return Value

布尔值，表示待执行的执行应被视为已完成。


duckdb_destroy_value

销毁该值并释放为该类型分配的所有内存。

Syntax 
void duckdb_destroy_value(
  duckdb_value *value
);
Parameters
  • value: The value to destroy.


duckdb_create_varchar

从以null结尾的字符串创建一个值

Syntax 
duckdb_value duckdb_create_varchar(
  const char *text
);
Parameters
  • text: The null-terminated string
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_varchar_length

从字符串创建一个值

Syntax 
duckdb_value duckdb_create_varchar_length(
  const char *text,
  idx_t length
);
Parameters
  • text: The text
  • length: The length of the text
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_bool

从布尔值创建一个值

Syntax 
duckdb_value duckdb_create_bool(
  bool input
);
Parameters
  • input: The boolean value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_int8

从 int8_t（一个 tinyint）创建一个值

Syntax 
duckdb_value duckdb_create_int8(
  int8_t input
);
Parameters
  • input: The tinyint value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_uint8

从uint8_t（一个utinyint）创建一个值

Syntax 
duckdb_value duckdb_create_uint8(
  uint8_t input
);
Parameters
  • input: The utinyint value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_int16

从 int16_t（一个小整数）创建一个值

Syntax 
duckdb_value duckdb_create_int16(
  int16_t input
);
Parameters
  • input: The smallint value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_uint16

从 uint16_t（一个 usmallint）创建一个值

Syntax 
duckdb_value duckdb_create_uint16(
  uint16_t input
);
Parameters
  • input: The usmallint value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_int32

从 int32_t（一个整数）创建一个值

Syntax 
duckdb_value duckdb_create_int32(
  int32_t input
);
Parameters
  • input: The integer value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_uint32

从 uint32_t（一个无符号整数）创建一个值

Syntax 
duckdb_value duckdb_create_uint32(
  uint32_t input
);
Parameters
  • input: The uinteger value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_uint64

从 uint64_t（一个 ubigint）创建一个值

Syntax 
duckdb_value duckdb_create_uint64(
  uint64_t input
);
Parameters
  • input: The ubigint value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_int64

从int64创建一个值

Return Value

The value. This must be destroyed with duckdb_destroy_value.

Syntax 
duckdb_value duckdb_create_int64(
  int64_t val
);


duckdb_create_hugeint

从hugeint创建一个值

Syntax 
duckdb_value duckdb_create_hugeint(
  duckdb_hugeint input
);
Parameters
  • input: The hugeint value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_uhugeint

从uhugeint创建一个值

Syntax 
duckdb_value duckdb_create_uhugeint(
  duckdb_uhugeint input
);
Parameters
  • input: The uhugeint value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_float

从浮点数创建一个值

Syntax 
duckdb_value duckdb_create_float(
  float input
);
Parameters
  • input: The float value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_double

从双精度数创建一个值

Syntax 
duckdb_value duckdb_create_double(
  double input
);
Parameters
  • input: The double value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_date

从日期创建一个值

Syntax 
duckdb_value duckdb_create_date(
  duckdb_date input
);
Parameters
  • input: The date value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_time

从时间创建一个值

Syntax 
duckdb_value duckdb_create_time(
  duckdb_time input
);
Parameters
  • input: The time value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_time_tz_value

Creates a value from a time_tz. Not to be confused with duckdb_create_time_tz, which creates a duckdb_time_tz_t.

Syntax 
duckdb_value duckdb_create_time_tz_value(
  duckdb_time_tz value
);
Parameters
  • value: The time_tz value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_timestamp

从时间戳创建一个值

Syntax 
duckdb_value duckdb_create_timestamp(
  duckdb_timestamp input
);
Parameters
  • input: The timestamp value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_interval

从间隔创建值

Syntax 
duckdb_value duckdb_create_interval(
  duckdb_interval input
);
Parameters
  • input: The interval value
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_create_blob

从blob创建一个值

Syntax 
duckdb_value duckdb_create_blob(
  const uint8_t *data,
  idx_t length
);
Parameters
  • data: The blob data
  • length: The length of the blob data
Return Value

The value. This must be destroyed with duckdb_destroy_value.


duckdb_get_bool

返回给定值的布尔值。

Syntax 
bool duckdb_get_bool(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a boolean
Return Value

一个布尔值，如果无法转换则为false


duckdb_get_int8

返回给定值的int8_t值。

Syntax 
int8_t duckdb_get_int8(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a tinyint
Return Value

A int8_t, or MinValue if the value cannot be converted


duckdb_get_uint8

返回给定值的uint8_t值。

Syntax 
uint8_t duckdb_get_uint8(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a utinyint
Return Value

A uint8_t, or MinValue if the value cannot be converted


duckdb_get_int16

返回给定值的int16_t值。

Syntax 
int16_t duckdb_get_int16(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a smallint
Return Value

A int16_t, or MinValue if the value cannot be converted


duckdb_get_uint16

返回给定值的 uint16_t 值。

Syntax 
uint16_t duckdb_get_uint16(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a usmallint
Return Value

A uint16_t, or MinValue if the value cannot be converted


duckdb_get_int32

返回给定值的 int32_t 值。

Syntax 
int32_t duckdb_get_int32(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a integer
Return Value

A int32_t, or MinValue if the value cannot be converted


duckdb_get_uint32

返回给定值的uint32_t值。

Syntax 
uint32_t duckdb_get_uint32(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a uinteger
Return Value

A uint32_t, or MinValue if the value cannot be converted


duckdb_get_int64

返回给定值的int64_t值。

Syntax 
int64_t duckdb_get_int64(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a bigint
Return Value

A int64_t, or MinValue if the value cannot be converted


duckdb_get_uint64

返回给定值的 uint64_t 值。

Syntax 
uint64_t duckdb_get_uint64(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a ubigint
Return Value

A uint64_t, or MinValue if the value cannot be converted


duckdb_get_hugeint

返回给定值的hugeint值。

Syntax 
duckdb_hugeint duckdb_get_hugeint(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a hugeint
Return Value

A duckdb_hugeint, or MinValue if the value cannot be converted


duckdb_get_uhugeint

返回给定值的uhugeint值。

Syntax 
duckdb_uhugeint duckdb_get_uhugeint(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a uhugeint
Return Value

A duckdb_uhugeint, or MinValue if the value cannot be converted


duckdb_get_float

返回给定值的浮点数值。

Syntax 
float duckdb_get_float(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a float
Return Value

一个浮点数，如果无法转换则为NAN


duckdb_get_double

返回给定值的双精度值。

Syntax 
double duckdb_get_double(
  duckdb_value val
);
Parameters
  • val: 一个包含双精度浮点数的 duckdb_value
Return Value

一个双精度浮点数，如果无法转换则为NAN


duckdb_get_date

返回给定值的日期值。

Syntax 
duckdb_date duckdb_get_date(
  duckdb_value val
);
Parameters
  • val: A duckdb_value containing a date
Return Value

A duckdb_date, or MinValue if the value cannot be converted


duckdb_get_time

返回给定值的时间值。

Syntax 
duckdb_time duckdb_get_time(
  duckdb_value val
);
Parameters
  • val: 一个包含时间的 duckdb_value
Return Value

A duckdb_time, or MinValue


duckdb_get_time_tz

返回给定值的time_tz值。

Syntax 
duckdb_time_tz duckdb_get_time_tz(
  duckdb_value val
);
Parameters
  • val: 一个包含 time_tz 的 duckdb_value
Return Value

A duckdb_time_tz, or MinValue if the value cannot be converted


duckdb_get_timestamp

返回给定值的时间戳值。

Syntax 
duckdb_timestamp duckdb_get_timestamp(
  duckdb_value val
);
Parameters
  • val: 一个包含时间戳的 duckdb_value
Return Value

A duckdb_timestamp, or MinValue if the value cannot be converted


duckdb_get_interval

返回给定值的间隔值。

Syntax 
duckdb_interval duckdb_get_interval(
  duckdb_value val
);
Parameters
  • val: 一个包含间隔的 duckdb_value
Return Value

A duckdb_interval, or MinValue if the value cannot be converted


duckdb_get_value_type

返回给定值的类型。只要值未被销毁，类型就有效。 类型本身不能被销毁。

Syntax 
duckdb_logical_type duckdb_get_value_type(
  duckdb_value val
);
Parameters
  • val: 一个 duckdb_value
Return Value

一个duckdb_logical_type。


duckdb_get_blob

返回给定值的blob值。

Syntax 
duckdb_blob duckdb_get_blob(
  duckdb_value val
);
Parameters
  • val: 一个包含 blob 的 duckdb_value
Return Value

一个duckdb_blob


duckdb_get_varchar

Obtains a string representation of the given value. The result must be destroyed with duckdb_free.

Syntax 
char *duckdb_get_varchar(
  duckdb_value value
);
Parameters
  • value: The value
Return Value

The string value. This must be destroyed with duckdb_free.


duckdb_create_struct_value

Creates a struct value from a type and an array of values. Must be destroyed with duckdb_destroy_value.

Syntax 
duckdb_value duckdb_create_struct_value(
  duckdb_logical_type type,
  duckdb_value *values
);
Parameters
  • type: 结构体的类型
  • values: 结构体字段的值
Return Value

The struct value, or nullptr, if any child type is DUCKDB_TYPE_ANY or DUCKDB_TYPE_INVALID.


duckdb_create_list_value

Creates a list value from a child (element) type and an array of values of length value_count. Must be destroyed with duckdb_destroy_value.

Syntax 
duckdb_value duckdb_create_list_value(
  duckdb_logical_type type,
  duckdb_value *values,
  idx_t value_count
);
Parameters
  • type: 列表的类型
  • values: 列表的值
  • value_count: 列表中值的数量
Return Value

The list value, or nullptr, if the child type is DUCKDB_TYPE_ANY or DUCKDB_TYPE_INVALID.


duckdb_create_array_value

Creates an array value from a child (element) type and an array of values of length value_count. Must be destroyed with duckdb_destroy_value.

Syntax 
duckdb_value duckdb_create_array_value(
  duckdb_logical_type type,
  duckdb_value *values,
  idx_t value_count
);
Parameters
  • type: 数组的类型
  • values: 数组的值
  • value_count: 数组中的值的数量
Return Value

The array value, or nullptr, if the child type is DUCKDB_TYPE_ANY or DUCKDB_TYPE_INVALID.


duckdb_get_map_size

返回MAP值中的元素数量。

Syntax 
idx_t duckdb_get_map_size(
  duckdb_value value
);
Parameters
  • value: MAP 值。
Return Value

地图中的元素数量。


duckdb_get_map_key

返回索引处的MAP键作为duckdb_value。

Syntax 
duckdb_value duckdb_get_map_key(
  duckdb_value value,
  idx_t index
);
Parameters
  • value: The MAP value.
  • index: 键的索引。
Return Value

键作为 duckdb_value。


duckdb_get_map_value

返回索引处的MAP值作为duckdb_value。

Syntax 
duckdb_value duckdb_get_map_value(
  duckdb_value value,
  idx_t index
);
Parameters
  • value: The MAP value.
  • index: 值的索引。
Return Value

值作为duckdb_value。


duckdb_create_logical_type

Creates a duckdb_logical_type from a primitive type. The resulting logical type must be destroyed with duckdb_destroy_logical_type.

Returns an invalid logical type, if type is: DUCKDB_TYPE_INVALID, DUCKDB_TYPE_DECIMAL, DUCKDB_TYPE_ENUM, DUCKDB_TYPE_LIST, DUCKDB_TYPE_STRUCT, DUCKDB_TYPE_MAP, DUCKDB_TYPE_ARRAY, or DUCKDB_TYPE_UNION.

Syntax 
duckdb_logical_type duckdb_create_logical_type(
  duckdb_type type
);
Parameters
  • type: The primitive type to create.
Return Value

逻辑类型。


duckdb_logical_type_get_alias

Returns the alias of a duckdb_logical_type, if set, else nullptr. The result must be destroyed with duckdb_free.

Syntax 
char *duckdb_logical_type_get_alias(
  duckdb_logical_type type
);
Parameters
  • type: The logical type
Return Value

The alias or nullptr


duckdb_logical_type_set_alias

设置duckdb_logical_type的别名。

Syntax 
void duckdb_logical_type_set_alias(
  duckdb_logical_type type,
  const char *alias
);
Parameters
  • type: The logical type
  • alias: The alias to set


duckdb_create_list_type

Creates a LIST type from its child type. The return type must be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_create_list_type(
  duckdb_logical_type type
);
Parameters
  • type: The child type of the list
Return Value

逻辑类型。


duckdb_create_array_type

Creates an ARRAY type from its child type. The return type must be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_create_array_type(
  duckdb_logical_type type,
  idx_t array_size
);
Parameters
  • type: The child type of the array.
  • array_size: The number of elements in the array.
Return Value

逻辑类型。


duckdb_create_map_type

Creates a MAP type from its key type and value type. The return type must be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_create_map_type(
  duckdb_logical_type key_type,
  duckdb_logical_type value_type
);
Parameters
  • key_type: The map's key type.
  • value_type: The map's value type.
Return Value

逻辑类型。


duckdb_create_union_type

Creates a UNION type from the passed arrays. The return type must be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_create_union_type(
  duckdb_logical_type *member_types,
  const char **member_names,
  idx_t member_count
);
Parameters
  • member_types: The array of union member types.
  • member_names: The union member names.
  • member_count: The number of union members.
Return Value

逻辑类型。


duckdb_create_struct_type

Creates a STRUCT type based on the member types and names. The resulting type must be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_create_struct_type(
  duckdb_logical_type *member_types,
  const char **member_names,
  idx_t member_count
);
Parameters
  • member_types: The array of types of the struct members.
  • member_names: The array of names of the struct members.
  • member_count: The number of members of the struct.
Return Value

逻辑类型。


duckdb_create_enum_type

Creates an ENUM type from the passed member name array. The resulting type should be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_create_enum_type(
  const char **member_names,
  idx_t member_count
);
Parameters
  • member_names: The array of names that the enum should consist of.
  • member_count: The number of elements that were specified in the array.
Return Value

逻辑类型。


duckdb_create_decimal_type

Creates a DECIMAL type with the specified width and scale. The resulting type should be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_create_decimal_type(
  uint8_t width,
  uint8_t scale
);
Parameters
  • width: The width of the decimal type
  • scale: The scale of the decimal type
Return Value

逻辑类型。


duckdb_get_type_id

Retrieves the enum duckdb_type of a duckdb_logical_type.

Syntax 
duckdb_type duckdb_get_type_id(
  duckdb_logical_type type
);
Parameters
  • type: The logical type.
Return Value

The duckdb_type id.


duckdb_decimal_width

获取十进制类型的宽度。

Syntax 
uint8_t duckdb_decimal_width(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

十进制类型的宽度


duckdb_decimal_scale

获取小数类型的比例。

Syntax 
uint8_t duckdb_decimal_scale(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

十进制类型的规模


duckdb_decimal_internal_type

检索十进制类型的内部存储类型。

Syntax 
duckdb_type duckdb_decimal_internal_type(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

十进制类型的内部类型


duckdb_enum_internal_type

检索枚举类型的内部存储类型。

Syntax 
duckdb_type duckdb_enum_internal_type(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

枚举类型的内部类型


duckdb_enum_dictionary_size

获取枚举类型的字典大小。

Syntax 
uint32_t duckdb_enum_dictionary_size(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

枚举类型的字典大小


duckdb_enum_dictionary_value

从枚举中检索指定位置的字典值。

The result must be freed with duckdb_free.

Syntax 
char *duckdb_enum_dictionary_value(
  duckdb_logical_type type,
  idx_t index
);
Parameters
  • type: The logical type object
  • index: The index in the dictionary
Return Value

The string value of the enum type. Must be freed with duckdb_free.


duckdb_list_type_child_type

Retrieves the child type of the given LIST type. Also accepts MAP types. The result must be freed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_list_type_child_type(
  duckdb_logical_type type
);
Parameters
  • type: The logical type, either LIST or MAP.
Return Value

LIST 或 MAP 类型的子类型。


duckdb_array_type_child_type

检索给定ARRAY类型的子类型。

The result must be freed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_array_type_child_type(
  duckdb_logical_type type
);
Parameters
  • type: 逻辑类型。必须是 ARRAY。
Return Value

ARRAY 类型的子类型。


duckdb_array_type_array_size

检索给定数组类型的数组大小。

Syntax 
idx_t duckdb_array_type_array_size(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

此数组类型的值可以存储的固定元素数量。


duckdb_map_type_key_type

检索给定映射类型的键类型。

The result must be freed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_map_type_key_type(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

The key type of the map type. Must be destroyed with duckdb_destroy_logical_type.


duckdb_map_type_value_type

检索给定映射类型的值类型。

The result must be freed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_map_type_value_type(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

The value type of the map type. Must be destroyed with duckdb_destroy_logical_type.


duckdb_struct_type_child_count

返回结构体类型的子元素数量。

Syntax 
idx_t duckdb_struct_type_child_count(
  duckdb_logical_type type
);
Parameters
  • type: The logical type object
Return Value

结构体类型的子元素数量。


duckdb_struct_type_child_name

检索结构体子项的名称。

The result must be freed with duckdb_free.

Syntax 
char *duckdb_struct_type_child_name(
  duckdb_logical_type type,
  idx_t index
);
Parameters
  • type: The logical type object
  • index: The child index
Return Value

The name of the struct type. Must be freed with duckdb_free.


duckdb_struct_type_child_type

检索给定结构类型在指定索引处的子类型。

The result must be freed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_struct_type_child_type(
  duckdb_logical_type type,
  idx_t index
);
Parameters
  • type: The logical type object
  • index: The child index
Return Value

The child type of the struct type. Must be destroyed with duckdb_destroy_logical_type.


duckdb_union_type_member_count

返回联合类型拥有的成员数量。

Syntax 
idx_t duckdb_union_type_member_count(
  duckdb_logical_type type
);
Parameters
  • type: The logical type (union) object
Return Value

联合类型的成员数量。


duckdb_union_type_member_name

检索联合成员的名称。

The result must be freed with duckdb_free.

Syntax 
char *duckdb_union_type_member_name(
  duckdb_logical_type type,
  idx_t index
);
Parameters
  • type: The logical type object
  • index: The child index
Return Value

The name of the union member. Must be freed with duckdb_free.


duckdb_union_type_member_type

检索指定索引处给定联合成员的子类型。

The result must be freed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_union_type_member_type(
  duckdb_logical_type type,
  idx_t index
);
Parameters
  • type: The logical type object
  • index: The child index
Return Value

The child type of the union member. Must be destroyed with duckdb_destroy_logical_type.


duckdb_destroy_logical_type

销毁逻辑类型并释放为该类型分配的所有内存。

Syntax 
void duckdb_destroy_logical_type(
  duckdb_logical_type *type
);
Parameters
  • type: The logical type to destroy.


duckdb_register_logical_type

在给定的连接中注册一个自定义类型。 该类型必须有一个别名

Syntax 
duckdb_state duckdb_register_logical_type(
  duckdb_connection con,
  duckdb_logical_type type,
  duckdb_create_type_info info
);
Parameters
  • con: The connection to use
  • type: The custom type to register
Return Value

注册是否成功。


duckdb_create_data_chunk

Creates an empty data chunk with the specified column types. The result must be destroyed with duckdb_destroy_data_chunk.

Syntax 
duckdb_data_chunk duckdb_create_data_chunk(
  duckdb_logical_type *types,
  idx_t column_count
);
Parameters
  • types: An array of column types. Column types can not contain ANY and INVALID types.
  • column_count: The number of columns.
Return Value

数据块。


duckdb_destroy_data_chunk

销毁数据块并释放为该块分配的所有内存。

Syntax 
void duckdb_destroy_data_chunk(
  duckdb_data_chunk *chunk
);
Parameters
  • chunk: The data chunk to destroy.


duckdb_data_chunk_reset

Resets a data chunk, clearing the validity masks and setting the cardinality of the data chunk to 0. After calling this method, you must call duckdb_vector_get_validity and duckdb_vector_get_data to obtain current data and validity pointers

Syntax 
void duckdb_data_chunk_reset(
  duckdb_data_chunk chunk
);
Parameters
  • chunk: The data chunk to reset.


duckdb_data_chunk_get_column_count

检索数据块中的列数。

Syntax 
idx_t duckdb_data_chunk_get_column_count(
  duckdb_data_chunk chunk
);
Parameters
  • chunk: The data chunk to get the data from
Return Value

数据块中的列数


duckdb_data_chunk_get_vector

检索数据块中指定列索引处的向量。

指向向量的指针在块存活期间有效。 它不需要被销毁。

Syntax 
duckdb_vector duckdb_data_chunk_get_vector(
  duckdb_data_chunk chunk,
  idx_t col_idx
);
Parameters
  • chunk: The data chunk to get the data from
Return Value

向量


duckdb_data_chunk_get_size

检索数据块中当前的元组数量。

Syntax 
idx_t duckdb_data_chunk_get_size(
  duckdb_data_chunk chunk
);
Parameters
  • chunk: The data chunk to get the data from
Return Value

数据块中的元组数量


duckdb_data_chunk_set_size

设置数据块中当前元组的数量。

Syntax 
void duckdb_data_chunk_set_size(
  duckdb_data_chunk chunk,
  idx_t size
);
Parameters
  • chunk: The data chunk to set the size in
  • size: The number of tuples in the data chunk


duckdb_vector_get_column_type

检索指定向量的列类型。

The result must be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_vector_get_column_type(
  duckdb_vector vector
);
Parameters
  • vector: The vector get the data from
Return Value

向量的类型


duckdb_vector_get_data

检索向量的数据指针。

数据指针可用于从向量中读取或写入值。如何读取或写入值取决于向量的类型。

Syntax 
void *duckdb_vector_get_data(
  duckdb_vector vector
);
Parameters
  • vector: The vector to get the data from
Return Value

数据指针


duckdb_vector_get_validity

检索指定向量的有效性掩码指针。

如果所有值都有效，此函数可能返回NULL！

有效性掩码是一个位集，表示数据块中的空值情况。 它是一系列uint64_t值，每个uint64_t值包含64个元组的有效性。 如果值为有效（即不为NULL），则位设置为1；如果值为无效（即为NULL），则位设置为0。

可以通过以下方式获取特定值的有效性：

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

或者，可以使用（较慢的）duckdb_validity_row_is_valid函数。

Syntax 
uint64_t *duckdb_vector_get_validity(
  duckdb_vector vector
);
Parameters
  • vector: The vector to get the data from
Return Value

指向有效性掩码的指针，如果没有有效性掩码则为NULL


duckdb_vector_ensure_validity_writable

通过分配确保有效性掩码是可写的。

调用此函数后，duckdb_vector_get_validity 将始终返回非NULL值。 这允许将空值写入向量，无论之前是否存在有效性掩码。

Syntax 
void duckdb_vector_ensure_validity_writable(
  duckdb_vector vector
);
Parameters
  • vector: The vector to alter


duckdb_vector_assign_string_element

在向量的指定位置分配一个字符串元素。

Syntax 
void duckdb_vector_assign_string_element(
  duckdb_vector vector,
  idx_t index,
  const char *str
);
Parameters
  • vector: The vector to alter
  • index: The row position in the vector to assign the string to
  • str: The null-terminated string


duckdb_vector_assign_string_element_len

在向量的指定位置分配一个字符串元素。你也可以使用此函数来分配BLOBs。

Syntax 
void duckdb_vector_assign_string_element_len(
  duckdb_vector vector,
  idx_t index,
  const char *str,
  idx_t str_len
);
Parameters
  • vector: The vector to alter
  • index: The row position in the vector to assign the string to
  • str: The string
  • str_len: The length of the string (in bytes)


duckdb_list_vector_get_child

检索列表向量的子向量。

只要父向量有效，生成的向量就有效。

Syntax 
duckdb_vector duckdb_list_vector_get_child(
  duckdb_vector vector
);
Parameters
  • vector: The vector
Return Value

子向量


duckdb_list_vector_get_size

返回列表子向量的大小。

Syntax 
idx_t duckdb_list_vector_get_size(
  duckdb_vector vector
);
Parameters
  • vector: The vector
Return Value

子列表的大小


duckdb_list_vector_set_size

设置列表向量的基础子向量的总大小。

Syntax 
duckdb_state duckdb_list_vector_set_size(
  duckdb_vector vector,
  idx_t size
);
Parameters
  • vector: The list vector.
  • size: The size of the child list.
Return Value

duckdb 状态。如果向量为 nullptr，则返回 DuckDBError。


duckdb_list_vector_reserve

设置列表底层子向量的总容量。

After calling this method, you must call duckdb_vector_get_validity and duckdb_vector_get_data to obtain current data and validity pointers

Syntax 
duckdb_state duckdb_list_vector_reserve(
  duckdb_vector vector,
  idx_t required_capacity
);
Parameters
  • vector: The list vector.
  • required_capacity: the total capacity to reserve.
Return Value

duckdb 状态。如果向量为 nullptr，则返回 DuckDBError。


duckdb_struct_vector_get_child

检索结构向量的子向量。

只要父向量有效，生成的向量就有效。

Syntax 
duckdb_vector duckdb_struct_vector_get_child(
  duckdb_vector vector,
  idx_t index
);
Parameters
  • vector: The vector
  • index: The child index
Return Value

子向量


duckdb_array_vector_get_child

检索数组向量的子向量。

只要父向量有效，结果向量就有效。 结果向量的大小是父向量的大小乘以数组大小。

Syntax 
duckdb_vector duckdb_array_vector_get_child(
  duckdb_vector vector
);
Parameters
  • vector: The vector
Return Value

子向量


duckdb_validity_row_is_valid

返回给定有效性掩码中的一行是否有效（即不为NULL）。

Syntax 
bool duckdb_validity_row_is_valid(
  uint64_t *validity,
  idx_t row
);
Parameters
  • validity: The validity mask, as obtained through duckdb_vector_get_validity
  • row: The row index
Return Value

如果行有效则为true，否则为false


duckdb_validity_set_row_validity

在有效性掩码中，将特定行设置为有效或无效。

Note that duckdb_vector_ensure_validity_writable should be called before calling duckdb_vector_get_validity, to ensure that there is a validity mask to write to.

Syntax 
void duckdb_validity_set_row_validity(
  uint64_t *validity,
  idx_t row,
  bool valid
);
Parameters
  • validity: The validity mask, as obtained through duckdb_vector_get_validity.
  • row: The row index
  • valid: Whether or not to set the row to valid, or invalid


duckdb_validity_set_row_invalid

在有效性掩码中，将特定行设置为无效。

Equivalent to duckdb_validity_set_row_validity with valid set to false.

Syntax 
void duckdb_validity_set_row_invalid(
  uint64_t *validity,
  idx_t row
);
Parameters
  • validity: The validity mask
  • row: The row index


duckdb_validity_set_row_valid

在有效性掩码中，将特定行设置为有效。

Equivalent to duckdb_validity_set_row_validity with valid set to true.

Syntax 
void duckdb_validity_set_row_valid(
  uint64_t *validity,
  idx_t row
);
Parameters
  • validity: The validity mask
  • row: The row index


duckdb_create_scalar_function

创建一个新的空标量函数。

返回值应使用duckdb_destroy_scalar_function销毁。

Return Value

标量函数对象。

Syntax 
duckdb_scalar_function duckdb_create_scalar_function(
  
);


duckdb_destroy_scalar_function

销毁给定的标量函数对象。

Syntax 
void duckdb_destroy_scalar_function(
  duckdb_scalar_function *scalar_function
);
Parameters
  • scalar_function: 要销毁的标量函数


duckdb_scalar_function_set_name

设置给定标量函数的名称。

Syntax 
void duckdb_scalar_function_set_name(
  duckdb_scalar_function scalar_function,
  const char *name
);
Parameters
  • scalar_function: 标量函数
  • name: 标量函数的名称


duckdb_scalar_function_set_varargs

将给定标量函数的参数设置为可变参数。不需要使用duckdb_scalar_function_add_parameter添加参数。

Syntax 
void duckdb_scalar_function_set_varargs(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);
Parameters
  • scalar_function: 标量函数。
  • type: 参数的类型。
Return Value

参数类型。不能包含INVALID。


duckdb_scalar_function_set_special_handling

将给定标量函数的参数设置为可变参数。不需要使用duckdb_scalar_function_add_parameter添加参数。

Syntax 
void duckdb_scalar_function_set_special_handling(
  duckdb_scalar_function scalar_function
);
Parameters
  • scalar_function: 标量函数。


duckdb_scalar_function_set_volatile

将标量函数的函数稳定性设置为VOLATILE，表示该函数应该为每一行重新运行。 这限制了可以为该函数执行的优化。

Syntax 
void duckdb_scalar_function_set_volatile(
  duckdb_scalar_function scalar_function
);
Parameters
  • scalar_function: 标量函数。


duckdb_scalar_function_add_parameter

向标量函数添加一个参数。

Syntax 
void duckdb_scalar_function_add_parameter(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);
Parameters
  • scalar_function: 标量函数。
  • type: The parameter type. Cannot contain INVALID.


duckdb_scalar_function_set_return_type

设置标量函数的返回类型。

Syntax 
void duckdb_scalar_function_set_return_type(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);
Parameters
  • scalar_function: 标量函数
  • type: 不能包含 INVALID 或 ANY。


duckdb_scalar_function_set_extra_info

为标量函数分配额外的信息，这些信息可以在绑定等过程中获取。

Syntax 
void duckdb_scalar_function_set_extra_info(
  duckdb_scalar_function scalar_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);
Parameters
  • scalar_function: 标量函数
  • extra_info: The extra information
  • destroy: The callback that will be called to destroy the bind data (if any)


duckdb_scalar_function_set_function

设置标量函数的主函数。

Syntax 
void duckdb_scalar_function_set_function(
  duckdb_scalar_function scalar_function,
  duckdb_scalar_function_t function
);
Parameters
  • scalar_function: 标量函数
  • function: The function


duckdb_register_scalar_function

在给定的连接中注册标量函数对象。

该函数至少需要一个名称、一个函数和一个返回类型。

如果函数不完整或已存在同名函数，则返回DuckDBError。

Syntax 
duckdb_state duckdb_register_scalar_function(
  duckdb_connection con,
  duckdb_scalar_function scalar_function
);
Parameters
  • con: The connection to register it in.
  • scalar_function: 函数指针
Return Value

注册是否成功。


duckdb_scalar_function_get_extra_info

检索在duckdb_scalar_function_set_extra_info中设置的函数的额外信息。

Syntax 
void *duckdb_scalar_function_get_extra_info(
  duckdb_function_info info
);
Parameters
  • info: 信息对象。
Return Value

额外信息。


duckdb_scalar_function_set_error

报告在执行标量函数时发生了错误。

Syntax 
void duckdb_scalar_function_set_error(
  duckdb_function_info info,
  const char *error
);
Parameters
  • info: 信息对象。
  • error: The error message


duckdb_create_scalar_function_set

创建一个新的空标量函数集。

返回值应使用duckdb_destroy_scalar_function_set销毁。

Return Value

标量函数集对象。

Syntax 
duckdb_scalar_function_set duckdb_create_scalar_function_set(
  const char *name
);


duckdb_destroy_scalar_function_set

销毁给定的标量函数集对象。

Syntax 
void duckdb_destroy_scalar_function_set(
  duckdb_scalar_function_set *scalar_function_set
);


duckdb_add_scalar_function_to_set

将标量函数作为新的重载添加到标量函数集中。

如果无法添加函数，例如如果重载已经存在，则返回DuckDBError。

Syntax 
duckdb_state duckdb_add_scalar_function_to_set(
  duckdb_scalar_function_set set,
  duckdb_scalar_function function
);
Parameters
  • set: 标量函数集合
  • function: 要添加的函数


duckdb_register_scalar_function_set

在给定的连接中注册标量函数集。

集合至少需要一个有效的重载。

如果集合不完整或已存在具有此名称的函数，则返回DuckDBError。

Syntax 
duckdb_state duckdb_register_scalar_function_set(
  duckdb_connection con,
  duckdb_scalar_function_set set
);
Parameters
  • con: The connection to register it in.
  • set: 要注册的函数集
Return Value

注册是否成功。


duckdb_create_aggregate_function

创建一个新的空聚合函数。

返回值应使用duckdb_destroy_aggregate_function销毁。

Return Value

聚合函数对象。

Syntax 
duckdb_aggregate_function duckdb_create_aggregate_function(
  
);


duckdb_destroy_aggregate_function

销毁给定的聚合函数对象。

Syntax 
void duckdb_destroy_aggregate_function(
  duckdb_aggregate_function *aggregate_function
);


duckdb_aggregate_function_set_name

设置给定聚合函数的名称。

Syntax 
void duckdb_aggregate_function_set_name(
  duckdb_aggregate_function aggregate_function,
  const char *name
);
Parameters
  • aggregate_function: 聚合函数
  • name: 聚合函数的名称


duckdb_aggregate_function_add_parameter

向聚合函数添加一个参数。

Syntax 
void duckdb_aggregate_function_add_parameter(
  duckdb_aggregate_function aggregate_function,
  duckdb_logical_type type
);
Parameters
  • aggregate_function: 聚合函数。
  • type: The parameter type. Cannot contain INVALID.


duckdb_aggregate_function_set_return_type

设置聚合函数的返回类型。

Syntax 
void duckdb_aggregate_function_set_return_type(
  duckdb_aggregate_function aggregate_function,
  duckdb_logical_type type
);
Parameters
  • aggregate_function: 聚合函数。
  • type: 返回类型。不能包含 INVALID 或 ANY。


duckdb_aggregate_function_set_functions

设置聚合函数的主要功能。

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
);
Parameters
  • aggregate_function: 聚合函数
  • state_size: 状态大小
  • state_init: 状态初始化函数
  • update: 更新状态
  • combine: 合并状态
  • finalize: 完成状态


duckdb_aggregate_function_set_destructor

设置聚合函数的状态析构回调（可选）

Syntax 
void duckdb_aggregate_function_set_destructor(
  duckdb_aggregate_function aggregate_function,
  duckdb_aggregate_destroy_t destroy
);
Parameters
  • aggregate_function: 聚合函数
  • destroy: 状态销毁回调


duckdb_register_aggregate_function

在给定的连接中注册聚合函数对象。

该函数至少需要一个名称、函数和返回类型。

如果函数不完整或已存在同名函数，则返回DuckDBError。

Syntax 
duckdb_state duckdb_register_aggregate_function(
  duckdb_connection con,
  duckdb_aggregate_function aggregate_function
);
Parameters
  • con: The connection to register it in.
Return Value

注册是否成功。


duckdb_aggregate_function_set_special_handling

将聚合函数的NULL处理设置为SPECIAL_HANDLING。

Syntax 
void duckdb_aggregate_function_set_special_handling(
  duckdb_aggregate_function aggregate_function
);
Parameters
  • aggregate_function: The aggregate function


duckdb_aggregate_function_set_extra_info

为标量函数分配额外的信息，这些信息可以在绑定等过程中获取。

Syntax 
void duckdb_aggregate_function_set_extra_info(
  duckdb_aggregate_function aggregate_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);
Parameters
  • aggregate_function: The aggregate function
  • extra_info: The extra information
  • destroy: The callback that will be called to destroy the bind data (if any)


duckdb_aggregate_function_get_extra_info

检索在duckdb_aggregate_function_set_extra_info中设置的函数的额外信息。

Syntax 
void *duckdb_aggregate_function_get_extra_info(
  duckdb_function_info info
);
Parameters
  • info: The info object
Return Value

额外信息


duckdb_aggregate_function_set_error

报告在执行聚合函数时发生错误。

Syntax 
void duckdb_aggregate_function_set_error(
  duckdb_function_info info,
  const char *error
);
Parameters
  • info: The info object
  • error: The error message


duckdb_create_aggregate_function_set

创建一个新的空聚合函数集。

返回值应使用duckdb_destroy_aggregate_function_set销毁。

Return Value

聚合函数集对象。

Syntax 
duckdb_aggregate_function_set duckdb_create_aggregate_function_set(
  const char *name
);


duckdb_destroy_aggregate_function_set

销毁给定的聚合函数集对象。

Syntax 
void duckdb_destroy_aggregate_function_set(
  duckdb_aggregate_function_set *aggregate_function_set
);


duckdb_add_aggregate_function_to_set

将聚合函数作为新的重载添加到聚合函数集中。

如果无法添加函数，例如如果重载已经存在，则返回DuckDBError。

Syntax 
duckdb_state duckdb_add_aggregate_function_to_set(
  duckdb_aggregate_function_set set,
  duckdb_aggregate_function function
);
Parameters
  • set: 聚合函数集合
  • function: The function to add


duckdb_register_aggregate_function_set

在给定的连接中注册聚合函数集。

集合至少需要一个有效的重载。

如果集合不完整或已存在具有此名称的函数，则返回DuckDBError。

Syntax 
duckdb_state duckdb_register_aggregate_function_set(
  duckdb_connection con,
  duckdb_aggregate_function_set set
);
Parameters
  • con: The connection to register it in.
  • set: The function set to register
Return Value

注册是否成功。


duckdb_create_table_function

创建一个新的空表函数。

The return value should be destroyed with duckdb_destroy_table_function.

Return Value

表格函数对象。

Syntax 
duckdb_table_function duckdb_create_table_function(
  
);


duckdb_destroy_table_function

销毁给定的表函数对象。

Syntax 
void duckdb_destroy_table_function(
  duckdb_table_function *table_function
);
Parameters
  • table_function: The table function to destroy


duckdb_table_function_set_name

设置给定表函数的名称。

Syntax 
void duckdb_table_function_set_name(
  duckdb_table_function table_function,
  const char *name
);
Parameters
  • table_function: The table function
  • name: The name of the table function


duckdb_table_function_add_parameter

向表函数添加一个参数。

Syntax 
void duckdb_table_function_add_parameter(
  duckdb_table_function table_function,
  duckdb_logical_type type
);
Parameters
  • table_function: The table function.
  • type: The parameter type. Cannot contain INVALID.


duckdb_table_function_add_named_parameter

向表函数添加一个命名参数。

Syntax 
void duckdb_table_function_add_named_parameter(
  duckdb_table_function table_function,
  const char *name,
  duckdb_logical_type type
);
Parameters
  • table_function: The table function.
  • name: The parameter name.
  • type: The parameter type. Cannot contain INVALID.


duckdb_table_function_set_extra_info

为表函数分配额外的信息，这些信息可以在绑定等过程中获取。

Syntax 
void duckdb_table_function_set_extra_info(
  duckdb_table_function table_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);
Parameters
  • table_function: The table function
  • extra_info: The extra information
  • destroy: The callback that will be called to destroy the bind data (if any)


duckdb_table_function_set_bind

设置表函数的绑定函数。

Syntax 
void duckdb_table_function_set_bind(
  duckdb_table_function table_function,
  duckdb_table_function_bind_t bind
);
Parameters
  • table_function: The table function
  • bind: The bind function


duckdb_table_function_set_init

设置表函数的初始化函数。

Syntax 
void duckdb_table_function_set_init(
  duckdb_table_function table_function,
  duckdb_table_function_init_t init
);
Parameters
  • table_function: The table function
  • init: The init function


duckdb_table_function_set_local_init

设置表函数的线程本地初始化函数。

Syntax 
void duckdb_table_function_set_local_init(
  duckdb_table_function table_function,
  duckdb_table_function_init_t init
);
Parameters
  • table_function: The table function
  • init: The init function


duckdb_table_function_set_function

设置表函数的主要功能。

Syntax 
void duckdb_table_function_set_function(
  duckdb_table_function table_function,
  duckdb_table_function_t function
);
Parameters
  • table_function: The table function
  • function: The function


duckdb_table_function_supports_projection_pushdown

设置给定的表函数是否支持投影下推。

If this is set to true, the system will provide a list of all required columns in the init stage through the duckdb_init_get_column_count and duckdb_init_get_column_index functions. If this is set to false (the default), the system will expect all columns to be projected.

Syntax 
void duckdb_table_function_supports_projection_pushdown(
  duckdb_table_function table_function,
  bool pushdown
);
Parameters
  • table_function: The table function
  • pushdown: True if the table function supports projection pushdown, false otherwise.


duckdb_register_table_function

在给定的连接中注册表函数对象。

该函数至少需要一个名称、一个绑定函数、一个初始化函数和一个主函数。

如果函数不完整或已存在同名函数，则返回DuckDBError。

Syntax 
duckdb_state duckdb_register_table_function(
  duckdb_connection con,
  duckdb_table_function function
);
Parameters
  • con: The connection to register it in.
  • function: The function pointer
Return Value

注册是否成功。


duckdb_bind_get_extra_info

Retrieves the extra info of the function as set in duckdb_table_function_set_extra_info.

Syntax 
void *duckdb_bind_get_extra_info(
  duckdb_bind_info info
);
Parameters
  • info: The info object
Return Value

额外信息


duckdb_bind_add_result_column

向表函数的输出添加一个结果列。

Syntax 
void duckdb_bind_add_result_column(
  duckdb_bind_info info,
  const char *name,
  duckdb_logical_type type
);
Parameters
  • info: The table function's bind info.
  • name: The column name.
  • type: The logical column type.


duckdb_bind_get_parameter_count

获取函数的常规（非命名）参数的数量。

Syntax 
idx_t duckdb_bind_get_parameter_count(
  duckdb_bind_info info
);
Parameters
  • info: The info object
Return Value

参数的数量


duckdb_bind_get_parameter

检索给定索引处的参数。

The result must be destroyed with duckdb_destroy_value.

Syntax 
duckdb_value duckdb_bind_get_parameter(
  duckdb_bind_info info,
  idx_t index
);
Parameters
  • info: The info object
  • index: The index of the parameter to get
Return Value

The value of the parameter. Must be destroyed with duckdb_destroy_value.


duckdb_bind_get_named_parameter

检索具有给定名称的命名参数。

The result must be destroyed with duckdb_destroy_value.

Syntax 
duckdb_value duckdb_bind_get_named_parameter(
  duckdb_bind_info info,
  const char *name
);
Parameters
  • info: The info object
  • name: The name of the parameter
Return Value

The value of the parameter. Must be destroyed with duckdb_destroy_value.


duckdb_bind_set_bind_data

在绑定对象中设置用户提供的绑定数据。此对象可以在执行期间再次检索。

Syntax 
void duckdb_bind_set_bind_data(
  duckdb_bind_info info,
  void *bind_data,
  duckdb_delete_callback_t destroy
);
Parameters
  • info: The info object
  • bind_data: The bind data object.
  • destroy: The callback that will be called to destroy the bind data (if any)


duckdb_bind_set_cardinality

设置表函数的基数估计，用于优化。

Syntax 
void duckdb_bind_set_cardinality(
  duckdb_bind_info info,
  idx_t cardinality,
  bool is_exact
);
Parameters
  • info: The bind data object.
  • is_exact: Whether or not the cardinality estimate is exact, or an approximation


duckdb_bind_set_error

报告在调用bind时发生错误。

Syntax 
void duckdb_bind_set_error(
  duckdb_bind_info info,
  const char *error
);
Parameters
  • info: The info object
  • error: The error message


duckdb_init_get_extra_info

Retrieves the extra info of the function as set in duckdb_table_function_set_extra_info.

Syntax 
void *duckdb_init_get_extra_info(
  duckdb_init_info info
);
Parameters
  • info: The info object
Return Value

额外信息


duckdb_init_get_bind_data

Gets the bind data set by duckdb_bind_set_bind_data during the bind.

请注意，绑定数据应被视为只读。 对于跟踪状态，请改用初始化数据。

Syntax 
void *duckdb_init_get_bind_data(
  duckdb_init_info info
);
Parameters
  • info: The info object
Return Value

绑定数据对象


duckdb_init_set_init_data

在初始化对象中设置用户提供的初始化数据。此对象可以在执行期间再次检索。

Syntax 
void duckdb_init_set_init_data(
  duckdb_init_info info,
  void *init_data,
  duckdb_delete_callback_t destroy
);
Parameters
  • info: The info object
  • init_data: The init data object.
  • destroy: The callback that will be called to destroy the init data (if any)


duckdb_init_get_column_count

返回投影列的数量。

如果启用了投影下推，必须使用此函数来确定要发出的列。

Syntax 
idx_t duckdb_init_get_column_count(
  duckdb_init_info info
);
Parameters
  • info: The info object
Return Value

预计的列数。


duckdb_init_get_column_index

返回指定位置投影列的列索引。

如果启用了投影下推，必须使用此函数来确定要发出的列。

Syntax 
idx_t duckdb_init_get_column_index(
  duckdb_init_info info,
  idx_t column_index
);
Parameters
  • info: The info object
  • column_index: The index at which to get the projected column index, from 0..duckdb_init_get_column_count(info)
Return Value

投影列的列索引。


duckdb_init_set_max_threads

设置可以并行处理此表函数的线程数（默认值：1）

Syntax 
void duckdb_init_set_max_threads(
  duckdb_init_info info,
  idx_t max_threads
);
Parameters
  • info: The info object
  • max_threads: The maximum amount of threads that can process this table function


duckdb_init_set_error

报告在调用init时发生错误。

Syntax 
void duckdb_init_set_error(
  duckdb_init_info info,
  const char *error
);
Parameters
  • info: The info object
  • error: The error message


duckdb_function_get_extra_info

Retrieves the extra info of the function as set in duckdb_table_function_set_extra_info.

Syntax 
void *duckdb_function_get_extra_info(
  duckdb_function_info info
);
Parameters
  • info: The info object
Return Value

额外信息


duckdb_function_get_bind_data

Gets the bind data set by duckdb_bind_set_bind_data during the bind.

请注意，绑定数据应被视为只读。 对于跟踪状态，请改用初始化数据。

Syntax 
void *duckdb_function_get_bind_data(
  duckdb_function_info info
);
Parameters
  • info: The info object
Return Value

绑定数据对象


duckdb_function_get_init_data

Gets the init data set by duckdb_init_set_init_data during the init.

Syntax 
void *duckdb_function_get_init_data(
  duckdb_function_info info
);
Parameters
  • info: The info object
Return Value

初始化数据对象


duckdb_function_get_local_init_data

Gets the thread-local init data set by duckdb_init_set_init_data during the local_init.

Syntax 
void *duckdb_function_get_local_init_data(
  duckdb_function_info info
);
Parameters
  • info: The info object
Return Value

初始化数据对象


duckdb_function_set_error

报告在执行函数时发生了错误。

Syntax 
void duckdb_function_set_error(
  duckdb_function_info info,
  const char *error
);
Parameters
  • info: The info object
  • error: The error message


duckdb_add_replacement_scan

向指定的数据库添加替换扫描定义。

Syntax 
void duckdb_add_replacement_scan(
  duckdb_database db,
  duckdb_replacement_callback_t replacement,
  void *extra_data,
  duckdb_delete_callback_t delete_callback
);
Parameters
  • db: The database object to add the replacement scan to
  • replacement: The replacement scan callback
  • extra_data: Extra data that is passed back into the specified callback
  • delete_callback: The delete callback to call on the extra data, if any


duckdb_replacement_scan_set_function_name

设置替换函数名称。如果在替换回调中调用此函数，则执行替换扫描。如果未调用，则不执行替换回调。

Syntax 
void duckdb_replacement_scan_set_function_name(
  duckdb_replacement_scan_info info,
  const char *function_name
);
Parameters
  • info: The info object
  • function_name: The function name to substitute.


duckdb_replacement_scan_add_parameter

向替换扫描函数添加一个参数。

Syntax 
void duckdb_replacement_scan_add_parameter(
  duckdb_replacement_scan_info info,
  duckdb_value parameter
);
Parameters
  • info: The info object
  • parameter: The parameter to add.


duckdb_replacement_scan_set_error

报告在执行替换扫描时发生错误。

Syntax 
void duckdb_replacement_scan_set_error(
  duckdb_replacement_scan_info info,
  const char *error
);
Parameters
  • info: The info object
  • error: The error message


duckdb_get_profiling_info

返回分析信息的根节点。如果未启用分析，则返回 nullptr。

Syntax 
duckdb_profiling_info duckdb_get_profiling_info(
  duckdb_connection connection
);
Parameters
  • connection: 一个连接对象。
Return Value

一个性能分析信息对象。


duckdb_profiling_info_get_value

返回当前分析信息节点的度量值。如果度量不存在或未启用，则返回 nullptr。目前，该值包含一个字符串，您可以通过调用相应的函数来检索该字符串：char *duckdb_get_varchar(duckdb_value value)。

Syntax 
duckdb_value duckdb_profiling_info_get_value(
  duckdb_profiling_info info,
  const char *key
);
Parameters
  • info: 一个性能分析信息对象。
  • key: 请求的指标名称。
Return Value

指标的值。必须使用duckdb_destroy_value释放


duckdb_profiling_info_get_metrics

返回此分析节点的键值度量映射作为MAP duckdb_value。 可以通过duckdb_value MAP函数访问各个元素。

Syntax 
duckdb_value duckdb_profiling_info_get_metrics(
  duckdb_profiling_info info
);
Parameters
  • info: 一个性能分析信息对象。
Return Value

键值度量映射作为MAP duckdb_value。


duckdb_profiling_info_get_child_count

返回当前分析信息节点中的子节点数量。

Syntax 
idx_t duckdb_profiling_info_get_child_count(
  duckdb_profiling_info info
);
Parameters
  • info: 一个分析信息对象。
Return Value

当前节点中的子节点数量。


duckdb_profiling_info_get_child

返回指定索引处的子节点。

Syntax 
duckdb_profiling_info duckdb_profiling_info_get_child(
  duckdb_profiling_info info,
  idx_t index
);
Parameters
  • info: 一个分析信息对象。
  • index: 子节点的索引。
Return Value

指定索引处的子节点。


duckdb_appender_create

创建一个附加器对象。

Note that the object must be destroyed with duckdb_appender_destroy.

Syntax 
duckdb_state duckdb_appender_create(
  duckdb_connection connection,
  const char *schema,
  const char *table,
  duckdb_appender *out_appender
);
Parameters
  • connection: The connection context to create the appender in.
  • schema: The schema of the table to append to, or nullptr for the default schema.
  • table: The table name to append to.
  • out_appender: The resulting appender object.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_appender_column_count

返回属于追加器的表中的列数。

Syntax 
idx_t duckdb_appender_column_count(
  duckdb_appender appender
);
Parameters
  • appender: The appender to get the column count from.
Return Value

表中的列数。


duckdb_appender_column_type

返回指定索引处列的类型。

Note: The resulting type should be destroyed with duckdb_destroy_logical_type.

Syntax 
duckdb_logical_type duckdb_appender_column_type(
  duckdb_appender appender,
  idx_t col_idx
);
Parameters
  • appender: The appender to get the column type from.
  • col_idx: The index of the column to get the type of.
Return Value

列的duckdb_logical_type。


duckdb_appender_error

Returns the error message associated with the given appender. If the appender has no error message, this returns nullptr instead.

The error message should not be freed. It will be de-allocated when duckdb_appender_destroy is called.

Syntax 
const char *duckdb_appender_error(
  duckdb_appender appender
);
Parameters
  • appender: The appender to get the error from.
Return Value

The error message, or nullptr if there is none.


duckdb_appender_flush

将appender刷新到表中，强制清除appender的缓存。如果刷新数据时触发约束违规或任何其他错误，则所有数据都将失效，并且此函数返回DuckDBError。无法再追加更多值。调用duckdb_appender_error以获取错误消息，然后调用duckdb_appender_destroy以销毁失效的appender。

Syntax 
duckdb_state duckdb_appender_flush(
  duckdb_appender appender
);
Parameters
  • appender: The appender to flush.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_appender_close

通过刷新所有中间状态并关闭它以进行进一步的追加来关闭appender。如果刷新数据触发约束违规或任何其他错误，则所有数据都将失效，并且此函数返回DuckDBError。调用duckdb_appender_error以获取错误消息，然后调用duckdb_appender_destroy以销毁失效的appender。

Syntax 
duckdb_state duckdb_appender_close(
  duckdb_appender appender
);
Parameters
  • appender: The appender to flush and close.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_appender_destroy

通过将所有中间状态刷新到表并销毁它来关闭appender。通过销毁它，此函数释放与appender相关的所有内存。如果刷新数据触发约束违规，则所有数据都将失效，并且此函数返回DuckDBError。由于appender的销毁，不再可能通过duckdb_appender_error获取特定的错误消息。因此，如果您需要了解特定错误的详细信息，请在销毁appender之前调用duckdb_appender_close。

Syntax 
duckdb_state duckdb_appender_destroy(
  duckdb_appender *appender
);
Parameters
  • appender: The appender to flush, close and destroy.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_appender_begin_row

A nop function, provided for backwards compatibility reasons. Does nothing. Only duckdb_appender_end_row is required.

Syntax 
duckdb_state duckdb_appender_begin_row(
  duckdb_appender appender
);


duckdb_appender_end_row

完成当前行的追加。调用end_row后，可以追加下一行。

Syntax 
duckdb_state duckdb_appender_end_row(
  duckdb_appender appender
);
Parameters
  • appender: The appender.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_append_default

向appender追加一个DEFAULT值（如果列不可用DEFAULT，则为NULL）。

Syntax 
duckdb_state duckdb_append_default(
  duckdb_appender appender
);


duckdb_append_bool

向appender追加一个布尔值。

Syntax 
duckdb_state duckdb_append_bool(
  duckdb_appender appender,
  bool value
);


duckdb_append_int8

将一个int8_t值附加到appender。

Syntax 
duckdb_state duckdb_append_int8(
  duckdb_appender appender,
  int8_t value
);


duckdb_append_int16

向appender追加一个int16_t值。

Syntax 
duckdb_state duckdb_append_int16(
  duckdb_appender appender,
  int16_t value
);


duckdb_append_int32

向appender追加一个int32_t值。

Syntax 
duckdb_state duckdb_append_int32(
  duckdb_appender appender,
  int32_t value
);


duckdb_append_int64

将一个int64_t值附加到appender。

Syntax 
duckdb_state duckdb_append_int64(
  duckdb_appender appender,
  int64_t value
);


duckdb_append_hugeint

向appender添加一个duckdb_hugeint值。

Syntax 
duckdb_state duckdb_append_hugeint(
  duckdb_appender appender,
  duckdb_hugeint value
);


duckdb_append_uint8

将一个uint8_t值附加到appender。

Syntax 
duckdb_state duckdb_append_uint8(
  duckdb_appender appender,
  uint8_t value
);


duckdb_append_uint16

将一个uint16_t值附加到appender。

Syntax 
duckdb_state duckdb_append_uint16(
  duckdb_appender appender,
  uint16_t value
);


duckdb_append_uint32

向appender追加一个uint32_t值。

Syntax 
duckdb_state duckdb_append_uint32(
  duckdb_appender appender,
  uint32_t value
);


duckdb_append_uint64

将一个uint64_t值附加到appender。

Syntax 
duckdb_state duckdb_append_uint64(
  duckdb_appender appender,
  uint64_t value
);


duckdb_append_uhugeint

向appender追加一个duckdb_uhugeint值。

Syntax 
duckdb_state duckdb_append_uhugeint(
  duckdb_appender appender,
  duckdb_uhugeint value
);


duckdb_append_float

向追加器追加一个浮点值。

Syntax 
duckdb_state duckdb_append_float(
  duckdb_appender appender,
  float value
);


duckdb_append_double

向appender追加一个双精度值。

Syntax 
duckdb_state duckdb_append_double(
  duckdb_appender appender,
  double value
);


duckdb_append_date

向appender追加一个duckdb_date值。

Syntax 
duckdb_state duckdb_append_date(
  duckdb_appender appender,
  duckdb_date value
);


duckdb_append_time

向appender追加一个duckdb_time值。

Syntax 
duckdb_state duckdb_append_time(
  duckdb_appender appender,
  duckdb_time value
);


duckdb_append_timestamp

向appender追加一个duckdb_timestamp值。

Syntax 
duckdb_state duckdb_append_timestamp(
  duckdb_appender appender,
  duckdb_timestamp value
);


duckdb_append_interval

向appender添加一个duckdb_interval值。

Syntax 
duckdb_state duckdb_append_interval(
  duckdb_appender appender,
  duckdb_interval value
);


duckdb_append_varchar

将一个varchar值附加到appender。

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


duckdb_append_varchar_length

将一个varchar值附加到appender。

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


duckdb_append_blob

向追加器追加一个blob值。

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


duckdb_append_null

向appender追加一个NULL值（任何类型）。

Syntax 
duckdb_state duckdb_append_null(
  duckdb_appender appender
);


duckdb_append_data_chunk

将预填充的数据块附加到指定的附加器。

数据块的类型必须与表的类型完全匹配，不执行类型转换。 如果类型不匹配或appender处于无效状态，则返回DuckDBError。 如果追加成功，则返回DuckDBSuccess。

Syntax 
duckdb_state duckdb_append_data_chunk(
  duckdb_appender appender,
  duckdb_data_chunk chunk
);
Parameters
  • appender: The appender to append to.
  • chunk: The data chunk to append.
Return Value

返回状态。


duckdb_table_description_create

创建一个表描述对象。请注意，即使函数返回DuckDBError，也应始终在生成的table_description上调用duckdb_table_description_destroy。

Syntax 
duckdb_state duckdb_table_description_create(
  duckdb_connection connection,
  const char *schema,
  const char *table,
  duckdb_table_description *out
);
Parameters
  • connection: 连接上下文。
  • schema: 表的模式，或使用nullptr表示默认模式。
  • table: 表名。
  • out: 结果表描述对象。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_table_description_destroy

销毁TableDescription对象。

Syntax 
void duckdb_table_description_destroy(
  duckdb_table_description *table_description
);
Parameters
  • table_description: 要销毁的table_description。


duckdb_table_description_error

返回与给定表描述相关的错误信息。 如果表描述没有错误信息，则返回nullptr。 错误信息不应被释放。它将在调用duckdb_table_description_destroy时被释放。

Syntax 
const char *duckdb_table_description_error(
  duckdb_table_description table_description
);
Parameters
  • table_description: 获取错误的表描述。
Return Value

The error message, or nullptr if there is none.


duckdb_column_has_default

检查表格中位于'index'索引处的列是否具有DEFAULT表达式。

Syntax 
duckdb_state duckdb_column_has_default(
  duckdb_table_description table_description,
  idx_t index,
  bool *out
);
Parameters
  • table_description: 要查询的table_description。
  • index: 要查询的列的索引。
  • out: 用于存储结果的输出参数。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_query_arrow

警告 弃用通知。此方法计划在未来的版本中移除。

在连接中执行SQL查询，并将完整（物化）的结果存储在箭头结构中。 如果查询执行失败，将返回DuckDBError，并且可以通过调用 duckdb_query_arrow_error来检索错误消息。

请注意，在运行duckdb_query_arrow之后，即使查询失败，也必须在结果对象上调用duckdb_destroy_arrow，否则结果中存储的错误将无法正确释放。

Syntax 
duckdb_state duckdb_query_arrow(
  duckdb_connection connection,
  const char *query,
  duckdb_arrow *out_result
);
Parameters
  • connection: The connection to perform the query in.
  • query: The SQL query to run.
  • out_result: The query result.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_query_arrow_schema

警告 弃用通知。此方法计划在未来的版本中移除。

从箭头结果中获取内部箭头模式。记得在相应的ArrowSchema对象上调用release。

Syntax 
duckdb_state duckdb_query_arrow_schema(
  duckdb_arrow result,
  duckdb_arrow_schema *out_schema
);
Parameters
  • result: 从中获取模式的结果。
  • out_schema: 输出模式。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_prepared_arrow_schema

警告 弃用通知。此方法计划在未来的版本中移除。

从准备好的语句中获取内部的箭头模式。记得在相应的ArrowSchema对象上调用release。

Syntax 
duckdb_state duckdb_prepared_arrow_schema(
  duckdb_prepared_statement prepared,
  duckdb_arrow_schema *out_schema
);
Parameters
  • prepared: 用于获取模式的预处理语句。
  • out_schema: 输出模式。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_result_arrow_array

警告 弃用通知。此方法计划在未来的版本中移除。

将数据块转换为箭头结构数组。记得在相应的ArrowArray对象上调用release。

Syntax 
void duckdb_result_arrow_array(
  duckdb_result result,
  duckdb_data_chunk chunk,
  duckdb_arrow_array *out_array
);
Parameters
  • result: 数据块已从中获取的结果对象。
  • chunk: 要转换的数据块。
  • out_array: 输出数组。


duckdb_query_arrow_array

警告 弃用通知。此方法计划在未来的版本中移除。

从箭头结果中获取一个内部的箭头结构数组。记得在相应的ArrowArray对象上调用release。

此函数可以多次调用以获取下一个数据块，这将释放之前的out_array。 因此，在再次调用此函数之前，请使用out_array。

Syntax 
duckdb_state duckdb_query_arrow_array(
  duckdb_arrow result,
  duckdb_arrow_array *out_array
);
Parameters
  • result: 从中获取数组的结果。
  • out_array: 输出数组。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_arrow_column_count

警告 弃用通知。此方法计划在未来的版本中移除。

返回箭头结果对象中存在的列数。

Syntax 
idx_t duckdb_arrow_column_count(
  duckdb_arrow result
);
Parameters
  • result: The result object.
Return Value

结果对象中存在的列数。


duckdb_arrow_row_count

警告 弃用通知。此方法计划在未来的版本中移除。

返回箭头结果对象中存在的行数。

Syntax 
idx_t duckdb_arrow_row_count(
  duckdb_arrow result
);
Parameters
  • result: The result object.
Return Value

结果对象中存在的行数。


duckdb_arrow_rows_changed

警告 弃用通知。此方法计划在未来的版本中移除。

返回存储在箭头结果中的查询更改的行数。这仅与INSERT/UPDATE/DELETE查询相关。对于其他查询，rows_changed将为0。

Syntax 
idx_t duckdb_arrow_rows_changed(
  duckdb_arrow result
);
Parameters
  • result: The result object.
Return Value

更改的行数。


duckdb_query_arrow_error

警告 弃用通知。此方法计划在未来的版本中移除。

返回结果中包含的错误信息。只有在duckdb_query_arrow返回DuckDBError时，错误信息才会被设置。

错误信息不应被释放。当调用duckdb_destroy_arrow时，它将被释放。

Syntax 
const char *duckdb_query_arrow_error(
  duckdb_arrow result
);
Parameters
  • result: The result object to fetch the error from.
Return Value

结果的错误。


duckdb_destroy_arrow

警告 弃用通知。此方法计划在未来的版本中移除。

关闭结果并释放为箭头结果分配的所有内存。

Syntax 
void duckdb_destroy_arrow(
  duckdb_arrow *result
);
Parameters
  • result: The result to destroy.


duckdb_destroy_arrow_stream

警告 弃用通知。此方法计划在未来的版本中移除。

释放箭头数组流并释放其内存。

Syntax 
void duckdb_destroy_arrow_stream(
  duckdb_arrow_stream *stream_p
);
Parameters
  • stream_p: 要销毁的箭头数组流。


duckdb_execute_prepared_arrow

警告 弃用通知。此方法计划在未来的版本中移除。

使用给定的绑定参数执行准备好的语句，并返回一个箭头查询结果。 请注意，在运行duckdb_execute_prepared_arrow之后，必须在结果对象上调用duckdb_destroy_arrow。

Syntax 
duckdb_state duckdb_execute_prepared_arrow(
  duckdb_prepared_statement prepared_statement,
  duckdb_arrow *out_result
);
Parameters
  • prepared_statement: The prepared statement to execute.
  • out_result: The query result.
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_arrow_scan

警告 弃用通知。此方法计划在未来的版本中移除。

扫描Arrow流并使用给定的名称创建视图。

Syntax 
duckdb_state duckdb_arrow_scan(
  duckdb_connection connection,
  const char *table_name,
  duckdb_arrow_stream arrow
);
Parameters
  • connection: 执行扫描的连接。
  • table_name: 要创建的临时视图的名称。
  • arrow: Arrow 流包装器。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_arrow_array_scan

警告 弃用通知。此方法计划在未来的版本中移除。

扫描Arrow数组并使用给定的名称创建视图。 请注意，在运行duckdb_arrow_array_scan之后，必须在输出流上调用duckdb_destroy_arrow_stream。

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
);
Parameters
  • connection: 执行扫描的连接。
  • table_name: 要创建的临时视图的名称。
  • arrow_schema: Arrow 模式包装器。
  • arrow_array: Arrow 数组包装器。
  • out_stream: 输出数组流，用于包装传递的模式，完成后释放/删除。
Return Value

DuckDBSuccess on success or DuckDBError on failure.


duckdb_execute_tasks

在此线程上执行DuckDB任务。

将在执行了max_tasks后返回，或者如果没有更多任务存在时返回。

Syntax 
void duckdb_execute_tasks(
  duckdb_database database,
  idx_t max_tasks
);
Parameters
  • database: 用于执行任务的数据库对象
  • max_tasks: 要执行的最大任务数量


duckdb_create_task_state

创建一个任务状态，可以与duckdb_execute_tasks_state一起使用，以执行任务，直到在该状态上调用duckdb_finish_execution。

duckdb_destroy_state 必须在结果上调用。

Syntax 
duckdb_task_state duckdb_create_task_state(
  duckdb_database database
);
Parameters
  • database: 用于创建任务状态的数据库对象
Return Value

可以与duckdb_execute_tasks_state一起使用的任务状态。


duckdb_execute_tasks_state

在此线程上执行DuckDB任务。

线程将持续执行任务，直到在状态上调用duckdb_finish_execution。 多个线程可以共享相同的duckdb_task_state。

Syntax 
void duckdb_execute_tasks_state(
  duckdb_task_state state
);
Parameters
  • state: 执行器的任务状态


duckdb_execute_n_tasks_state

在此线程上执行DuckDB任务。

线程将继续执行任务，直到在状态上调用duckdb_finish_execution，执行了max_tasks个任务或没有更多任务要执行。

多个线程可以共享同一个duckdb_task_state。

Syntax 
idx_t duckdb_execute_n_tasks_state(
  duckdb_task_state state,
  idx_t max_tasks
);
Parameters
  • state: 执行器的任务状态
  • max_tasks: 要执行的最大任务数量
Return Value

实际已执行的任务数量


duckdb_finish_execution

在特定任务上完成执行。

Syntax 
void duckdb_finish_execution(
  duckdb_task_state state
);
Parameters
  • state: 完成任务执行的状态


duckdb_task_state_is_finished

检查提供的duckdb_task_state是否已完成执行

Syntax 
bool duckdb_task_state_is_finished(
  duckdb_task_state state
);
Parameters
  • state: 要检查的任务状态
Return Value

是否已在任务状态上调用了duckdb_finish_execution


duckdb_destroy_task_state

销毁从duckdb_create_task_state返回的任务状态。

请注意，当任务状态上有一个活动的 duckdb_execute_tasks_state 运行时，不应调用此函数。

Syntax 
void duckdb_destroy_task_state(
  duckdb_task_state state
);
Parameters
  • state: 要清理的任务状态


duckdb_execution_is_finished

如果当前查询的执行已完成，则返回 true。

Syntax 
bool duckdb_execution_is_finished(
  duckdb_connection con
);
Parameters
  • con: 检查的连接


duckdb_stream_fetch_chunk

警告 弃用通知。此方法计划在未来的版本中移除。

从（流式）duckdb_result 中获取数据块。此函数应重复调用，直到结果耗尽。

The result must be destroyed with duckdb_destroy_data_chunk.

此函数只能用于使用 'duckdb_pending_prepared_streaming' 创建的 duckdb_results

如果使用此函数，则不能使用其他结果函数，反之亦然（即，此函数不能与旧版结果函数或物化结果函数混合使用）。

事先不知道这个结果会返回多少个块。

Syntax 
duckdb_data_chunk duckdb_stream_fetch_chunk(
  duckdb_result result
);
Parameters
  • result: The result object to fetch the data chunk from.
Return Value

生成的数据块。如果结果有错误，则返回 NULL。


duckdb_fetch_chunk

从duckdb_result中获取一个数据块。此函数应重复调用，直到结果耗尽。

The result must be destroyed with duckdb_destroy_data_chunk.

事先不知道这个结果会返回多少个块。

Syntax 
duckdb_data_chunk duckdb_fetch_chunk(
  duckdb_result result
);
Parameters
  • result: The result object to fetch the data chunk from.
Return Value

生成的数据块。如果结果有错误，则返回NULL。


duckdb_create_cast_function

创建一个新的类型转换函数对象。

Return Value

转换函数对象。

Syntax 
duckdb_cast_function duckdb_create_cast_function(
  
);


duckdb_cast_function_set_source_type

设置转换函数的源类型。

Syntax 
void duckdb_cast_function_set_source_type(
  duckdb_cast_function cast_function,
  duckdb_logical_type source_type
);
Parameters
  • cast_function: 转换函数对象。
  • source_type: 要设置的源类型。


duckdb_cast_function_set_target_type

设置转换函数的目标类型。

Syntax 
void duckdb_cast_function_set_target_type(
  duckdb_cast_function cast_function,
  duckdb_logical_type target_type
);
Parameters
  • cast_function: 转换函数对象。
  • target_type: 要设置的目标类型。


duckdb_cast_function_set_implicit_cast_cost

设置使用此函数将源类型隐式转换为目标类型的“成本”。

Syntax 
void duckdb_cast_function_set_implicit_cast_cost(
  duckdb_cast_function cast_function,
  int64_t cost
);
Parameters
  • cast_function: 转换函数对象。
  • cost: 要设置的成本。


duckdb_cast_function_set_function

设置要使用的实际转换函数。

Syntax 
void duckdb_cast_function_set_function(
  duckdb_cast_function cast_function,
  duckdb_cast_function_t function
);
Parameters
  • cast_function: 转换函数对象。
  • function: 要设置的函数。


duckdb_cast_function_set_extra_info

为可以在执行期间获取的cast函数分配额外信息，等等。

Syntax 
void duckdb_cast_function_set_extra_info(
  duckdb_cast_function cast_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);
Parameters
  • extra_info: The extra information
  • destroy: 将调用的回调函数，用于销毁额外信息（如果有的话）


duckdb_cast_function_get_extra_info

检索在duckdb_cast_function_set_extra_info中设置的函数的额外信息。

Syntax 
void *duckdb_cast_function_get_extra_info(
  duckdb_function_info info
);
Parameters
  • info: The info object.
Return Value

额外信息。


duckdb_cast_function_get_cast_mode

从给定的函数信息中获取强制转换执行模式。

Syntax 
duckdb_cast_mode duckdb_cast_function_get_cast_mode(
  duckdb_function_info info
);
Parameters
  • info: The info object.
Return Value

转换模式。


duckdb_cast_function_set_error

报告在执行cast函数时发生了错误。

Syntax 
void duckdb_cast_function_set_error(
  duckdb_function_info info,
  const char *error
);
Parameters
  • info: The info object.
  • error: 错误信息。


duckdb_cast_function_set_row_error

报告在执行cast函数时发生错误，将相应的输出行设置为NULL。

Syntax 
void duckdb_cast_function_set_row_error(
  duckdb_function_info info,
  const char *error,
  idx_t row,
  duckdb_vector output
);
Parameters
  • info: The info object.
  • error: 错误信息。
  • row: 输出向量中要设置为NULL的行的索引。
  • output: 输出向量。


duckdb_register_cast_function

在给定的连接中注册一个转换函数。

Syntax 
duckdb_state duckdb_register_cast_function(
  duckdb_connection con,
  duckdb_cast_function cast_function
);
Parameters
  • con: 使用的连接。
  • cast_function: 要注册的转换函数。
Return Value

注册是否成功。


duckdb_destroy_cast_function

销毁转换函数对象。

Syntax 
void duckdb_destroy_cast_function(
  duckdb_cast_function *cast_function
);
Parameters
  • cast_function: The cast function object.


关于此页面