完整的 API – DuckDB 数据库

搜索快捷键 cmd + k | ctrl + k

文档 / 客户端API / C

完整 API

本页包含 DuckDB C API 的参考。

API参考概览

打开连接

duckdb_instance_cache duckdb_create_instance_cache();
duckdb_state duckdb_get_or_create_from_cache(duckdb_instance_cache instance_cache, const char *path, duckdb_database *out_database, duckdb_config config, char **out_error);
void duckdb_destroy_instance_cache(duckdb_instance_cache *instance_cache);
duckdb_state duckdb_open(const char *path, duckdb_database *out_database);
duckdb_state duckdb_open_ext(const char *path, duckdb_database *out_database, duckdb_config config, char **out_error);
void duckdb_close(duckdb_database *database);
duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);
void duckdb_interrupt(duckdb_connection connection);
duckdb_query_progress_type duckdb_query_progress(duckdb_connection connection);
void duckdb_disconnect(duckdb_connection *connection);
void duckdb_connection_get_client_context(duckdb_connection connection, duckdb_client_context *out_context);
idx_t duckdb_client_context_get_connection_id(duckdb_client_context context);
void duckdb_destroy_client_context(duckdb_client_context *context);
const char *duckdb_library_version();
duckdb_value duckdb_get_table_names(duckdb_connection connection, const char *query, bool qualified);

配置

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

查询执行

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

助手

void *duckdb_malloc(size_t size);
void duckdb_free(void *ptr);
idx_t duckdb_vector_size();
bool duckdb_string_is_inlined(duckdb_string_t string);
uint32_t duckdb_string_t_length(duckdb_string_t string);
const char *duckdb_string_t_data(duckdb_string_t *string);

日期时间时间戳助手

duckdb_date_struct duckdb_from_date(duckdb_date date);
duckdb_date duckdb_to_date(duckdb_date_struct date);
bool duckdb_is_finite_date(duckdb_date date);
duckdb_time_struct duckdb_from_time(duckdb_time time);
duckdb_time_tz duckdb_create_time_tz(int64_t micros, int32_t offset);
duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz micros);
duckdb_time duckdb_to_time(duckdb_time_struct time);
duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts);
duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts);
bool duckdb_is_finite_timestamp(duckdb_timestamp ts);
bool duckdb_is_finite_timestamp_s(duckdb_timestamp_s ts);
bool duckdb_is_finite_timestamp_ms(duckdb_timestamp_ms ts);
bool duckdb_is_finite_timestamp_ns(duckdb_timestamp_ns ts);

Hugeint 助手

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

无符号 Hugeint 助手

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

十进制助手

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

预处理语句

duckdb_state duckdb_prepare(duckdb_connection connection, const char *query, duckdb_prepared_statement *out_prepared_statement);
void duckdb_destroy_prepare(duckdb_prepared_statement *prepared_statement);
const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement);
idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement);
const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index);
duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx);
duckdb_logical_type duckdb_param_logical_type(duckdb_prepared_statement prepared_statement, idx_t param_idx);
duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement);
duckdb_statement_type duckdb_prepared_statement_type(duckdb_prepared_statement statement);

将值绑定到预处理语句

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

提取语句

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

值接口

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_varint(duckdb_varint input);
duckdb_value duckdb_create_decimal(duckdb_decimal input);
duckdb_value duckdb_create_float(float input);
duckdb_value duckdb_create_double(double input);
duckdb_value duckdb_create_date(duckdb_date input);
duckdb_value duckdb_create_time(duckdb_time input);
duckdb_value duckdb_create_time_tz_value(duckdb_time_tz value);
duckdb_value duckdb_create_timestamp(duckdb_timestamp input);
duckdb_value duckdb_create_timestamp_tz(duckdb_timestamp input);
duckdb_value duckdb_create_timestamp_s(duckdb_timestamp_s input);
duckdb_value duckdb_create_timestamp_ms(duckdb_timestamp_ms input);
duckdb_value duckdb_create_timestamp_ns(duckdb_timestamp_ns input);
duckdb_value duckdb_create_interval(duckdb_interval input);
duckdb_value duckdb_create_blob(const uint8_t *data, idx_t length);
duckdb_value duckdb_create_bit(duckdb_bit input);
duckdb_value duckdb_create_uuid(duckdb_uhugeint input);
bool duckdb_get_bool(duckdb_value val);
int8_t duckdb_get_int8(duckdb_value val);
uint8_t duckdb_get_uint8(duckdb_value val);
int16_t duckdb_get_int16(duckdb_value val);
uint16_t duckdb_get_uint16(duckdb_value val);
int32_t duckdb_get_int32(duckdb_value val);
uint32_t duckdb_get_uint32(duckdb_value val);
int64_t duckdb_get_int64(duckdb_value val);
uint64_t duckdb_get_uint64(duckdb_value val);
duckdb_hugeint duckdb_get_hugeint(duckdb_value val);
duckdb_uhugeint duckdb_get_uhugeint(duckdb_value val);
duckdb_varint duckdb_get_varint(duckdb_value val);
duckdb_decimal duckdb_get_decimal(duckdb_value val);
float duckdb_get_float(duckdb_value val);
double duckdb_get_double(duckdb_value val);
duckdb_date duckdb_get_date(duckdb_value val);
duckdb_time duckdb_get_time(duckdb_value val);
duckdb_time_tz duckdb_get_time_tz(duckdb_value val);
duckdb_timestamp duckdb_get_timestamp(duckdb_value val);
duckdb_timestamp duckdb_get_timestamp_tz(duckdb_value val);
duckdb_timestamp_s duckdb_get_timestamp_s(duckdb_value val);
duckdb_timestamp_ms duckdb_get_timestamp_ms(duckdb_value val);
duckdb_timestamp_ns duckdb_get_timestamp_ns(duckdb_value val);
duckdb_interval duckdb_get_interval(duckdb_value val);
duckdb_logical_type duckdb_get_value_type(duckdb_value val);
duckdb_blob duckdb_get_blob(duckdb_value val);
duckdb_bit duckdb_get_bit(duckdb_value val);
duckdb_uhugeint duckdb_get_uuid(duckdb_value val);
char *duckdb_get_varchar(duckdb_value value);
duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value *values);
duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
duckdb_value duckdb_create_map_value(duckdb_logical_type map_type, duckdb_value *keys, duckdb_value *values, idx_t entry_count);
duckdb_value duckdb_create_union_value(duckdb_logical_type union_type, idx_t tag_index, duckdb_value value);
idx_t duckdb_get_map_size(duckdb_value value);
duckdb_value duckdb_get_map_key(duckdb_value value, idx_t index);
duckdb_value duckdb_get_map_value(duckdb_value value, idx_t index);
bool duckdb_is_null_value(duckdb_value value);
duckdb_value duckdb_create_null_value();
idx_t duckdb_get_list_size(duckdb_value value);
duckdb_value duckdb_get_list_child(duckdb_value value, idx_t index);
duckdb_value duckdb_create_enum_value(duckdb_logical_type type, uint64_t value);
uint64_t duckdb_get_enum_value(duckdb_value value);
duckdb_value duckdb_get_struct_child(duckdb_value value, idx_t index);
char *duckdb_value_to_string(duckdb_value value);

逻辑类型接口

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_vector duckdb_create_vector(duckdb_logical_type type, idx_t capacity);
void duckdb_destroy_vector(duckdb_vector *vector);
duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector);
void *duckdb_vector_get_data(duckdb_vector vector);
uint64_t *duckdb_vector_get_validity(duckdb_vector vector);
void duckdb_vector_ensure_validity_writable(duckdb_vector vector);
void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str);
void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index, const char *str, idx_t str_len);
duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector);
idx_t duckdb_list_vector_get_size(duckdb_vector vector);
duckdb_state duckdb_list_vector_set_size(duckdb_vector vector, idx_t size);
duckdb_state duckdb_list_vector_reserve(duckdb_vector vector, idx_t required_capacity);
duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index);
duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector);
void duckdb_slice_vector(duckdb_vector vector, duckdb_selection_vector selection, idx_t len);
void duckdb_vector_reference_value(duckdb_vector vector, duckdb_value value);
void duckdb_vector_reference_vector(duckdb_vector to_vector, duckdb_vector from_vector);

有效性掩码函数

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

标量函数

duckdb_scalar_function duckdb_create_scalar_function();
void duckdb_destroy_scalar_function(duckdb_scalar_function *scalar_function);
void duckdb_scalar_function_set_name(duckdb_scalar_function scalar_function, const char *name);
void duckdb_scalar_function_set_varargs(duckdb_scalar_function scalar_function, duckdb_logical_type type);
void duckdb_scalar_function_set_special_handling(duckdb_scalar_function scalar_function);
void duckdb_scalar_function_set_volatile(duckdb_scalar_function scalar_function);
void duckdb_scalar_function_add_parameter(duckdb_scalar_function scalar_function, duckdb_logical_type type);
void duckdb_scalar_function_set_return_type(duckdb_scalar_function scalar_function, duckdb_logical_type type);
void duckdb_scalar_function_set_extra_info(duckdb_scalar_function scalar_function, void *extra_info, duckdb_delete_callback_t destroy);
void duckdb_scalar_function_set_bind(duckdb_scalar_function scalar_function, duckdb_scalar_function_bind_t bind);
void duckdb_scalar_function_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
void duckdb_scalar_function_bind_set_error(duckdb_bind_info info, const char *error);
void duckdb_scalar_function_set_function(duckdb_scalar_function scalar_function, duckdb_scalar_function_t function);
duckdb_state duckdb_register_scalar_function(duckdb_connection con, duckdb_scalar_function scalar_function);
void *duckdb_scalar_function_get_extra_info(duckdb_function_info info);
void *duckdb_scalar_function_get_bind_data(duckdb_function_info info);
void duckdb_scalar_function_get_client_context(duckdb_bind_info info, duckdb_client_context *out_context);
void duckdb_scalar_function_set_error(duckdb_function_info info, const char *error);
duckdb_scalar_function_set duckdb_create_scalar_function_set(const char *name);
void duckdb_destroy_scalar_function_set(duckdb_scalar_function_set *scalar_function_set);
duckdb_state duckdb_add_scalar_function_to_set(duckdb_scalar_function_set set, duckdb_scalar_function function);
duckdb_state duckdb_register_scalar_function_set(duckdb_connection con, duckdb_scalar_function_set set);

选择向量接口

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

聚合函数

