duckdb::ArrowTypeExtension Class Reference

Collaboration diagram for duckdb::ArrowTypeExtension:

Public Member Functions
	ArrowTypeExtension (ArrowExtensionMetadata &extension_metadata, unique_ptr< ArrowType > type)
	This type is not registered, so we just use whatever is the format and hope for the best.
	ArrowTypeExtension (string extension_name, string arrow_format, shared_ptr< ArrowTypeExtensionData > type)
	We either have simple extensions where we only return one type.
	ArrowTypeExtension (string vendor_name, string type_name, string arrow_format, shared_ptr< ArrowTypeExtensionData > type)
	ArrowTypeExtension (string extension_name, populate_arrow_schema_t populate_arrow_schema, get_type_t get_type, shared_ptr< ArrowTypeExtensionData > type)
	We have complex extensions, where we can return multiple types, hence we must have callback functions to do so.
	ArrowTypeExtension (string vendor_name, string type_name, populate_arrow_schema_t populate_arrow_schema, get_type_t get_type, shared_ptr< ArrowTypeExtensionData > type, cast_arrow_duck_t arrow_to_duckdb, cast_duck_arrow_t duckdb_to_arrow)
ArrowExtensionMetadata	GetInfo () const
unique_ptr< ArrowType >	GetType (ClientContext &context, const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) const
shared_ptr< ArrowTypeExtensionData >	GetTypeExtension () const
LogicalTypeId	GetLogicalTypeId () const
LogicalType	GetLogicalType () const
bool	HasType () const

Static Public Member Functions
static void	PopulateArrowSchema (DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &duckdb_type, ClientContext &context, const ArrowTypeExtension &extension)

Public Attributes
populate_arrow_schema_t	populate_arrow_schema = nullptr
	(Optional) Callback to a function that sets up the arrow schema production
get_type_t	get_type = nullptr
	(Optional) Callback to a function that sets up the arrow schema production

Private Attributes
ArrowExtensionMetadata	extension_metadata
	Extension Info from Arrow.
shared_ptr< ArrowTypeExtensionData >	type_extension
	Arrow Extension Type.

Constructor & Destructor Documentation

ArrowTypeExtension() [1/6]

duckdb::ArrowTypeExtension::ArrowTypeExtension ( )

inline

{};

ArrowTypeExtension() [2/6]

duckdb::ArrowTypeExtension::ArrowTypeExtension ( ArrowExtensionMetadata &  extension_metadata, unique_ptr< ArrowType >  type  )

explicit

This type is not registered, so we just use whatever is the format and hope for the best.

    : extension_metadata(extension_metadata) {
    type_extension = make_shared_ptr<ArrowTypeExtensionData>(type->GetDuckType());
}

ArrowTypeExtension() [3/6]

duckdb::ArrowTypeExtension::ArrowTypeExtension	(	string	extension_name,
		string	arrow_format,
		shared_ptr< ArrowTypeExtensionData >	type
	)

We either have simple extensions where we only return one type.

    : extension_metadata(std::move(extension_name), {}, {}, std::move(arrow_format)), type_extension(std::move(type)) {
}

ArrowTypeExtension() [4/6]

duckdb::ArrowTypeExtension::ArrowTypeExtension	(	string	vendor_name,
		string	type_name,
		string	arrow_format,
		shared_ptr< ArrowTypeExtensionData >	type
	)

    : extension_metadata(ArrowExtensionMetadata::ARROW_EXTENSION_NON_CANONICAL, std::move(vendor_name),
                         std::move(type_name), std::move(arrow_format)),
      type_extension(std::move(type)) {
}

ArrowTypeExtension() [5/6]

duckdb::ArrowTypeExtension::ArrowTypeExtension	(	string	extension_name,
		populate_arrow_schema_t	populate_arrow_schema,
		get_type_t	get_type,
		shared_ptr< ArrowTypeExtensionData >	type
	)

