⌘+k ctrl+k
1.4 (LTS)
搜索快捷键 cmd + k | ctrl + k
类型

DuckDB 是一个强类型的数据库系统。因此,每一列都指定了单一的类型。该类型在整个列中保持不变。也就是说,标记为 INTEGER 的列将仅包含 INTEGER 值。

DuckDB 还支持复合类型列。例如,可以定义整数数组(INTEGER[])。也可以将类型定义为任意结构体(ROW(i INTEGER, j VARCHAR))。因此,原生的 DuckDB 类型对象不仅仅是枚举,而是一个可以嵌套的类。

C API 中的类型使用枚举(duckdb_type)和一个复杂类(duckdb_logical_type)进行建模。对于大多数原始类型,例如整数或变长字符串,枚举已经足够。对于更复杂的类型,如列表、结构体或小数,则必须使用逻辑类型(logical type)。

typedef enum DUCKDB_TYPE {
  DUCKDB_TYPE_INVALID = 0,
  DUCKDB_TYPE_BOOLEAN = 1,
  DUCKDB_TYPE_TINYINT = 2,
  DUCKDB_TYPE_SMALLINT = 3,
  DUCKDB_TYPE_INTEGER = 4,
  DUCKDB_TYPE_BIGINT = 5,
  DUCKDB_TYPE_UTINYINT = 6,
  DUCKDB_TYPE_USMALLINT = 7,
  DUCKDB_TYPE_UINTEGER = 8,
  DUCKDB_TYPE_UBIGINT = 9,
  DUCKDB_TYPE_FLOAT = 10,
  DUCKDB_TYPE_DOUBLE = 11,
  DUCKDB_TYPE_TIMESTAMP = 12,
  DUCKDB_TYPE_DATE = 13,
  DUCKDB_TYPE_TIME = 14,
  DUCKDB_TYPE_INTERVAL = 15,
  DUCKDB_TYPE_HUGEINT = 16,
  DUCKDB_TYPE_UHUGEINT = 32,
  DUCKDB_TYPE_VARCHAR = 17,
  DUCKDB_TYPE_BLOB = 18,
  DUCKDB_TYPE_DECIMAL = 19,
  DUCKDB_TYPE_TIMESTAMP_S = 20,
  DUCKDB_TYPE_TIMESTAMP_MS = 21,
  DUCKDB_TYPE_TIMESTAMP_NS = 22,
  DUCKDB_TYPE_ENUM = 23,
  DUCKDB_TYPE_LIST = 24,
  DUCKDB_TYPE_STRUCT = 25,
  DUCKDB_TYPE_MAP = 26,
  DUCKDB_TYPE_ARRAY = 33,
  DUCKDB_TYPE_UUID = 27,
  DUCKDB_TYPE_UNION = 28,
  DUCKDB_TYPE_BIT = 29,
  DUCKDB_TYPE_TIME_TZ = 30,
  DUCKDB_TYPE_TIMESTAMP_TZ = 31,
} duckdb_type;

函数

结果集中某列的枚举类型可以使用 duckdb_column_type 函数获取。某列的逻辑类型可以使用 duckdb_column_logical_type 函数获取。

duckdb_value

duckdb_value 系列函数会根据需要自动转换(auto-cast)值。例如,在类型为 duckdb_value_int32 的列上使用 duckdb_value_double 是完全没问题的。该值会被自动转换并作为 double 返回。请注意,在某些情况下转换可能会失败。例如,当我们请求 duckdb_value_int8 而该值无法容纳在 int8 中时就会发生这种情况。在这种情况下,将返回一个默认值(通常为 0nullptr)。如果对应的值为 NULL,也会返回相同的默认值。

duckdb_value_is_null 函数可用于检查特定值是否为 NULL

自动转换规则的一个例外是 duckdb_value_varchar_internal 函数。此函数不执行自动转换,且仅适用于 VARCHAR 列。该函数存在的原因是结果不需要释放内存。

duckdb_value_varcharduckdb_value_blob 要求使用 duckdb_free 来释放结果内存。

duckdb_fetch_chunk

duckdb_fetch_chunk 函数可用于从 DuckDB 结果集中读取数据块,这是使用 C API 从 DuckDB 结果中读取数据的最高效方式。这也是从 DuckDB 结果中读取某些特定类型数据的唯一方式。例如,duckdb_value 函数不支持对复合类型(列表或结构体)或更复杂类型(如枚举或小数)进行结构化读取。

有关数据块的更多信息,请参阅 关于数据块的文档