duckdb_aggregate_function duckdb_create_aggregate_function();
void duckdb_destroy_aggregate_function(duckdb_aggregate_function *aggregate_function);
void duckdb_aggregate_function_set_name(duckdb_aggregate_function aggregate_function, const char *name);
void duckdb_aggregate_function_add_parameter(duckdb_aggregate_function aggregate_function, duckdb_logical_type type);
void duckdb_aggregate_function_set_return_type(duckdb_aggregate_function aggregate_function, duckdb_logical_type type);
void duckdb_aggregate_function_set_functions(duckdb_aggregate_function aggregate_function, duckdb_aggregate_state_size state_size, duckdb_aggregate_init_t state_init, duckdb_aggregate_update_t update, duckdb_aggregate_combine_t combine, duckdb_aggregate_finalize_t finalize);
void duckdb_aggregate_function_set_destructor(duckdb_aggregate_function aggregate_function, duckdb_aggregate_destroy_t destroy);
duckdb_state duckdb_register_aggregate_function(duckdb_connection con, duckdb_aggregate_function aggregate_function);
void duckdb_aggregate_function_set_special_handling(duckdb_aggregate_function aggregate_function);
void duckdb_aggregate_function_set_extra_info(duckdb_aggregate_function aggregate_function, void *extra_info, duckdb_delete_callback_t destroy);
void *duckdb_aggregate_function_get_extra_info(duckdb_function_info info);
void duckdb_aggregate_function_set_error(duckdb_function_info info, const char *error);
duckdb_aggregate_function_set duckdb_create_aggregate_function_set(const char *name);
void duckdb_destroy_aggregate_function_set(duckdb_aggregate_function_set *aggregate_function_set);
duckdb_state duckdb_add_aggregate_function_to_set(duckdb_aggregate_function_set set, duckdb_aggregate_function function);
duckdb_state duckdb_register_aggregate_function_set(duckdb_connection con, duckdb_aggregate_function_set set);

表函数

duckdb_table_function duckdb_create_table_function();
void duckdb_destroy_table_function(duckdb_table_function *table_function);
void duckdb_table_function_set_name(duckdb_table_function table_function, const char *name);
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);

表函数

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);
duckdb_state duckdb_appender_create_ext(duckdb_connection connection, const char *catalog, const char *schema, const char *table, duckdb_appender *out_appender);
idx_t duckdb_appender_column_count(duckdb_appender appender);
duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t col_idx);
const char *duckdb_appender_error(duckdb_appender appender);
duckdb_state duckdb_appender_flush(duckdb_appender appender);
duckdb_state duckdb_appender_close(duckdb_appender appender);
duckdb_state duckdb_appender_destroy(duckdb_appender *appender);
duckdb_state duckdb_appender_add_column(duckdb_appender appender, const char *name);
duckdb_state duckdb_appender_clear_columns(duckdb_appender appender);
duckdb_state duckdb_appender_begin_row(duckdb_appender appender);
duckdb_state duckdb_appender_end_row(duckdb_appender appender);
duckdb_state duckdb_append_default(duckdb_appender appender);
duckdb_state duckdb_append_default_to_chunk(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col, idx_t row);
duckdb_state duckdb_append_bool(duckdb_appender appender, bool value);
duckdb_state duckdb_append_int8(duckdb_appender appender, int8_t value);
duckdb_state duckdb_append_int16(duckdb_appender appender, int16_t value);
duckdb_state duckdb_append_int32(duckdb_appender appender, int32_t value);
duckdb_state duckdb_append_int64(duckdb_appender appender, int64_t value);
duckdb_state duckdb_append_hugeint(duckdb_appender appender, duckdb_hugeint value);
duckdb_state duckdb_append_uint8(duckdb_appender appender, uint8_t value);
duckdb_state duckdb_append_uint16(duckdb_appender appender, uint16_t value);
duckdb_state duckdb_append_uint32(duckdb_appender appender, uint32_t value);
duckdb_state duckdb_append_uint64(duckdb_appender appender, uint64_t value);
duckdb_state duckdb_append_uhugeint(duckdb_appender appender, duckdb_uhugeint value);
duckdb_state duckdb_append_float(duckdb_appender appender, float value);
duckdb_state duckdb_append_double(duckdb_appender appender, double value);
duckdb_state duckdb_append_date(duckdb_appender appender, duckdb_date value);
duckdb_state duckdb_append_time(duckdb_appender appender, duckdb_time value);
duckdb_state duckdb_append_timestamp(duckdb_appender appender, duckdb_timestamp value);
duckdb_state duckdb_append_interval(duckdb_appender appender, duckdb_interval value);
duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val);
duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *val, idx_t length);
duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length);
duckdb_state duckdb_append_null(duckdb_appender appender);
duckdb_state duckdb_append_value(duckdb_appender appender, duckdb_value value);
duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk);

表描述

duckdb_state duckdb_table_description_create(duckdb_connection connection, const char *schema, const char *table, duckdb_table_description *out);
duckdb_state duckdb_table_description_create_ext(duckdb_connection connection, const char *catalog, const char *schema, const char *table, duckdb_table_description *out);
void duckdb_table_description_destroy(duckdb_table_description *table_description);
const char *duckdb_table_description_error(duckdb_table_description table_description);
duckdb_state duckdb_column_has_default(duckdb_table_description table_description, idx_t index, bool *out);
char *duckdb_table_description_get_column_name(duckdb_table_description table_description, idx_t index);

Arrow 接口

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_create_instance_cache`

创建一个新的数据库实例缓存。如果客户端/程序在同一进程中（重新）打开多个到同一文件的数据库，则实例缓存是必需的。必须使用“duckdb_destroy_instance_cache”销毁。

语法

duckdb_instance_cache duckdb_create_instance_cache(
  
);

`duckdb_get_or_create_from_cache`

在实例缓存中创建一个新的数据库实例，或检索现有数据库实例。必须使用“duckdb_close”关闭。

语法

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

参数

instance_cache：在其中创建数据库或从中获取数据库的实例缓存。
path：磁盘上数据库文件的路径。 nullptr 和 :memory: 都打开或检索内存数据库。
out_database：生成的缓存数据库。
config：（可选）用于创建数据库的配置。
out_error：如果设置且函数返回 DuckDBError，则此字段包含错误消息。请注意，错误消息必须使用 duckdb_free 释放。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_destroy_instance_cache`

销毁现有的数据库实例缓存并释放其内存。

语法

void duckdb_destroy_instance_cache(
  duckdb_instance_cache *instance_cache
);

`duckdb_open`

创建一个新数据库或打开存储在给定路径中的现有数据库文件。如果未给出路径，则会创建一个新的内存数据库。数据库必须使用“duckdb_close”关闭。

语法

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

参数

path：磁盘上数据库文件的路径。 nullptr 和 :memory: 都打开内存数据库。
out_database：结果数据库对象。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_open_ext`

duckdb_open 的扩展版本。创建一个新数据库或打开存储在给定路径中的现有数据库文件。数据库必须使用“duckdb_close”关闭。

语法

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

参数

path：磁盘上数据库文件的路径。 nullptr 和 :memory: 都打开内存数据库。
out_database：结果数据库对象。
config：（可选）用于启动数据库的配置。
out_error：如果设置且函数返回 DuckDBError，则此字段包含错误消息。请注意，错误消息必须使用 duckdb_free 释放。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_connect`

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

语法

duckdb_state duckdb_connect(
  duckdb_database database,
  duckdb_connection *out_connection
);

参数

database：要连接到的数据库文件。
out_connection：结果连接对象。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_connection_get_client_context`

检索连接的客户端上下文。

语法

void duckdb_connection_get_client_context(
  duckdb_connection connection,
  duckdb_client_context *out_context
);

参数

connection：连接。
out_context：连接的客户端上下文。必须使用 duckdb_destroy_client_context 销毁。

`duckdb_client_context_get_connection_id`

返回客户端上下文的连接 ID。

语法

idx_t duckdb_client_context_get_connection_id(
  duckdb_client_context context
);

`duckdb_destroy_client_context`

销毁客户端上下文并释放其内存。

语法

void duckdb_destroy_client_context(
  duckdb_client_context *context
);

`duckdb_library_version`

返回链接的 DuckDB 的版本，以及开发版本的版本后缀

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

语法

const char *duckdb_library_version(
  
);

`duckdb_get_table_names`

获取查询的（完全限定的）表名称列表。

语法

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

参数

connection：从中获取表名称的连接。
query：从中获取表名称的查询。
qualified：如果设置为 true，则返回完全限定的表名称 (catalog.schema.table)，否则仅返回（未转义的）表名称。

返回值

一个类型为 VARCHAR[] 的 duckdb_value，其中包含查询的（完全限定的）表名称。必须使用 duckdb_destroy_value 销毁。

`duckdb_create_config`

初始化一个空配置对象，该对象可用于通过 duckdb_open_ext 为 DuckDB 实例提供启动选项。 duckdb_config 必须使用“duckdb_destroy_config”销毁

除非发生 malloc 失败，否则这始终会成功。

请注意，即使函数返回 DuckDBError，也应始终对生成配置调用 duckdb_destroy_config。

语法

duckdb_state duckdb_create_config(
  duckdb_config *out_config
);

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_config_count`

这返回可用于 duckdb_get_config_flag 的配置选项总数。

不应在循环中调用此函数，因为它在内部循环所有选项。

语法

size_t duckdb_config_count(
  
);

`duckdb_get_config_flag`

获取特定配置选项的可读名称和描述。这可用于例如显示配置选项。除非 index 超出范围（即，>= duckdb_config_count），否则这将会成功。

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

语法

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

参数

index：配置选项的索引（介于 0 和 duckdb_config_count 之间）
out_name：配置标志的名称。
out_description：配置标志的描述。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_set_config`

为指定的配置设置指定的选项。配置选项由名称指示。要获取配置选项列表，请参阅 duckdb_get_config_flag。

在源代码中，配置选项在 config.cpp 中定义。

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

语法

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

参数

config：要在其上设置选项的配置对象。
name：要设置的配置标志的名称。
option：要将配置标志设置为的值。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_query`

在连接中执行 SQL 查询并将完整（物化）结果存储在 out_result 指针中。如果查询执行失败，则返回 DuckDBError，并且可以通过调用 duckdb_result_error 检索错误消息。

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

语法

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

参数

