duckdb::EnumTypeInfo Struct Reference

Inheritance diagram for duckdb::EnumTypeInfo:

Collaboration diagram for duckdb::EnumTypeInfo:

Public Member Functions
	EnumTypeInfo (Vector &values_insert_order_p, idx_t dict_size_p)
	EnumTypeInfo (const EnumTypeInfo &)=delete
EnumTypeInfo &	operator= (const EnumTypeInfo &)=delete
const EnumDictType &	GetEnumDictType () const
const Vector &	GetValuesInsertOrder () const
const idx_t &	GetDictSize () const
void	Serialize (Serializer &serializer) const override
shared_ptr< ExtraTypeInfo >	Copy () const override
Public Member Functions inherited from duckdb::ExtraTypeInfo
	ExtraTypeInfo (ExtraTypeInfoType type)
	ExtraTypeInfo (ExtraTypeInfoType type, string alias)
bool	Equals (ExtraTypeInfo *other_p) const
virtual shared_ptr< ExtraTypeInfo >	DeepCopy () const
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static PhysicalType	DictType (idx_t size)
static LogicalType	CreateType (Vector &ordered_data, idx_t size)
static shared_ptr< ExtraTypeInfo >	Deserialize (Deserializer &source)
Static Public Member Functions inherited from duckdb::ExtraTypeInfo
static shared_ptr< ExtraTypeInfo >	Deserialize (Deserializer &source)

Protected Member Functions
bool	EqualsInternal (ExtraTypeInfo *other_p) const override
Protected Member Functions inherited from duckdb::ExtraTypeInfo
	ExtraTypeInfo (const ExtraTypeInfo &other)
ExtraTypeInfo &	operator= (const ExtraTypeInfo &other)

Protected Attributes
Vector	values_insert_order

Private Attributes
EnumDictType	dict_type
idx_t	dict_size

Additional Inherited Members
Public Attributes inherited from duckdb::ExtraTypeInfo
ExtraTypeInfoType	type
string	alias
unique_ptr< ExtensionTypeInfo >	extension_info

Constructor & Destructor Documentation

EnumTypeInfo()

duckdb::EnumTypeInfo::EnumTypeInfo ( Vector &  values_insert_order_p, idx_t  dict_size_p  )

explicit

    : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), values_insert_order(values_insert_order_p),
      dict_type(EnumDictType::VECTOR_DICT), dict_size(dict_size_p) {
}

Member Function Documentation

GetEnumDictType()

const EnumDictType & duckdb::EnumTypeInfo::GetEnumDictType

(

)

const

                                                        {
    return dict_type;
}

GetValuesInsertOrder()

const Vector & duckdb::EnumTypeInfo::GetValuesInsertOrder

(

)

const

                                                       {
    return values_insert_order;
}

GetDictSize()

const idx_t & duckdb::EnumTypeInfo::GetDictSize

(

)

const

                                             {
    return dict_size;
}

DictType()

PhysicalType duckdb::EnumTypeInfo::DictType ( idx_t  size )

static

                                              {
    if (size <= NumericLimits<uint8_t>::Maximum()) {
        return PhysicalType::UINT8;
    } else if (size <= NumericLimits<uint16_t>::Maximum()) {
        return PhysicalType::UINT16;
    } else if (size <= NumericLimits<uint32_t>::Maximum()) {
        return PhysicalType::UINT32;
    } else {
        throw InternalException("Enum size must be lower than " + std::to_string(NumericLimits<uint32_t>::Maximum()));
    }
}

CreateType()

LogicalType duckdb::EnumTypeInfo::CreateType ( Vector &  ordered_data, idx_t  size  )

static

                                                                     {
    // Generate EnumTypeInfo
    shared_ptr<ExtraTypeInfo> info;
    auto enum_internal_type = EnumTypeInfo::DictType(size);
    switch (enum_internal_type) {
    case PhysicalType::UINT8:
        info = make_shared_ptr<EnumTypeInfoTemplated<uint8_t>>(ordered_data, size);
        break;
    case PhysicalType::UINT16:
        info = make_shared_ptr<EnumTypeInfoTemplated<uint16_t>>(ordered_data, size);
        break;
    case PhysicalType::UINT32:
        info = make_shared_ptr<EnumTypeInfoTemplated<uint32_t>>(ordered_data, size);
        break;
    default:
        throw InternalException("Invalid Physical Type for ENUMs");
    }
    // Generate Actual Enum Type
    return LogicalType(LogicalTypeId::ENUM, info);
}

Serialize()

void duckdb::EnumTypeInfo::Serialize ( Serializer &  serializer ) const

overridevirtual

Reimplemented from duckdb::ExtraTypeInfo.

                                                         {
    ExtraTypeInfo::Serialize(serializer);
 
    // Enums are special in that we serialize their values as a list instead of dumping the whole vector
    auto strings = FlatVector::GetData<string_t>(values_insert_order);
    serializer.WriteProperty(200, "values_count", dict_size);
    serializer.WriteList(201, "values", dict_size,
                         [&](Serializer::List &list, idx_t i) { list.WriteElement(strings[i]); });
}

Deserialize()

shared_ptr< ExtraTypeInfo > duckdb::EnumTypeInfo::Deserialize ( Deserializer &  source )

static

                                                                              {
    auto values_count = deserializer.ReadProperty<idx_t>(200, "values_count");
    auto enum_internal_type = EnumTypeInfo::DictType(values_count);
    switch (enum_internal_type) {
    case PhysicalType::UINT8:
        return EnumTypeInfoTemplated<uint8_t>::Deserialize(deserializer, NumericCast<uint32_t>(values_count));
    case PhysicalType::UINT16:
        return EnumTypeInfoTemplated<uint16_t>::Deserialize(deserializer, NumericCast<uint32_t>(values_count));
    case PhysicalType::UINT32:
        return EnumTypeInfoTemplated<uint32_t>::Deserialize(deserializer, NumericCast<uint32_t>(values_count));
    default:
        throw InternalException("Invalid Physical Type for ENUMs");
    }
}

Copy()

shared_ptr< ExtraTypeInfo > duckdb::EnumTypeInfo::Copy ( ) const

overridevirtual

Reimplemented from duckdb::ExtraTypeInfo.

                                                   {
    Vector values_insert_order_copy(LogicalType::VARCHAR, false, false, 0);
    values_insert_order_copy.Reference(values_insert_order);
    return make_shared_ptr<EnumTypeInfo>(values_insert_order_copy, dict_size);
}

EqualsInternal()

bool duckdb::EnumTypeInfo::EqualsInternal ( ExtraTypeInfo *  other_p ) const

overrideprotectedvirtual

Reimplemented from duckdb::ExtraTypeInfo.

                                                              {
    auto &other = other_p->Cast<EnumTypeInfo>();
    if (dict_type != other.dict_type) {
        return false;
    }
    D_ASSERT(dict_type == EnumDictType::VECTOR_DICT);
    // We must check if both enums have the same size
    if (other.dict_size != dict_size) {
        return false;
    }
    auto other_vector_ptr = FlatVector::GetData<string_t>(other.values_insert_order);
    auto this_vector_ptr = FlatVector::GetData<string_t>(values_insert_order);
 
    // Now we must check if all strings are the same
    for (idx_t i = 0; i < dict_size; i++) {
        if (!Equals::Operation(other_vector_ptr[i], this_vector_ptr[i])) {
            return false;
        }
    }
    return true;
}

---

The documentation for this struct was generated from the following file:

• external/duckdb/duckdb.cpp