API参考概览

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

日期时间戳辅助函数

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

Decimal 辅助函数

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

逻辑类型接口

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_result_get_chunk

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

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

结果必须使用 duckdb_destroy_data_chunk 进行销毁。

此函数取代了所有 duckdb_value 函数,以及 duckdb_column_dataduckdb_nullmask_data 函数。它能带来显著的性能提升,应在较新的代码库中优先使用。

如果使用了此函数,则不能使用其他任何结果函数,反之亦然(即此函数不能与遗留的结果函数混合使用)。

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

语法
duckdb_data_chunk duckdb_result_get_chunk(
  duckdb_result result,
  idx_t chunk_index
);
参数
  • result: 要从中获取数据块的结果对象。
  • chunk_index: 要获取的数据块索引。
返回值

得到的数据块。如果块索引超出范围,则返回 NULL


duckdb_result_is_streaming

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

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

语法
bool duckdb_result_is_streaming(
  duckdb_result result
);
参数
  • result: 要检查的结果对象。
返回值

结果对象是否为 StreamQueryResult 类型


duckdb_result_chunk_count

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

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

语法
idx_t duckdb_result_chunk_count(
  duckdb_result result
);
参数
  • result: 结果对象
返回值

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


duckdb_result_return_type

返回给定结果的 return_type,若出错则返回 DUCKDB_RETURN_TYPE_INVALID

语法
duckdb_result_type duckdb_result_return_type(
  duckdb_result result
);
参数
  • result: 结果对象
返回值

返回类型


duckdb_from_date

duckdb_date 对象分解为年、月和日(存储为 duckdb_date_struct)。

语法
duckdb_date_struct duckdb_from_date(
  duckdb_date date
);
参数
  • date: 从 DUCKDB_TYPE_DATE 列获取的日期对象。
返回值

包含分解元素的 duckdb_date_struct


duckdb_to_date

通过年、月和日(duckdb_date_struct)重新组合成 duckdb_date

语法
duckdb_date duckdb_to_date(
  duckdb_date_struct date
);
参数
  • date: 存储在 duckdb_date_struct 中的年、月和日。
返回值

duckdb_date 元素。


duckdb_is_finite_date

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

语法
bool duckdb_is_finite_date(
  duckdb_date date
);
参数
  • date: 从 DUCKDB_TYPE_DATE 列获取的日期对象。
返回值

如果日期是有限的则为 true,如果为 ±无穷大则为 false。


duckdb_from_time

duckdb_time 对象分解为时、分、秒和微秒(存储为 duckdb_time_struct)。

语法
duckdb_time_struct duckdb_from_time(
  duckdb_time time
);
参数
  • time: 从 DUCKDB_TYPE_TIME 列获取的时间对象。
返回值

包含分解元素的 duckdb_time_struct


duckdb_create_time_tz

通过微秒和时区偏移量创建一个 duckdb_time_tz 对象。

语法
duckdb_time_tz duckdb_create_time_tz(
  int64_t micros,
  int32_t offset
);
参数
  • micros: 时间的微秒部分。
  • offset: 时间的时区偏移部分。
返回值

The duckdb_time_tz element.


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_time 元素。


duckdb_from_timestamp

duckdb_timestamp 对象分解为 duckdb_timestamp_struct

语法
duckdb_timestamp_struct duckdb_from_timestamp(
  duckdb_timestamp ts
);
参数
  • ts: 从 DUCKDB_TYPE_TIMESTAMP 列获取的 ts 对象。
返回值

包含分解元素的 duckdb_timestamp_struct


duckdb_to_timestamp

通过 duckdb_timestamp_struct 重新组合成 duckdb_timestamp

语法
duckdb_timestamp duckdb_to_timestamp(
  duckdb_timestamp_struct ts
);
参数
  • ts: duckdb_timestamp_struct 中分解的元素。
返回值

duckdb_timestamp 元素。


duckdb_is_finite_timestamp

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

语法
bool duckdb_is_finite_timestamp(
  duckdb_timestamp ts
);
参数
  • ts: 从 DUCKDB_TYPE_TIMESTAMP 列获取的 duckdb_timestamp 对象。
返回值

如果时间戳是有限的则为 true,如果为 ±无穷大则为 false。


duckdb_is_finite_timestamp_s

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

语法
bool duckdb_is_finite_timestamp_s(
  duckdb_timestamp_s ts
);
参数
  • ts: 从 DUCKDB_TYPE_TIMESTAMP_S 列获取的 duckdb_timestamp_s 对象。