connection：要在其中执行查询的连接。
query：要运行的 SQL 查询。
out_result：查询结果。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_result_statement_type`

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

语法

duckdb_statement_type duckdb_result_statement_type(
  duckdb_result result
);

返回值

duckdb_statement_type 值或 DUCKDB_STATEMENT_TYPE_INVALID

`duckdb_column_logical_type`

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

此调用的返回类型应使用 duckdb_destroy_logical_type 销毁。

如果列超出范围，则返回 NULL。

语法

duckdb_logical_type duckdb_column_logical_type(
  duckdb_result *result,
  idx_t col
);

`duckdb_nullmask_data`

以列格式返回结果特定列的 nullmask。 nullmask 指示对于每一行，相应的行是否为 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]);
}

语法

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

`duckdb_result_get_chunk`

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

结果必须使用 duckdb_destroy_data_chunk 销毁。

此函数取代所有 duckdb_value 函数，以及 duckdb_column_data 和 duckdb_nullmask_data 函数。它会带来显著更好的性能，应在新代码库中优先使用。

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

使用 duckdb_result_chunk_count 来确定结果中有多少块。

语法

duckdb_data_chunk duckdb_result_get_chunk(
  duckdb_result result,
  idx_t chunk_index
);

参数

result：从中获取数据块的结果对象。
chunk_index：从中获取的块索引。

`duckdb_result_is_streaming`

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

语法

bool duckdb_result_is_streaming(
  duckdb_result result
);

`duckdb_value_boolean`

语法

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

`duckdb_value_int8`

语法

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

`duckdb_value_int16`

语法

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

`duckdb_value_int32`

语法

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

`duckdb_value_int64`

语法

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

`duckdb_value_hugeint`

语法

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

`duckdb_value_uhugeint`

语法

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

`duckdb_value_decimal`

语法

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

`duckdb_value_uint8`

语法

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

`duckdb_value_uint16`

语法

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

`duckdb_value_uint32`

语法

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

`duckdb_value_uint64`

语法

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

`duckdb_value_float`

语法

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

`duckdb_value_double`

语法

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

`duckdb_value_date`

语法

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

`duckdb_value_time`

语法

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

`duckdb_value_timestamp`

语法

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

`duckdb_value_interval`

语法

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

`duckdb_value_varchar`

返回值

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

语法

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

`duckdb_value_string`

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

语法

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

`duckdb_value_varchar_internal`

返回值

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

结果不得释放。

语法

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

`duckdb_value_string_internal`

返回值

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

结果不得释放。

语法

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

`duckdb_value_blob`

返回值

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

语法

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

`duckdb_value_is_null`

语法

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

`duckdb_vector_size`

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

语法

idx_t duckdb_vector_size(
  
);

`duckdb_string_is_inlined`

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

语法

bool duckdb_string_is_inlined(
  duckdb_string_t string
);

`duckdb_from_date`

将 duckdb_date 对象分解为年、月和日（存储为 duckdb_date_struct）。

语法

duckdb_date_struct duckdb_from_date(
  duckdb_date date
);

`duckdb_to_date`

从年、月和日 (duckdb_date_struct) 重新组合 duckdb_date。

语法

duckdb_date duckdb_to_date(
  duckdb_date_struct date
);

`duckdb_is_finite_date`

测试 duckdb_date 以查看它是否为有限值。

语法

bool duckdb_is_finite_date(
  duckdb_date date
);

返回值

如果日期是有限的，则为 True；如果它是 ±infinity，则为 false。

`duckdb_from_time`

将 duckdb_time 对象分解为小时、分钟、秒和微秒（存储为 duckdb_time_struct）。

语法

duckdb_time_struct duckdb_from_time(
  duckdb_time time
);

`duckdb_create_time_tz`

从微秒和时区偏移量创建 duckdb_time_tz 对象。

语法

duckdb_time_tz duckdb_create_time_tz(
  int64_t micros,
  int32_t offset
);

`duckdb_from_time_tz`

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

使用 duckdb_from_time 将微秒进一步分解为小时、分钟、秒和微秒。

语法

duckdb_time_tz_struct duckdb_from_time_tz(
  duckdb_time_tz micros
);

参数

micros：时间对象，从 DUCKDB_TYPE_TIME_TZ 列中获得。

`duckdb_to_time`

从小时、分钟、秒和微秒 (duckdb_time_struct) 重新组合 duckdb_time。

语法

duckdb_time duckdb_to_time(
  duckdb_time_struct time
);

参数

time：duckdb_time_struct 中的小时、分钟、秒和微秒。

`duckdb_from_timestamp`

将 duckdb_timestamp 对象分解为 duckdb_timestamp_struct。

语法

duckdb_timestamp_struct duckdb_from_timestamp(
  duckdb_timestamp ts
);

参数

ts：ts 对象，从 DUCKDB_TYPE_TIMESTAMP 列中获得。

`duckdb_to_timestamp`

从 duckdb_timestamp_struct 重新组合 duckdb_timestamp。

语法

duckdb_timestamp duckdb_to_timestamp(
  duckdb_timestamp_struct ts
);

`duckdb_is_finite_timestamp`

测试 duckdb_timestamp 以查看它是否为有限值。

语法

bool duckdb_is_finite_timestamp(
  duckdb_timestamp ts
);

参数

ts：duckdb_timestamp 对象，从 DUCKDB_TYPE_TIMESTAMP 列中获得。

返回值

如果时间戳是有限的，则为 True；如果它是 ±infinity，则为 false。

`duckdb_is_finite_timestamp_s`

测试 duckdb_timestamp_s 以查看它是否为有限值。

语法

bool duckdb_is_finite_timestamp_s(
  duckdb_timestamp_s ts
);

参数

ts：duckdb_timestamp_s 对象，从 DUCKDB_TYPE_TIMESTAMP_S 列中获得。

返回值

如果时间戳是有限的，则为 True；如果它是 ±infinity，则为 false。

`duckdb_is_finite_timestamp_ms`

测试 duckdb_timestamp_ms 以查看它是否为有限值。

语法

bool duckdb_is_finite_timestamp_ms(
  duckdb_timestamp_ms ts
);

参数

ts：duckdb_timestamp_ms 对象，从 DUCKDB_TYPE_TIMESTAMP_MS 列中获得。

返回值

如果时间戳是有限的，则为 True；如果它是 ±infinity，则为 false。

`duckdb_is_finite_timestamp_ns`

测试 duckdb_timestamp_ns 以查看它是否为有限值。

语法

bool duckdb_is_finite_timestamp_ns(
  duckdb_timestamp_ns ts
);

参数

ts：duckdb_timestamp_ns 对象，从 DUCKDB_TYPE_TIMESTAMP_NS 列中获得。

返回值

如果时间戳是有限的，则为 True；如果它是 ±infinity，则为 false。

`duckdb_double_to_uhugeint`

将 double 值转换为 duckdb_uhugeint 对象。

如果转换失败，因为 double 值太大，则结果将为 0。

语法

duckdb_uhugeint duckdb_double_to_uhugeint(
  double val
);

`duckdb_prepare`

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

请注意，在调用 duckdb_prepare 之后，即使准备失败，也应始终使用 duckdb_destroy_prepare 销毁预处理语句。

如果准备失败，可以调用 duckdb_prepare_error 来获取准备失败的原因。

语法

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

参数

connection: 连接对象
query: 要准备的 SQL 查询
out_prepared_statement: 生成的预处理语句对象

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_prepare_error`

返回与给定预处理语句关联的错误消息。如果预处理语句没有错误消息，则返回 nullptr。

错误消息不应被释放。它将在调用 duckdb_destroy_prepare 时被释放。

语法

const char *duckdb_prepare_error(
  duckdb_prepared_statement prepared_statement
);

`duckdb_param_type`

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

如果参数索引超出范围或语句未成功准备，则返回 DUCKDB_TYPE_INVALID。

语法

duckdb_type duckdb_param_type(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx
);

参数

prepared_statement: 预处理语句。
param_idx: 参数索引。

`duckdb_param_logical_type`

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

如果参数索引超出范围或语句未成功准备，则返回 nullptr。

此调用的返回类型应使用 duckdb_destroy_logical_type 销毁。

语法

duckdb_logical_type duckdb_param_logical_type(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx
);

参数

prepared_statement: 预处理语句。
param_idx: 参数索引。

`duckdb_clear_bindings`

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

语法

duckdb_state duckdb_clear_bindings(
  duckdb_prepared_statement prepared_statement
);

`duckdb_prepared_statement_type`

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

语法

duckdb_statement_type duckdb_prepared_statement_type(
  duckdb_prepared_statement statement
);

返回值

duckdb_statement_type 值或 DUCKDB_STATEMENT_TYPE_INVALID

`duckdb_bind_value`

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

语法

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

`duckdb_bind_parameter_index`

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

语法

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

`duckdb_bind_boolean`

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

语法

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

`duckdb_bind_int8`

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

语法

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

`duckdb_bind_int16`

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

语法

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

`duckdb_bind_int32`

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

语法

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

`duckdb_bind_int64`

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

语法

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

`duckdb_bind_hugeint`

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

语法

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

`duckdb_bind_uhugeint`

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

语法

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

`duckdb_bind_decimal`

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

语法

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

`duckdb_bind_uint8`

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

语法

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

`duckdb_bind_uint16`

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

语法

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

`duckdb_bind_uint32`

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

语法

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

`duckdb_bind_uint64`

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

语法

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

`duckdb_bind_float`

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

语法

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

`duckdb_bind_double`

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

语法

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

`duckdb_bind_date`

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

语法

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

`duckdb_bind_time`

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

语法

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

`duckdb_bind_timestamp`

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

语法

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

`duckdb_bind_timestamp_tz`

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

语法

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

`duckdb_bind_interval`

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

语法

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

`duckdb_bind_varchar`

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

语法

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

`duckdb_bind_varchar_length`

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

语法

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 值绑定到预处理语句。

语法

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

`duckdb_bind_null`

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

语法

duckdb_state duckdb_bind_null(
  duckdb_prepared_statement prepared_statement,
  idx_t param_idx
);

`duckdb_execute_prepared`

使用给定的绑定参数执行预处理语句，并返回具体化的查询结果。

对于每个预处理语句，可以多次调用此方法，并且可以在对此函数的调用之间修改参数。

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

语法

duckdb_state duckdb_execute_prepared(
  duckdb_prepared_statement prepared_statement,
  duckdb_result *out_result
);

参数

prepared_statement: 要执行的预处理语句。
out_result：查询结果。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_execute_prepared_streaming`

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

对于每个预处理语句，可以多次调用此方法，并且可以在对此函数的调用之间修改参数。

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

语法

duckdb_state duckdb_execute_prepared_streaming(
  duckdb_prepared_statement prepared_statement,
  duckdb_result *out_result
);

参数

prepared_statement: 要执行的预处理语句。
out_result：查询结果。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_extract_statements`

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

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

语法

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

参数

connection: 连接对象
query: 要提取的 SQL 查询
out_extracted_statements: 生成的提取语句对象

`duckdb_prepare_extracted_statement`

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

如果准备失败，可以调用 duckdb_prepare_error 来获取准备失败的原因。

语法

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

参数

connection: 连接对象
extracted_statements: 提取的语句对象
index: 要准备的提取语句的索引
out_prepared_statement: 生成的预处理语句对象

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_extract_statements_error`

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

语法

const char *duckdb_extract_statements_error(
  duckdb_extracted_statements extracted_statements
);

`duckdb_pending_prepared`

使用给定的绑定参数执行预处理语句，并返回挂起的结果。挂起的结果表示尚未完全执行的查询的中间结构。挂起的结果可用于增量执行查询，并在任务之间将控制权返回给客户端。

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

语法

duckdb_state duckdb_pending_prepared(
  duckdb_prepared_statement prepared_statement,
  duckdb_pending_result *out_result
);

参数

prepared_statement: 要执行的预处理语句。
out_result: 挂起的查询结果。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_pending_prepared_streaming`

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

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

语法

duckdb_state duckdb_pending_prepared_streaming(
  duckdb_prepared_statement prepared_statement,
  duckdb_pending_result *out_result
);

参数

prepared_statement: 要执行的预处理语句。
out_result: 挂起的查询结果。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`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 获得。

语法

duckdb_pending_state duckdb_pending_execute_task(
  duckdb_pending_result pending_result
);

`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 获得。

语法