We have complex extensions, where we can return multiple types, hence we must have callback functions to do so.

    : populate_arrow_schema(populate_arrow_schema), get_type(get_type),
      extension_metadata(std::move(extension_name), {}, {}, {}), type_extension(std::move(type)) {
}

ArrowTypeExtension() [6/6]

duckdb::ArrowTypeExtension::ArrowTypeExtension	(	string	vendor_name,
		string	type_name,
		populate_arrow_schema_t	populate_arrow_schema,
		get_type_t	get_type,
		shared_ptr< ArrowTypeExtensionData >	type,
		cast_arrow_duck_t	arrow_to_duckdb,
		cast_duck_arrow_t	duckdb_to_arrow
	)

    : populate_arrow_schema(populate_arrow_schema), get_type(get_type),
      extension_metadata(ArrowExtensionMetadata::ARROW_EXTENSION_NON_CANONICAL, std::move(vendor_name),
                         std::move(type_name), {}),
      type_extension(std::move(type)) {
    type_extension->arrow_to_duckdb = arrow_to_duckdb;
    type_extension->duckdb_to_arrow = duckdb_to_arrow;
}

Member Function Documentation

GetInfo()

ArrowExtensionMetadata duckdb::ArrowTypeExtension::GetInfo

(

)

const

                                                         {
    return extension_metadata;
}

GetType()

unique_ptr< ArrowType > duckdb::ArrowTypeExtension::GetType	(	ClientContext &	context,
		const ArrowSchema &	schema,
		const ArrowSchemaMetadata &	schema_metadata
	)		const

                                                                                                    {
    if (get_type) {
        return get_type(context, schema, schema_metadata);
    }
    // FIXME: THis is not good
    auto duckdb_type = type_extension->GetDuckDBType();
    return make_uniq<ArrowType>(duckdb_type);
}

GetTypeExtension()

shared_ptr< ArrowTypeExtensionData > duckdb::ArrowTypeExtension::GetTypeExtension

(

)

const

                                                                              {
    return type_extension;
}

GetLogicalTypeId()

LogicalTypeId duckdb::ArrowTypeExtension::GetLogicalTypeId

(

)

const

                                                         {
    return type_extension->GetDuckDBType().id();
}

GetLogicalType()

LogicalType duckdb::ArrowTypeExtension::GetLogicalType

(

)

const

                                                     {
    return type_extension->GetDuckDBType();
}

HasType()

bool duckdb::ArrowTypeExtension::HasType

(

)

const

                                       {
    return type_extension.get() != nullptr;
}

PopulateArrowSchema()

void duckdb::ArrowTypeExtension::PopulateArrowSchema ( DuckDBArrowSchemaHolder &  root_holder, ArrowSchema &  child, const LogicalType &  duckdb_type, ClientContext &  context, const ArrowTypeExtension &  extension  )

static

                                                                                  {
    if (extension.populate_arrow_schema) {
        extension.populate_arrow_schema(root_holder, child, duckdb_type, context, extension);
        return;
    }
 
    auto format = make_unsafe_uniq_array<char>(extension.extension_metadata.GetArrowFormat().size() + 1);
    idx_t i = 0;
    for (const auto &c : extension.extension_metadata.GetArrowFormat()) {
        format[i++] = c;
    }
    format[i++] = '\0';
    // We do the default way of populating the schema
    root_holder.extension_format.emplace_back(std::move(format));
 
    child.format = root_holder.extension_format.back().get();
    ArrowSchemaMetadata schema_metadata;
    if (extension.extension_metadata.IsCanonical()) {
        schema_metadata = ArrowSchemaMetadata::ArrowCanonicalType(extension.extension_metadata.GetExtensionName());
    } else {
        schema_metadata = ArrowSchemaMetadata::NonCanonicalType(extension.extension_metadata.GetTypeName(),
                                                                extension.extension_metadata.GetVendorName());
    }
    root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
    child.metadata = root_holder.metadata_info.back().get();
}

---

The documentation for this class was generated from the following files:

• external/duckdb/duckdb.hpp
• external/duckdb/duckdb.cpp