返回值

如果时间戳是有限的则为 true,如果为 ±无穷大则为 false。


duckdb_is_finite_timestamp_ms

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

语法
bool duckdb_is_finite_timestamp_ms(
  duckdb_timestamp_ms ts
);
参数
  • ts: 从 DUCKDB_TYPE_TIMESTAMP_MS 列获取的 duckdb_timestamp_ms 对象。
返回值

如果时间戳是有限的则为 true,如果为 ±无穷大则为 false。


duckdb_is_finite_timestamp_ns

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

语法
bool duckdb_is_finite_timestamp_ns(
  duckdb_timestamp_ns ts
);
参数
  • ts: 从 DUCKDB_TYPE_TIMESTAMP_NS 列获取的 duckdb_timestamp_ns 对象。
返回值

如果时间戳是有限的则为 true,如果为 ±无穷大则为 false。


duckdb_hugeint_to_double

将 duckdb_hugeint 对象(从 DUCKDB_TYPE_HUGEINT 列获取)转换为 double。

语法
double duckdb_hugeint_to_double(
  duckdb_hugeint val
);
参数
  • val: hugeint 值。
返回值

转换后的 double 元素。


duckdb_double_to_hugeint

将 double 值转换为 duckdb_hugeint 对象。

如果由于 double 值太大导致转换失败,结果将为 0。

语法
duckdb_hugeint duckdb_double_to_hugeint(
  double val
);
参数
  • val: double 值。
返回值

转换后的 duckdb_hugeint 元素。


duckdb_double_to_decimal

将 double 值转换为 duckdb_decimal 对象。

如果由于 double 值太大或宽度/精度无效导致转换失败,结果将为 0。

语法
duckdb_decimal duckdb_double_to_decimal(
  double val,
  uint8_t width,
  uint8_t scale
);
参数
  • val: double 值。
返回值

转换后的 duckdb_decimal 元素。


duckdb_decimal_to_double

将 duckdb_decimal 对象(从 DUCKDB_TYPE_DECIMAL 列获取)转换为 double。

语法
double duckdb_decimal_to_double(
  duckdb_decimal val
);
参数
  • val: decimal 值。
返回值

转换后的 double 元素。


duckdb_create_logical_type

从原始类型创建一个 duckdb_logical_type。生成的逻辑类型必须使用 duckdb_destroy_logical_type 销毁。

如果类型为以下值,则返回无效的逻辑类型:DUCKDB_TYPE_INVALID, DUCKDB_TYPE_DECIMAL, DUCKDB_TYPE_ENUM, DUCKDB_TYPE_LIST, DUCKDB_TYPE_STRUCT, DUCKDB_TYPE_MAP, DUCKDB_TYPE_ARRAYDUCKDB_TYPE_UNION

语法
duckdb_logical_type duckdb_create_logical_type(
  duckdb_type type
);
参数
  • type: 要创建的原始类型。
返回值

逻辑类型。


duckdb_logical_type_get_alias

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