duckdb_pending_state duckdb_pending_execute_check_state(
  duckdb_pending_result pending_result
);

`duckdb_execute_pending`

完全执行挂起的查询结果，返回最终查询结果。

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

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

语法

duckdb_state duckdb_execute_pending(
  duckdb_pending_result pending_result,
  duckdb_result *out_result
);

参数

pending_result: 要执行的挂起结果。
out_result: 结果对象。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_pending_execution_is_finished`

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

语法

bool duckdb_pending_execution_is_finished(
  duckdb_pending_state pending_state
);

`duckdb_create_varchar`

从空终止字符串创建一个值

语法

duckdb_value duckdb_create_varchar(
  const char *text
);

`duckdb_create_varchar_length`

从字符串创建一个值

语法

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

`duckdb_create_bool`

从布尔值创建一个值

语法

duckdb_value duckdb_create_bool(
  bool input
);

`duckdb_create_int8`

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

语法

duckdb_value duckdb_create_int8(
  int8_t input
);

`duckdb_create_uint8`

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

语法

duckdb_value duckdb_create_uint8(
  uint8_t input
);

`duckdb_create_int16`

从 int16_t（一个 smallint）创建一个值

语法

duckdb_value duckdb_create_int16(
  int16_t input
);

`duckdb_create_uint16`

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

语法

duckdb_value duckdb_create_uint16(
  uint16_t input
);

`duckdb_create_int32`

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

语法

duckdb_value duckdb_create_int32(
  int32_t input
);

`duckdb_create_uint32`

从 uint32_t（一个 uinteger）创建一个值

语法

duckdb_value duckdb_create_uint32(
  uint32_t input
);

`duckdb_create_uint64`

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

语法

duckdb_value duckdb_create_uint64(
  uint64_t input
);

`duckdb_create_int64`

从 int64 创建一个值

语法

duckdb_value duckdb_create_int64(
  int64_t val
);

`duckdb_create_hugeint`

从 hugeint 创建一个值

语法

duckdb_value duckdb_create_hugeint(
  duckdb_hugeint input
);

`duckdb_create_uhugeint`

从 uhugeint 创建一个值

语法

duckdb_value duckdb_create_uhugeint(
  duckdb_uhugeint input
);

`duckdb_create_varint`

从 duckdb_varint 创建一个 VARINT 值

语法

duckdb_value duckdb_create_varint(
  duckdb_varint input
);

`duckdb_create_decimal`

从 duckdb_decimal 创建一个 DECIMAL 值

语法

duckdb_value duckdb_create_decimal(
  duckdb_decimal input
);

`duckdb_create_float`

从 float 创建一个值

语法

duckdb_value duckdb_create_float(
  float input
);

`duckdb_create_double`

从 double 创建一个值

语法

duckdb_value duckdb_create_double(
  double input
);

`duckdb_create_date`

从日期创建一个值

语法

duckdb_value duckdb_create_date(
  duckdb_date input
);

`duckdb_create_time`

从时间创建一个值

语法

duckdb_value duckdb_create_time(
  duckdb_time input
);

`duckdb_create_time_tz_value`

从 time_tz 创建一个值。不要与 duckdb_create_time_tz 混淆，后者创建 duckdb_time_tz_t。

语法

duckdb_value duckdb_create_time_tz_value(
  duckdb_time_tz value
);

`duckdb_create_timestamp`

从 duckdb_timestamp 创建一个 TIMESTAMP 值

语法

duckdb_value duckdb_create_timestamp(
  duckdb_timestamp input
);

`duckdb_create_timestamp_tz`

从 duckdb_timestamp 创建一个 TIMESTAMP_TZ 值

语法

duckdb_value duckdb_create_timestamp_tz(
  duckdb_timestamp input
);

`duckdb_create_timestamp_s`

从 duckdb_timestamp_s 创建一个 TIMESTAMP_S 值

语法

duckdb_value duckdb_create_timestamp_s(
  duckdb_timestamp_s input
);

`duckdb_create_timestamp_ms`

从 duckdb_timestamp_ms 创建一个 TIMESTAMP_MS 值

语法

duckdb_value duckdb_create_timestamp_ms(
  duckdb_timestamp_ms input
);

`duckdb_create_timestamp_ns`

从 duckdb_timestamp_ns 创建一个 TIMESTAMP_NS 值

语法

duckdb_value duckdb_create_timestamp_ns(
  duckdb_timestamp_ns input
);

`duckdb_create_interval`

从 interval 创建一个值

语法

duckdb_value duckdb_create_interval(
  duckdb_interval input
);

`duckdb_create_blob`

从 blob 创建一个值

语法

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

`duckdb_create_bit`

从 duckdb_bit 创建一个 BIT 值

语法

duckdb_value duckdb_create_bit(
  duckdb_bit input
);

`duckdb_create_uuid`

从 uhugeint 创建一个 UUID 值

语法

duckdb_value duckdb_create_uuid(
  duckdb_uhugeint input
);

`duckdb_get_bool`

返回给定值的布尔值。

语法

bool duckdb_get_bool(
  duckdb_value val
);

`duckdb_get_int8`

返回给定值的 int8_t 值。

语法

int8_t duckdb_get_int8(
  duckdb_value val
);

`duckdb_get_uint8`

返回给定值的 uint8_t 值。

语法

uint8_t duckdb_get_uint8(
  duckdb_value val
);

`duckdb_get_int16`

返回给定值的 int16_t 值。

语法

int16_t duckdb_get_int16(
  duckdb_value val
);

`duckdb_get_uint16`

返回给定值的 uint16_t 值。

语法

uint16_t duckdb_get_uint16(
  duckdb_value val
);

`duckdb_get_int32`

返回给定值的 int32_t 值。

语法

int32_t duckdb_get_int32(
  duckdb_value val
);

`duckdb_get_uint32`

返回给定值的 uint32_t 值。

语法

uint32_t duckdb_get_uint32(
  duckdb_value val
);

`duckdb_get_int64`

返回给定值的 int64_t 值。

语法

int64_t duckdb_get_int64(
  duckdb_value val
);

`duckdb_get_uint64`

返回给定值的 uint64_t 值。

语法

uint64_t duckdb_get_uint64(
  duckdb_value val
);

`duckdb_get_hugeint`

返回给定值的 hugeint 值。

语法

duckdb_hugeint duckdb_get_hugeint(
  duckdb_value val
);

`duckdb_get_uhugeint`

返回给定值的 uhugeint 值。

语法

duckdb_uhugeint duckdb_get_uhugeint(
  duckdb_value val
);

`duckdb_get_varint`

返回给定值的 duckdb_varint 值。 data 字段必须使用 duckdb_free 销毁。

语法

duckdb_varint duckdb_get_varint(
  duckdb_value val
);

返回值

一个 duckdb_varint。data 字段必须使用 duckdb_free 销毁。

`duckdb_get_decimal`

返回给定值的 duckdb_decimal 值。

语法

duckdb_decimal duckdb_get_decimal(
  duckdb_value val
);

`duckdb_get_float`

返回给定值的 float 值。

语法

float duckdb_get_float(
  duckdb_value val
);

`duckdb_get_double`

返回给定值的 double 值。

语法

double duckdb_get_double(
  duckdb_value val
);

`duckdb_get_date`

返回给定值的日期值。

语法

duckdb_date duckdb_get_date(
  duckdb_value val
);

`duckdb_get_time`

返回给定值的时间值。

语法

duckdb_time duckdb_get_time(
  duckdb_value val
);

`duckdb_get_time_tz`

返回给定值的 time_tz 值。

语法

duckdb_time_tz duckdb_get_time_tz(
  duckdb_value val
);

`duckdb_get_timestamp`

返回给定值的 TIMESTAMP 值。

语法

duckdb_timestamp duckdb_get_timestamp(
  duckdb_value val
);

`duckdb_get_timestamp_tz`

返回给定值的 TIMESTAMP_TZ 值。

语法

duckdb_timestamp duckdb_get_timestamp_tz(
  duckdb_value val
);

`duckdb_get_timestamp_s`

返回给定值的 duckdb_timestamp_s 值。

语法

duckdb_timestamp_s duckdb_get_timestamp_s(
  duckdb_value val
);

返回值

一个 duckdb_timestamp_s，或 MinValue如果该值无法转换

`duckdb_get_timestamp_ms`

返回给定值的 duckdb_timestamp_ms 值。

语法

duckdb_timestamp_ms duckdb_get_timestamp_ms(
  duckdb_value val
);

返回值

一个 duckdb_timestamp_ms，或 MinValue如果该值无法转换

`duckdb_get_timestamp_ns`

返回给定值的 duckdb_timestamp_ns 值。

语法

duckdb_timestamp_ns duckdb_get_timestamp_ns(
  duckdb_value val
);

返回值

一个 duckdb_timestamp_ns，或 MinValue如果该值无法转换

`duckdb_get_interval`

返回给定值的 interval 值。

语法

duckdb_interval duckdb_get_interval(
  duckdb_value val
);

`duckdb_get_value_type`

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

语法

duckdb_logical_type duckdb_get_value_type(
  duckdb_value val
);

`duckdb_get_blob`

返回给定值的 blob 值。

语法

duckdb_blob duckdb_get_blob(
  duckdb_value val
);

`duckdb_get_bit`

返回给定值的 duckdb_bit 值。data 字段必须使用 duckdb_free 销毁。

语法

duckdb_bit duckdb_get_bit(
  duckdb_value val
);

`duckdb_get_uuid`

返回一个 duckdb_uhugeint，表示给定值的 UUID 值。

语法

duckdb_uhugeint duckdb_get_uuid(
  duckdb_value val
);

`duckdb_create_struct_value`

从类型和值数组创建一个 struct 值。必须使用 duckdb_destroy_value 销毁。

语法

duckdb_value duckdb_create_struct_value(
  duckdb_logical_type type,
  duckdb_value *values
);

返回值

struct 值，如果任何子类型是 DUCKDB_TYPE_ANY 或 DUCKDB_TYPE_INVALID，则为 nullptr。

`duckdb_create_list_value`

从子（元素）类型和长度为 value_count 的值数组创建一个 list 值。必须使用 duckdb_destroy_value 销毁。

语法

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

参数

type: list 的类型
values: list 的值
value_count: list 中的值数量

返回值

list 值，如果子类型是 DUCKDB_TYPE_ANY 或 DUCKDB_TYPE_INVALID，则为 nullptr。

`duckdb_create_array_value`

从子（元素）类型和长度为 value_count 的值数组创建一个 array 值。必须使用 duckdb_destroy_value 销毁。

语法

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

参数

type: array 的类型
values: array 的值
value_count: array 中的值数量

返回值

array 值，如果子类型是 DUCKDB_TYPE_ANY 或 DUCKDB_TYPE_INVALID，则为 nullptr。

`duckdb_create_map_value`

从 map 类型和两个数组创建一个 map 值，一个用于键，一个用于值，每个数组的长度为 entry_count。必须使用 duckdb_destroy_value 销毁。

语法

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

参数

map_type: map 类型
keys: map 的键
values: map 的值
entry_count: map 中的条目（键值对）数量

`duckdb_create_union_value`

从 union 类型、标签索引和一个值创建一个 union 值。必须使用 duckdb_destroy_value 销毁。

语法

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

参数

union_type: union 类型
tag_index: union 的标签索引
value: union 的值

`duckdb_get_map_key`

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

语法

duckdb_value duckdb_get_map_key(
  duckdb_value value,
  idx_t index
);

`duckdb_get_map_value`

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

语法

duckdb_value duckdb_get_map_value(
  duckdb_value value,
  idx_t index
);

`duckdb_is_null_value`

返回值的类型是否为 SQLNULL。

语法

bool duckdb_is_null_value(
  duckdb_value value
);

`duckdb_create_null_value`

创建 SQLNULL 类型的值。

返回值

表示 SQLNULL 的 duckdb_value。必须使用 duckdb_destroy_value 销毁它。

语法

duckdb_value duckdb_create_null_value(
  
);

`duckdb_get_list_child`

返回索引处的 LIST 子项作为 duckdb_value。

语法

duckdb_value duckdb_get_list_child(
  duckdb_value value,
  idx_t index
);

`duckdb_create_enum_value`

从类型和一个值创建一个 enum 值。必须使用 duckdb_destroy_value 销毁。

语法

duckdb_value duckdb_create_enum_value(
  duckdb_logical_type type,
  uint64_t value
);

`duckdb_get_enum_value`

返回给定值的 enum 值。

语法

uint64_t duckdb_get_enum_value(
  duckdb_value value
);

`duckdb_get_struct_child`

返回索引处的 STRUCT 子项作为 duckdb_value。

语法

duckdb_value duckdb_get_struct_child(
  duckdb_value value,
  idx_t index
);

`duckdb_value_to_string`

返回给定值的 SQL 字符串表示形式。

语法

char *duckdb_value_to_string(
  duckdb_value value
);

返回值

作为空终止字符串的 SQL 字符串表示形式。结果必须使用 duckdb_free 释放。

`duckdb_logical_type_get_alias`

返回 duckdb_logical_type 的别名（如果已设置），否则返回 nullptr。结果必须使用 duckdb_free 销毁。

语法

char *duckdb_logical_type_get_alias(
  duckdb_logical_type type
);

`duckdb_logical_type_set_alias`

设置 duckdb_logical_type 的别名。

语法

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

`duckdb_create_array_type`

从其子类型创建一个 ARRAY 类型。返回类型必须使用 duckdb_destroy_logical_type 销毁。

语法

duckdb_logical_type duckdb_create_array_type(
  duckdb_logical_type type,
  idx_t array_size
);

参数

type: array 的子类型。
array_size: array 中的元素数量。

`duckdb_create_map_type`

从其键类型和值类型创建一个 MAP 类型。返回类型必须使用 duckdb_destroy_logical_type 销毁。

语法

duckdb_logical_type duckdb_create_map_type(
  duckdb_logical_type key_type,
  duckdb_logical_type value_type
);

参数

key_type: map 的键类型。
value_type: map 的值类型。

`duckdb_create_union_type`

从传递的数组创建一个 UNION 类型。返回类型必须使用 duckdb_destroy_logical_type 销毁。

语法

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

参数

member_types: union 成员类型的数组。
member_names：联合体成员的名称。
member_count：联合体成员的数量。

`duckdb_create_struct_type`

基于成员类型和名称创建一个 STRUCT 类型。生成的类型必须使用 duckdb_destroy_logical_type 销毁。

语法

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

参数

member_types：结构体成员的类型数组。
member_names：结构体成员的名称数组。
member_count：结构体的成员数量。

`duckdb_create_enum_type`

从传递的成员名称数组创建一个 ENUM 类型。生成的类型应使用 duckdb_destroy_logical_type 销毁。

语法

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

参数

member_names：枚举应包含的名称数组。
member_count：数组中指定的元素数量。

`duckdb_create_decimal_type`

创建一个具有指定宽度和小数的 DECIMAL 类型。生成的类型应使用 duckdb_destroy_logical_type 销毁。

语法

duckdb_logical_type duckdb_create_decimal_type(
  uint8_t width,
  uint8_t scale
);

参数

width：decimal 类型的宽度
scale：decimal 类型的小数位数

`duckdb_decimal_internal_type`

检索 decimal 类型的内部存储类型。

语法

duckdb_type duckdb_decimal_internal_type(
  duckdb_logical_type type
);

`duckdb_enum_dictionary_value`

从 enum 检索指定位置的字典值。

结果必须使用 duckdb_free 释放。

语法

char *duckdb_enum_dictionary_value(
  duckdb_logical_type type,
  idx_t index
);

`duckdb_list_type_child_type`

检索给定 LIST 类型的子类型。也接受 MAP 类型。结果必须使用 duckdb_destroy_logical_type 释放。

语法

duckdb_logical_type duckdb_list_type_child_type(
  duckdb_logical_type type
);

`duckdb_array_type_child_type`

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

结果必须使用 duckdb_destroy_logical_type 释放。

语法

duckdb_logical_type duckdb_array_type_child_type(
  duckdb_logical_type type
);

`duckdb_array_type_array_size`

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

语法

idx_t duckdb_array_type_array_size(
  duckdb_logical_type type
);

`duckdb_map_type_key_type`

检索给定 map 类型的键类型。

结果必须使用 duckdb_destroy_logical_type 释放。

语法

duckdb_logical_type duckdb_map_type_key_type(
  duckdb_logical_type type
);

返回值

map 类型的键类型。必须使用 duckdb_destroy_logical_type 销毁。

`duckdb_map_type_value_type`

检索给定 map 类型的值类型。

结果必须使用 duckdb_destroy_logical_type 释放。

语法

duckdb_logical_type duckdb_map_type_value_type(
  duckdb_logical_type type
);

返回值

map 类型的值类型。必须使用 duckdb_destroy_logical_type 销毁。

`duckdb_struct_type_child_count`

返回 struct 类型的子节点数量。

语法

idx_t duckdb_struct_type_child_count(
  duckdb_logical_type type
);

`duckdb_struct_type_child_name`

检索 struct 子节点的名称。

结果必须使用 duckdb_free 释放。

语法

char *duckdb_struct_type_child_name(
  duckdb_logical_type type,
  idx_t index
);

`duckdb_struct_type_child_type`

检索指定索引处给定 struct 类型的子类型。

结果必须使用 duckdb_destroy_logical_type 释放。

语法

duckdb_logical_type duckdb_struct_type_child_type(
  duckdb_logical_type type,
  idx_t index
);

返回值

struct 类型的子类型。必须使用 duckdb_destroy_logical_type 销毁。

`duckdb_union_type_member_count`

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

语法

idx_t duckdb_union_type_member_count(
  duckdb_logical_type type
);

`duckdb_union_type_member_name`

检索联合体成员的名称。

结果必须使用 duckdb_free 释放。

语法

char *duckdb_union_type_member_name(
  duckdb_logical_type type,
  idx_t index
);

`duckdb_union_type_member_type`

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

结果必须使用 duckdb_destroy_logical_type 释放。

语法

duckdb_logical_type duckdb_union_type_member_type(
  duckdb_logical_type type,
  idx_t index
);

返回值

联合体成员的子类型。必须使用 duckdb_destroy_logical_type 销毁。

`duckdb_register_logical_type`

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

语法

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

`duckdb_create_data_chunk`

创建具有指定列类型的空数据块。结果必须使用 duckdb_destroy_data_chunk 销毁。

语法

duckdb_data_chunk duckdb_create_data_chunk(
  duckdb_logical_type *types,
  idx_t column_count
);

参数

types：列类型的数组。列类型不能包含 ANY 和 INVALID 类型。
column_count：列数。

`duckdb_data_chunk_get_column_count`

检索数据块中的列数。

语法

idx_t duckdb_data_chunk_get_column_count(
  duckdb_data_chunk chunk
);

`duckdb_data_chunk_get_vector`

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

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

语法

duckdb_vector duckdb_data_chunk_get_vector(
  duckdb_data_chunk chunk,
  idx_t col_idx
);

`duckdb_create_vector`

创建一个扁平向量。

语法

duckdb_vector duckdb_create_vector(
  duckdb_logical_type type,
  idx_t capacity
);

`duckdb_destroy_vector`

销毁向量并释放为该向量分配的所有内存（如果在其他地方未使用）。

语法

void duckdb_destroy_vector(
  duckdb_vector *vector
);

`duckdb_vector_get_column_type`

检索指定向量的列类型。

结果必须使用 duckdb_destroy_logical_type 销毁。

语法

duckdb_logical_type duckdb_vector_get_column_type(
  duckdb_vector vector
);

`duckdb_vector_get_validity`

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

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

有效性掩码是一个位集，表示数据块中的 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 函数。

语法

uint64_t *duckdb_vector_get_validity(
  duckdb_vector vector
);

`duckdb_vector_ensure_validity_writable`

通过分配有效性掩码来确保其可写。

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

语法

void duckdb_vector_ensure_validity_writable(
  duckdb_vector vector
);

`duckdb_vector_assign_string_element`

在指定位置将字符串元素分配给向量。

语法

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

参数

vector：要更改的向量
index：向量中要将字符串分配到的行位置
str：以 null 结尾的字符串

`duckdb_vector_assign_string_element_len`

在指定位置将字符串元素分配给向量。您也可以使用此函数来分配 BLOB。

语法

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

参数

vector：要更改的向量
index：向量中要将字符串分配到的行位置
str：字符串
str_len：字符串的长度（以字节为单位）

`duckdb_list_vector_get_child`

检索列表向量的子向量。

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

语法

duckdb_vector duckdb_list_vector_get_child(
  duckdb_vector vector
);

`duckdb_list_vector_set_size`

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

语法

duckdb_state duckdb_list_vector_set_size(
  duckdb_vector vector,
  idx_t size
);

返回值

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

`duckdb_list_vector_reserve`

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

调用此方法后，必须调用 duckdb_vector_get_validity 和 duckdb_vector_get_data 以获取当前数据和有效性指针

语法

duckdb_state duckdb_list_vector_reserve(
  duckdb_vector vector,
  idx_t required_capacity
);

参数

vector：列表向量。
required_capacity：要保留的总容量。

返回值

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

`duckdb_struct_vector_get_child`

检索 struct 向量的子向量。

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

语法

duckdb_vector duckdb_struct_vector_get_child(
  duckdb_vector vector,
  idx_t index
);

`duckdb_array_vector_get_child`

检索 array 向量的子向量。

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

语法

duckdb_vector duckdb_array_vector_get_child(
  duckdb_vector vector
);

`duckdb_slice_vector`

使用选择向量切片向量。

选择向量中的最大值必须小于向量的长度

生成的向量恰好是一个字典向量。

语法

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

参数

vector：要成为字典的向量
selection：选择向量
len：选择向量的长度

`duckdb_vector_reference_value`

将值从 value 复制到 vector。

语法

void duckdb_vector_reference_value(
  duckdb_vector vector,
  duckdb_value value
);

`duckdb_vector_reference_vector`

在 to 向量中引用 from 向量，这会使向量共享值缓冲区的拥有权

语法

void duckdb_vector_reference_vector(
  duckdb_vector to_vector,
  duckdb_vector from_vector
);

`duckdb_validity_row_is_valid`

返回给定有效性掩码中的行是否有效（即，非 NULL）。

语法

bool duckdb_validity_row_is_valid(
  uint64_t *validity,
  idx_t row
);

参数

validity：有效性掩码，通过 duckdb_vector_get_validity 获得
row：行索引

`duckdb_validity_set_row_validity`

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

请注意，在调用 duckdb_vector_get_validity 之前应调用 duckdb_vector_ensure_validity_writable，以确保存在可写入的有效性掩码。

语法

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

参数

validity：有效性掩码，通过 duckdb_vector_get_validity 获得。
row：行索引
valid：是否将行设置为有效或无效

`duckdb_validity_set_row_invalid`

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

等效于将 valid 设置为 false 的 duckdb_validity_set_row_validity。

语法

void duckdb_validity_set_row_invalid(
  uint64_t *validity,
  idx_t row
);

`duckdb_validity_set_row_valid`

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

等效于将 valid 设置为 true 的 duckdb_validity_set_row_validity。

语法

void duckdb_validity_set_row_valid(
  uint64_t *validity,
  idx_t row
);

`duckdb_create_scalar_function`

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

返回值必须使用 duckdb_destroy_scalar_function 销毁。

语法

duckdb_scalar_function duckdb_create_scalar_function(
  
);

`duckdb_destroy_scalar_function`

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

语法

void duckdb_destroy_scalar_function(
  duckdb_scalar_function *scalar_function
);

`duckdb_scalar_function_set_name`

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

语法

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

`duckdb_scalar_function_set_varargs`

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

语法

void duckdb_scalar_function_set_varargs(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);

`duckdb_scalar_function_set_special_handling`

将标量函数的 null 处理行为设置为 special。

语法

void duckdb_scalar_function_set_special_handling(
  duckdb_scalar_function scalar_function
);

`duckdb_scalar_function_set_volatile`

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

语法

void duckdb_scalar_function_set_volatile(
  duckdb_scalar_function scalar_function
);

`duckdb_scalar_function_add_parameter`

向标量函数添加参数。

语法

void duckdb_scalar_function_add_parameter(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);

参数

scalar_function：标量函数。
type：参数类型。不能包含 INVALID。

`duckdb_scalar_function_set_return_type`

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

语法

void duckdb_scalar_function_set_return_type(
  duckdb_scalar_function scalar_function,
  duckdb_logical_type type
);

参数

scalar_function：标量函数
type：不能包含 INVALID 或 ANY。

`duckdb_scalar_function_set_extra_info`

将额外信息分配给标量函数，可以在绑定等期间获取。

语法

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

参数

scalar_function：标量函数
extra_info：额外信息
destroy：将调用以销毁额外信息的回调（如果有）

`duckdb_scalar_function_set_bind`

设置标量函数的（可选）绑定函数。

语法

void duckdb_scalar_function_set_bind(
  duckdb_scalar_function scalar_function,
  duckdb_scalar_function_bind_t bind
);

`duckdb_scalar_function_set_bind_data`

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

语法

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

参数

info：标量函数的绑定信息。
bind_data：绑定数据对象。
destroy：销毁绑定数据的回调（如果有）。

`duckdb_scalar_function_bind_set_error`

报告在对标量函数调用 bind 时发生了错误。

语法

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

`duckdb_scalar_function_set_function`

设置标量函数的主函数。

语法

void duckdb_scalar_function_set_function(
  duckdb_scalar_function scalar_function,
  duckdb_scalar_function_t function
);

`duckdb_register_scalar_function`

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

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

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

语法

duckdb_state duckdb_register_scalar_function(
  duckdb_connection con,
  duckdb_scalar_function scalar_function
);

`duckdb_scalar_function_get_extra_info`

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

语法

void *duckdb_scalar_function_get_extra_info(
  duckdb_function_info info
);

`duckdb_scalar_function_get_bind_data`

获取 duckdb_scalar_function_set_bind_data 设置的标量函数的绑定数据。

请注意，绑定数据是只读的。

语法

void *duckdb_scalar_function_get_bind_data(
  duckdb_function_info info
);

`duckdb_scalar_function_get_client_context`

检索标量函数的绑定信息的客户端上下文。

语法

void duckdb_scalar_function_get_client_context(
  duckdb_bind_info info,
  duckdb_client_context *out_context
);

参数

info：标量函数的绑定信息对象。
out_context：绑定信息的客户端上下文。必须使用 duckdb_destroy_client_context 销毁。

`duckdb_scalar_function_set_error`

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

语法

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

`duckdb_create_scalar_function_set`

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

返回值必须使用 duckdb_destroy_scalar_function_set 销毁。

语法

duckdb_scalar_function_set duckdb_create_scalar_function_set(
  const char *name
);

`duckdb_destroy_scalar_function_set`

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

语法

void duckdb_destroy_scalar_function_set(
  duckdb_scalar_function_set *scalar_function_set
);

`duckdb_add_scalar_function_to_set`

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

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

语法

duckdb_state duckdb_add_scalar_function_to_set(
  duckdb_scalar_function_set set,
  duckdb_scalar_function function
);

`duckdb_register_scalar_function_set`

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

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

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

语法

duckdb_state duckdb_register_scalar_function_set(
  duckdb_connection con,
  duckdb_scalar_function_set set
);

`duckdb_create_selection_vector`

创建一个新的大小为 size 的选择向量。

语法

duckdb_selection_vector duckdb_create_selection_vector(
  idx_t size
);

`duckdb_destroy_selection_vector`

销毁选择向量。

语法

void duckdb_destroy_selection_vector(
  duckdb_selection_vector vector
);

`duckdb_selection_vector_get_data_ptr`

访问选择向量的数据指针。

语法

sel_t *duckdb_selection_vector_get_data_ptr(
  duckdb_selection_vector vector
);

`duckdb_create_aggregate_function`

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

返回值应使用 duckdb_destroy_aggregate_function 销毁。

语法

duckdb_aggregate_function duckdb_create_aggregate_function(
  
);

`duckdb_destroy_aggregate_function`

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

语法

void duckdb_destroy_aggregate_function(
  duckdb_aggregate_function *aggregate_function
);

`duckdb_aggregate_function_set_name`

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

语法

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

`duckdb_aggregate_function_add_parameter`

向聚合函数添加参数。

语法

void duckdb_aggregate_function_add_parameter(
  duckdb_aggregate_function aggregate_function,
  duckdb_logical_type type
);

参数

aggregate_function：聚合函数。
type：参数类型。不能包含 INVALID。

`duckdb_aggregate_function_set_return_type`

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

语法

void duckdb_aggregate_function_set_return_type(
  duckdb_aggregate_function aggregate_function,
  duckdb_logical_type type
);

参数

aggregate_function：聚合函数。
type：返回类型。不能包含 INVALID 或 ANY。

`duckdb_aggregate_function_set_functions`

设置聚合函数的主函数。

语法

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

参数

aggregate_function：聚合函数
state_size：状态大小
state_init：状态初始化函数
update：更新状态
combine：合并状态
finalize：完成状态

`duckdb_aggregate_function_set_destructor`

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

语法

void duckdb_aggregate_function_set_destructor(
  duckdb_aggregate_function aggregate_function,
  duckdb_aggregate_destroy_t destroy
);

参数

aggregate_function：聚合函数
destroy：状态销毁回调

`duckdb_register_aggregate_function`

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

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

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

语法

duckdb_state duckdb_register_aggregate_function(
  duckdb_connection con,
  duckdb_aggregate_function aggregate_function
);

`duckdb_aggregate_function_set_special_handling`

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

语法

void duckdb_aggregate_function_set_special_handling(
  duckdb_aggregate_function aggregate_function
);

`duckdb_aggregate_function_set_extra_info`

将额外信息分配给标量函数，可以在绑定等期间获取。

语法

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

参数

aggregate_function：聚合函数
extra_info：额外信息
destroy：将调用以销毁额外信息的回调（如果有）

`duckdb_aggregate_function_get_extra_info`

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

语法

void *duckdb_aggregate_function_get_extra_info(
  duckdb_function_info info
);

`duckdb_aggregate_function_set_error`

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

语法

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

`duckdb_create_aggregate_function_set`

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

返回值应使用 duckdb_destroy_aggregate_function_set 销毁。

语法

duckdb_aggregate_function_set duckdb_create_aggregate_function_set(
  const char *name
);

`duckdb_destroy_aggregate_function_set`

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

语法

void duckdb_destroy_aggregate_function_set(
  duckdb_aggregate_function_set *aggregate_function_set
);

`duckdb_add_aggregate_function_to_set`

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

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

语法

duckdb_state duckdb_add_aggregate_function_to_set(
  duckdb_aggregate_function_set set,
  duckdb_aggregate_function function
);

`duckdb_register_aggregate_function_set`

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

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

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

语法

duckdb_state duckdb_register_aggregate_function_set(
  duckdb_connection con,
  duckdb_aggregate_function_set set
);

`duckdb_create_table_function`

创建一个新的空表函数。

返回值应使用 duckdb_destroy_table_function 销毁。

语法

duckdb_table_function duckdb_create_table_function(
  
);

`duckdb_destroy_table_function`

销毁给定的表函数对象。

语法

void duckdb_destroy_table_function(
  duckdb_table_function *table_function
);

`duckdb_table_function_set_name`

设置给定表函数的名称。

语法

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

`duckdb_table_function_add_parameter`

向表函数添加参数。

语法

void duckdb_table_function_add_parameter(
  duckdb_table_function table_function,
  duckdb_logical_type type
);

参数

table_function：表函数。
type：参数类型。不能包含 INVALID。

`duckdb_table_function_add_named_parameter`

向表函数添加命名参数。

语法

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

参数

table_function：表函数。
name：参数名称。
type：参数类型。不能包含 INVALID。

`duckdb_table_function_set_extra_info`

将额外信息分配给表函数，可以在绑定等期间获取。

语法

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

参数

table_function：表函数
extra_info：额外信息
destroy：将调用以销毁额外信息的回调（如果有）

`duckdb_table_function_set_bind`

设置表函数的绑定函数。

语法

void duckdb_table_function_set_bind(
  duckdb_table_function table_function,
  duckdb_table_function_bind_t bind
);

`duckdb_table_function_set_init`

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

语法

void duckdb_table_function_set_init(
  duckdb_table_function table_function,
  duckdb_table_function_init_t init
);

`duckdb_table_function_set_local_init`

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

语法

void duckdb_table_function_set_local_init(
  duckdb_table_function table_function,
  duckdb_table_function_init_t init
);

`duckdb_table_function_set_function`

设置表函数的主函数。

语法

void duckdb_table_function_set_function(
  duckdb_table_function table_function,
  duckdb_table_function_t function
);

`duckdb_table_function_supports_projection_pushdown`

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

如果设置为 true，则系统将在 init 阶段通过 duckdb_init_get_column_count 和 duckdb_init_get_column_index 函数提供所有必需的列的列表。如果设置为 false（默认），则系统将期望投影所有列。

语法

void duckdb_table_function_supports_projection_pushdown(
  duckdb_table_function table_function,
  bool pushdown
);

参数

table_function：表函数
pushdown：如果表函数支持投影下推，则为 True；否则为 false。

`duckdb_register_table_function`

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

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

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

语法

duckdb_state duckdb_register_table_function(
  duckdb_connection con,
  duckdb_table_function function
);

`duckdb_bind_add_result_column`

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

语法

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

`duckdb_bind_get_parameter_count`

检索函数的常规（非命名）参数的数量。

语法

idx_t duckdb_bind_get_parameter_count(
  duckdb_bind_info info
);

`duckdb_bind_get_parameter`

检索给定索引处的参数。

结果必须使用 duckdb_destroy_value 销毁。

语法

duckdb_value duckdb_bind_get_parameter(
  duckdb_bind_info info,
  idx_t index
);

`duckdb_bind_get_named_parameter`

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

结果必须使用 duckdb_destroy_value 销毁。

语法

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

`duckdb_bind_set_bind_data`

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

语法

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

参数

info：表函数的绑定信息。
bind_data：绑定数据对象。
destroy：销毁绑定数据的回调（如果有）。

`duckdb_init_set_init_data`

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

语法

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

参数

info：信息对象
init_data：初始化数据对象。
destroy：将调用以销毁初始化数据的回调（如果有）

`duckdb_init_get_column_count`

返回投影列的数量。

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

语法

idx_t duckdb_init_get_column_count(
  duckdb_init_info info
);

`duckdb_init_get_column_index`

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

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

语法

idx_t duckdb_init_get_column_index(
  duckdb_init_info info,
  idx_t column_index
);

参数

info：信息对象
column_index：从中获取投影列索引的索引，从 0..duckdb_init_get_column_count(info)

`duckdb_function_get_extra_info`

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

语法

void *duckdb_function_get_extra_info(
  duckdb_function_info info
);

`duckdb_function_get_bind_data`

获取由 duckdb_bind_set_bind_data 设置的表函数的绑定数据。

请注意，绑定数据是只读的。对于跟踪状态，请改用初始化数据。

语法

void *duckdb_function_get_bind_data(
  duckdb_function_info info
);

`duckdb_function_get_init_data`

获取由 duckdb_init_set_init_data 在初始化期间设置的初始化数据。

语法

void *duckdb_function_get_init_data(
  duckdb_function_info info
);

`duckdb_function_get_local_init_data`

获取由 duckdb_init_set_init_data 在 local_init 期间设置的线程本地初始化数据。

语法

void *duckdb_function_get_local_init_data(
  duckdb_function_info info
);

`duckdb_add_replacement_scan`

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

语法

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

参数

db：要添加替换扫描的数据库对象
replacement：替换扫描回调
extra_data：传递回指定回调的额外数据
delete_callback：要对额外数据调用的删除回调（如果有）

`duckdb_replacement_scan_set_function_name`

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

语法

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

`duckdb_replacement_scan_add_parameter`

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

语法

void duckdb_replacement_scan_add_parameter(
  duckdb_replacement_scan_info info,
  duckdb_value parameter
);

`duckdb_replacement_scan_set_error`

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

语法

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

`duckdb_profiling_info_get_value`

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

语法

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

`duckdb_profiling_info_get_metrics`

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

语法

duckdb_value duckdb_profiling_info_get_metrics(
  duckdb_profiling_info info
);

`duckdb_profiling_info_get_child_count`

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

语法

idx_t duckdb_profiling_info_get_child_count(
  duckdb_profiling_info info
);

`duckdb_profiling_info_get_child`

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

语法

duckdb_profiling_info duckdb_profiling_info_get_child(
  duckdb_profiling_info info,
  idx_t index
);

`duckdb_appender_create`

创建 appender 对象。

请注意，必须使用 duckdb_appender_destroy 销毁该对象。

语法

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

参数

connection：要在其中创建 appender 的连接上下文。
schema：要追加到的表的 schema，如果使用默认 schema，则为 nullptr。
table：要追加到的表名。
out_appender：生成的 appender 对象。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_appender_create_ext`

创建 appender 对象。

请注意，必须使用 duckdb_appender_destroy 销毁该对象。

语法

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

参数

connection：要在其中创建 appender 的连接上下文。
catalog：要追加到的表的 catalog，如果使用默认 catalog，则为 nullptr。
schema：要追加到的表的 schema，如果使用默认 schema，则为 nullptr。
table：要追加到的表名。
out_appender：生成的 appender 对象。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_appender_column_count`

返回属于 appender 的列数。如果没有活动的列列表，则此值等于表的物理列数。

语法

idx_t duckdb_appender_column_count(
  duckdb_appender appender
);

`duckdb_appender_column_type`

返回指定索引处列的类型。这可以是活动列列表中的类型，也可以是接收表中列的相同类型。

注意：必须使用 duckdb_destroy_logical_type 销毁结果类型。

语法

duckdb_logical_type duckdb_appender_column_type(
  duckdb_appender appender,
  idx_t col_idx
);

参数

appender：要从中获取列类型的 appender。
col_idx：要获取类型的列的索引。

`duckdb_appender_error`

返回与给定 appender 关联的错误消息。如果 appender 没有错误消息，则返回 nullptr。

不应释放错误消息。它将在调用 duckdb_appender_destroy 时释放。

语法

const char *duckdb_appender_error(
  duckdb_appender appender
);

`duckdb_appender_flush`

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

语法

duckdb_state duckdb_appender_flush(
  duckdb_appender appender
);

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_appender_close`

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