语法
char *duckdb_logical_type_get_alias(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型
返回值

别名或 nullptr


duckdb_logical_type_set_alias

设置 duckdb_logical_type 的别名。

语法
void duckdb_logical_type_set_alias(
  duckdb_logical_type type,
  const char *alias
);
参数
  • type: 逻辑类型
  • alias: 要设置的别名


duckdb_create_list_type

根据子类型创建 LIST 类型。返回的类型必须使用 duckdb_destroy_logical_type 销毁。

语法
duckdb_logical_type duckdb_create_list_type(
  duckdb_logical_type type
);
参数
  • type: 列表的子类型
返回值

逻辑类型。


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_size: 数组中的元素数量。
返回值

逻辑类型。


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: 映射的键类型。
  • value_type: 映射的值类型。
返回值

逻辑类型。


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: 联合成员类型的数组。
  • 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

创建一个具有指定宽度(width)和精度(scale)的 DECIMAL 类型。生成的类型应使用 duckdb_destroy_logical_type 销毁。

语法
duckdb_logical_type duckdb_create_decimal_type(
  uint8_t width,
  uint8_t scale
);
参数
  • width: 十进制类型的宽度
  • scale: 十进制类型的精度
返回值

逻辑类型。


duckdb_get_type_id

获取 duckdb_logical_type 的枚举 duckdb_type

语法
duckdb_type duckdb_get_type_id(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型。
返回值

duckdb_type id。


duckdb_decimal_width

获取十进制类型的宽度。

语法
uint8_t duckdb_decimal_width(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

十进制类型的宽度


duckdb_decimal_scale

获取十进制类型的精度。

语法
uint8_t duckdb_decimal_scale(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

十进制类型的精度


duckdb_decimal_internal_type

获取十进制类型的内部存储类型。

语法
duckdb_type duckdb_decimal_internal_type(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

十进制类型的内部类型


duckdb_enum_internal_type

获取枚举类型的内部存储类型。

语法
duckdb_type duckdb_enum_internal_type(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

枚举类型的内部类型


duckdb_enum_dictionary_size

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

语法
uint32_t duckdb_enum_dictionary_size(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

枚举类型的字典大小


duckdb_enum_dictionary_value

从枚举中获取指定位置的字典值。

结果必须使用 duckdb_free 释放。

语法
char *duckdb_enum_dictionary_value(
  duckdb_logical_type type,
  idx_t index
);
参数
  • type: 逻辑类型对象
  • index: 字典中的索引
返回值

枚举类型的字符串值。必须使用 duckdb_free 释放。


duckdb_list_type_child_type

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

语法
duckdb_logical_type duckdb_list_type_child_type(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型,LIST 或 MAP。
返回值

LIST 或 MAP 类型的子类型。


duckdb_array_type_child_type

获取给定 ARRAY 类型的子类型。

结果必须使用 duckdb_destroy_logical_type 释放。

语法
duckdb_logical_type duckdb_array_type_child_type(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型。必须是 ARRAY。
返回值

ARRAY 类型的子类型。


duckdb_array_type_array_size

获取给定数组类型的数组大小。

语法
idx_t duckdb_array_type_array_size(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

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


duckdb_map_type_key_type

获取给定映射类型的键类型。

结果必须使用 duckdb_destroy_logical_type 释放。

语法
duckdb_logical_type duckdb_map_type_key_type(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

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


duckdb_map_type_value_type

获取给定映射类型的值类型。

结果必须使用 duckdb_destroy_logical_type 释放。

语法
duckdb_logical_type duckdb_map_type_value_type(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

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


duckdb_struct_type_child_count

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

语法
idx_t duckdb_struct_type_child_count(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型对象
返回值

结构体类型的子项数量。


duckdb_struct_type_child_name

获取结构体子项的名称。

结果必须使用 duckdb_free 释放。

语法
char *duckdb_struct_type_child_name(
  duckdb_logical_type type,
  idx_t index
);
参数
  • type: 逻辑类型对象
  • index:子索引
返回值

结构体类型的名称。必须使用 duckdb_free 释放。


duckdb_struct_type_child_type

获取指定索引处给定结构体类型的子类型。

结果必须使用 duckdb_destroy_logical_type 释放。

语法
duckdb_logical_type duckdb_struct_type_child_type(
  duckdb_logical_type type,
  idx_t index
);
参数
  • type: 逻辑类型对象
  • index:子索引
返回值

结构体类型的子类型。必须使用 duckdb_destroy_logical_type 销毁。


duckdb_union_type_member_count

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

语法
idx_t duckdb_union_type_member_count(
  duckdb_logical_type type
);
参数
  • type: 逻辑类型(联合)对象
返回值

联合类型的成员数量。


duckdb_union_type_member_name

获取联合成员的名称。

结果必须使用 duckdb_free 释放。

语法
char *duckdb_union_type_member_name(
  duckdb_logical_type type,
  idx_t index
);
参数
  • type: 逻辑类型对象
  • index:子索引
返回值

联合成员的名称。必须使用 duckdb_free 释放。


duckdb_union_type_member_type

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

结果必须使用 duckdb_destroy_logical_type 释放。

语法
duckdb_logical_type duckdb_union_type_member_type(
  duckdb_logical_type type,
  idx_t index
);
参数
  • type: 逻辑类型对象
  • index:子索引
返回值

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


duckdb_destroy_logical_type

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

语法
void duckdb_destroy_logical_type(
  duckdb_logical_type *type
);
参数
  • type: 要销毁的逻辑类型。


duckdb_register_logical_type

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

语法
duckdb_state duckdb_register_logical_type(
  duckdb_connection con,
  duckdb_logical_type type,
  duckdb_create_type_info info
);
参数
  • con: 要使用的连接
  • type: 要注册的自定义类型
返回值

注册是否成功。


© 2025 DuckDB 基金会,阿姆斯特丹,荷兰
行为准则 商标使用指南