语法

duckdb_state duckdb_appender_close(
  duckdb_appender appender
);

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

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

语法

duckdb_state duckdb_appender_destroy(
  duckdb_appender *appender
);

参数

appender：要刷新、关闭和销毁的 appender。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_appender_add_column`

将列追加到 appender 的活动列列表中。立即刷新所有先前的数据。

活动列列表指定刷新数据时期望的所有列。任何非活动列都将填充其默认值或 NULL。

语法

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

参数

appender：要向其添加列的 appender。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_appender_clear_columns`

从 appender 的活动列列表中删除所有列，重置 appender 以将所有列视为活动列。立即刷新所有先前的数据。

语法

duckdb_state duckdb_appender_clear_columns(
  duckdb_appender appender
);

参数

appender：要从中清除列的 appender。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_appender_begin_row`

一个 nop 函数，提供用于向后兼容性原因。什么也不做。仅需要 duckdb_appender_end_row。

语法

duckdb_state duckdb_appender_begin_row(
  duckdb_appender appender
);

`duckdb_appender_end_row`

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

语法

duckdb_state duckdb_appender_end_row(
  duckdb_appender appender
);

参数

appender：appender。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_append_default`

将 DEFAULT 值（如果列的 DEFAULT 不可用，则为 NULL）追加到 appender。

语法

duckdb_state duckdb_append_default(
  duckdb_appender appender
);

`duckdb_append_default_to_chunk`

在指定的行和列处，将 DEFAULT 值（如果列的 DEFAULT 不可用，则为 NULL）追加到从指定的 appender 创建的块。列的默认值必须是一个常量值。不支持非确定性表达式，例如 nextval('seq') 或 random()。

语法

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

参数

appender：要从中获取默认值的 appender。
chunk：要将默认值追加到的数据块。
col：要将默认值追加到的块列索引。
row：要将默认值追加到的块行索引。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_append_bool`

将布尔值追加到 appender。

语法

duckdb_state duckdb_append_bool(
  duckdb_appender appender,
  bool value
);

`duckdb_append_int8`

将 int8_t 值追加到 appender。

语法

duckdb_state duckdb_append_int8(
  duckdb_appender appender,
  int8_t value
);

`duckdb_append_int16`

将 int16_t 值追加到 appender。

语法

duckdb_state duckdb_append_int16(
  duckdb_appender appender,
  int16_t value
);

`duckdb_append_int32`

将 int32_t 值追加到 appender。

语法

duckdb_state duckdb_append_int32(
  duckdb_appender appender,
  int32_t value
);

`duckdb_append_int64`

将 int64_t 值追加到 appender。

语法

duckdb_state duckdb_append_int64(
  duckdb_appender appender,
  int64_t value
);

`duckdb_append_hugeint`

将 duckdb_hugeint 值追加到 appender。

语法

duckdb_state duckdb_append_hugeint(
  duckdb_appender appender,
  duckdb_hugeint value
);

`duckdb_append_uint8`

将 uint8_t 值追加到 appender。

语法

duckdb_state duckdb_append_uint8(
  duckdb_appender appender,
  uint8_t value
);

`duckdb_append_uint16`

将 uint16_t 值追加到 appender。

语法

duckdb_state duckdb_append_uint16(
  duckdb_appender appender,
  uint16_t value
);

`duckdb_append_uint32`

将 uint32_t 值追加到 appender。

语法

duckdb_state duckdb_append_uint32(
  duckdb_appender appender,
  uint32_t value
);

`duckdb_append_uint64`

将 uint64_t 值追加到 appender。

语法

duckdb_state duckdb_append_uint64(
  duckdb_appender appender,
  uint64_t value
);

`duckdb_append_uhugeint`

将 duckdb_uhugeint 值追加到 appender。

语法

duckdb_state duckdb_append_uhugeint(
  duckdb_appender appender,
  duckdb_uhugeint value
);

`duckdb_append_float`

将浮点值追加到 appender。

语法

duckdb_state duckdb_append_float(
  duckdb_appender appender,
  float value
);

`duckdb_append_double`

将双精度值追加到 appender。

语法

duckdb_state duckdb_append_double(
  duckdb_appender appender,
  double value
);

`duckdb_append_date`

将 duckdb_date 值追加到 appender。

语法

duckdb_state duckdb_append_date(
  duckdb_appender appender,
  duckdb_date value
);

`duckdb_append_time`

将 duckdb_time 值追加到 appender。

语法

duckdb_state duckdb_append_time(
  duckdb_appender appender,
  duckdb_time value
);

`duckdb_append_timestamp`

将 duckdb_timestamp 值追加到 appender。

语法

duckdb_state duckdb_append_timestamp(
  duckdb_appender appender,
  duckdb_timestamp value
);

`duckdb_append_interval`

将 duckdb_interval 值追加到 appender。

语法

duckdb_state duckdb_append_interval(
  duckdb_appender appender,
  duckdb_interval value
);

`duckdb_append_varchar`

将 varchar 值追加到 appender。

语法

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

`duckdb_append_varchar_length`

将 varchar 值追加到 appender。

语法

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

`duckdb_append_blob`

将 blob 值追加到 appender。

语法

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

`duckdb_append_null`

将 NULL 值（任何类型）追加到 appender。

语法

duckdb_state duckdb_append_null(
  duckdb_appender appender
);

`duckdb_append_value`

将 duckdb_value 追加到 appender。

语法

duckdb_state duckdb_append_value(
  duckdb_appender appender,
  duckdb_value value
);

`duckdb_append_data_chunk`

将预填充的数据块追加到指定的 appender。如果数据块类型与活动 appender 类型不匹配，则尝试强制转换。

语法

duckdb_state duckdb_append_data_chunk(
  duckdb_appender appender,
  duckdb_data_chunk chunk
);

参数

appender：要追加到的 appender。
chunk：要追加的数据块。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_table_description_create`

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

语法

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

参数

connection：连接上下文。
schema：表的 schema，如果使用默认 schema，则为 nullptr。
table：表名。
out：生成的表描述对象。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_table_description_create_ext`

创建表描述对象。请注意，即使函数返回 DuckDBError，也必须对生成的 table_description 调用 duckdb_table_description_destroy。

语法

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

参数

connection：连接上下文。
catalog：表的 catalog（数据库）名称，如果使用默认 catalog，则为 nullptr。
schema：表的 schema，如果使用默认 schema，则为 nullptr。
table：表名。
out：生成的表描述对象。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_table_description_destroy`

销毁 TableDescription 对象。

语法

void duckdb_table_description_destroy(
  duckdb_table_description *table_description
);

参数

table_description：要销毁的 table_description。

`duckdb_table_description_error`

返回与给定 table_description 关联的错误消息。如果 table_description 没有错误消息，则返回 nullptr。不应释放错误消息。它将在调用 duckdb_table_description_destroy 时释放。

语法

const char *duckdb_table_description_error(
  duckdb_table_description table_description
);

参数

table_description：要从中获取错误的 table_description。

返回值

错误消息，如果没有则为 nullptr。

`duckdb_column_has_default`

检查表的“index”索引处的列是否具有 DEFAULT 表达式。

语法

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

参数

table_description：要查询的 table_description。
index：要查询的列的索引。
out：用于存储结果的 out-parameter。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_table_description_get_column_name`

获取“index”处的列名。必须使用 duckdb_free 销毁 out 结果。

语法

char *duckdb_table_description_get_column_name(
  duckdb_table_description table_description,
  idx_t index
);

参数

table_description：要查询的 table_description。
index：要查询的列的索引。

返回值

列名。

`duckdb_query_arrow`

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

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

语法

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

参数

connection：要在其中执行查询的连接。
query：要运行的 SQL 查询。
out_result：查询结果。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_query_arrow_schema`

从 arrow 结果中获取内部 arrow schema。请记住对相应的 ArrowSchema 对象调用 release。

语法

duckdb_state duckdb_query_arrow_schema(
  duckdb_arrow result,
  duckdb_arrow_schema *out_schema
);

参数

result：要从中获取 schema 的结果。
out_schema：输出 schema。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_prepared_arrow_schema`

从预处理语句中获取内部 arrow schema。请记住对相应的 ArrowSchema 对象调用 release。

语法

duckdb_state duckdb_prepared_arrow_schema(
  duckdb_prepared_statement prepared,
  duckdb_arrow_schema *out_schema
);

参数

prepared：要从中获取 schema 的预处理语句。
out_schema：输出 schema。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_result_arrow_array`

将数据块转换为 arrow 结构数组。请记住对相应的 ArrowArray 对象调用 release。

语法

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

参数

result：从中获取数据块的结果对象。
chunk：要转换的数据块。
out_array：输出数组。

`duckdb_query_arrow_array`

从 arrow 结果中获取内部 arrow 结构数组。请记住对相应的 ArrowArray 对象调用 release。

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

语法

duckdb_state duckdb_query_arrow_array(
  duckdb_arrow result,
  duckdb_arrow_array *out_array
);

参数

result：要从中获取数组的结果。
out_array：输出数组。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_arrow_column_count`

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

语法

idx_t duckdb_arrow_column_count(
  duckdb_arrow result
);

参数

result：结果对象。

返回值

结果对象中存在的列数。

`duckdb_arrow_row_count`

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

语法

idx_t duckdb_arrow_row_count(
  duckdb_arrow result
);

参数

result：结果对象。

返回值

结果对象中存在的行数。

`duckdb_arrow_rows_changed`

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

语法

idx_t duckdb_arrow_rows_changed(
  duckdb_arrow result
);

参数

result：结果对象。

返回值

更改的行数。

`duckdb_query_arrow_error`

返回结果中包含的错误消息。仅当 duckdb_query_arrow 返回 DuckDBError 时才设置错误。

不应释放错误消息。它将在调用 duckdb_destroy_arrow 时释放。

语法

const char *duckdb_query_arrow_error(
  duckdb_arrow result
);

参数

result：从中获取错误的结果对象。

返回值

结果的错误。

`duckdb_destroy_arrow`

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

语法

void duckdb_destroy_arrow(
  duckdb_arrow *result
);

参数

result：要销毁的结果。

`duckdb_destroy_arrow_stream`

释放 arrow 数组流并释放其内存。

语法

void duckdb_destroy_arrow_stream(
  duckdb_arrow_stream *stream_p
);

参数

stream_p：要销毁的 arrow 数组流。

`duckdb_execute_prepared_arrow`

使用给定的绑定参数执行预处理语句，并返回 arrow 查询结果。请注意，运行 duckdb_execute_prepared_arrow 后，必须对结果对象调用 duckdb_destroy_arrow。

语法

duckdb_state duckdb_execute_prepared_arrow(
  duckdb_prepared_statement prepared_statement,
  duckdb_arrow *out_result
);

参数

prepared_statement: 要执行的预处理语句。
out_result：查询结果。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_arrow_scan`

扫描 Arrow 流并创建具有给定名称的视图。

语法

duckdb_state duckdb_arrow_scan(
  duckdb_connection connection,
  const char *table_name,
  duckdb_arrow_stream arrow
);

参数

connection：要在其上执行扫描的连接。
table_name：要创建的临时视图的名称。
arrow：Arrow 流包装器。

返回值

成功时返回 DuckDBSuccess，失败时返回 DuckDBError。

`duckdb_arrow_array_scan`

扫描 Arrow 数组并创建具有给定名称的视图。请注意，运行 duckdb_arrow_array_scan 后，必须对 out 流调用 duckdb_destroy_arrow_stream。

语法

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

参数

connection：要在其上执行扫描的连接。
table_name：要创建的临时视图的名称。
arrow_schema：Arrow schema 包装器。
arrow_array：Arrow 数组包装器。
out_stream：输出数组流，围绕传递的 schema 包装，用于在完成后释放/删除。

void duckdb_execute_tasks(
  duckdb_database database,
  idx_t max_tasks
);

参数

database：要执行任务的数据库对象
max_tasks：要执行的最大任务数

`duckdb_create_task_state`

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

必须对结果调用 duckdb_destroy_state。

语法

duckdb_task_state duckdb_create_task_state(
  duckdb_database database
);

参数

database：要为其创建任务状态的数据库对象

void duckdb_execute_tasks_state(
  duckdb_task_state state
);

参数

state：执行器的任务状态

`duckdb_execute_n_tasks_state`

在此线程上执行 DuckDB 任务。

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

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

语法

idx_t duckdb_execute_n_tasks_state(
  duckdb_task_state state,
  idx_t max_tasks
);

参数

state：执行器的任务状态
max_tasks：要执行的最大任务数

void duckdb_finish_execution(
  duckdb_task_state state
);

参数

state：要完成执行的任务状态

`duckdb_task_state_is_finished`

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

语法

bool duckdb_task_state_is_finished(
  duckdb_task_state state
);

参数

state：要检查的任务状态

void duckdb_destroy_task_state(
  duckdb_task_state state
);

参数

state：要清理的任务状态

`duckdb_execution_is_finished`

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

语法

bool duckdb_execution_is_finished(
  duckdb_connection con
);

参数

con：要检查的连接

`duckdb_stream_fetch_chunk`

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

结果必须使用 duckdb_destroy_data_chunk 销毁。

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

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

事先不知道此结果将返回多少个块。

语法

duckdb_data_chunk duckdb_stream_fetch_chunk(
  duckdb_result result
);

参数

result：从中获取数据块的结果对象。

返回值

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

`duckdb_fetch_chunk`

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

结果必须使用 duckdb_destroy_data_chunk 销毁。

事先不知道此结果将返回多少个块。

语法

duckdb_data_chunk duckdb_fetch_chunk(
  duckdb_result result
);

参数

result：从中获取数据块的结果对象。

duckdb_cast_function duckdb_create_cast_function(
  
);

`duckdb_cast_function_set_source_type`

设置强制转换函数的源类型。

语法

void duckdb_cast_function_set_source_type(
  duckdb_cast_function cast_function,
  duckdb_logical_type source_type
);

参数

cast_function：强制转换函数对象。
source_type：要设置的源类型。

`duckdb_cast_function_set_target_type`

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

语法

void duckdb_cast_function_set_target_type(
  duckdb_cast_function cast_function,
  duckdb_logical_type target_type
);

参数

cast_function：强制转换函数对象。
target_type：要设置的目标类型。

`duckdb_cast_function_set_implicit_cast_cost`

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

语法

void duckdb_cast_function_set_implicit_cast_cost(
  duckdb_cast_function cast_function,
  int64_t cost
);

参数

cast_function：强制转换函数对象。
cost：要设置的成本。

`duckdb_cast_function_set_function`

设置要使用的实际强制转换函数。

语法

void duckdb_cast_function_set_function(
  duckdb_cast_function cast_function,
  duckdb_cast_function_t function
);

参数

cast_function：强制转换函数对象。
function：要设置的函数。

`duckdb_cast_function_set_extra_info`

将额外信息分配给强制转换函数，可以在执行期间等获取。

语法

void duckdb_cast_function_set_extra_info(
  duckdb_cast_function cast_function,
  void *extra_info,
  duckdb_delete_callback_t destroy
);

参数

extra_info：额外信息
destroy：将调用以销毁额外信息的回调（如果有）

`duckdb_cast_function_get_extra_info`

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

语法

void *duckdb_cast_function_get_extra_info(
  duckdb_function_info info
);

参数

info：信息对象。

duckdb_cast_mode duckdb_cast_function_get_cast_mode(
  duckdb_function_info info
);

参数

info：信息对象。

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

参数

info：信息对象。
error：错误消息。

`duckdb_cast_function_set_row_error`

报告执行强制转换函数时发生错误，并将相应的输出行设置为 NULL。

语法

void duckdb_cast_function_set_row_error(
  duckdb_function_info info,
  const char *error,
  idx_t row,
  duckdb_vector output
);

参数

info：信息对象。
error：错误消息。
row：输出向量中要设置为 NULL 的行的索引。
output：输出向量。

`duckdb_register_cast_function`

在给定的连接中注册强制转换函数。

语法

duckdb_state duckdb_register_cast_function(
  duckdb_connection con,
  duckdb_cast_function cast_function
);

参数

con：要使用的连接。
cast_function：要注册的强制转换函数。

void duckdb_destroy_cast_function(
  duckdb_cast_function *cast_function
);

参数

cast_function：强制转换函数对象。