duckdb::ExtraTypeInfo Struct Reference

Inheritance diagram for duckdb::ExtraTypeInfo:

Collaboration diagram for duckdb::ExtraTypeInfo:

Public Member Functions
	ExtraTypeInfo (ExtraTypeInfoType type)
	ExtraTypeInfo (ExtraTypeInfoType type, string alias)
bool	Equals (ExtraTypeInfo *other_p) const
virtual void	Serialize (Serializer &serializer) const
virtual shared_ptr< ExtraTypeInfo >	Copy () const
virtual shared_ptr< ExtraTypeInfo >	DeepCopy () const
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static shared_ptr< ExtraTypeInfo >	Deserialize (Deserializer &source)

Public Attributes
ExtraTypeInfoType	type
string	alias
unique_ptr< ExtensionTypeInfo >	extension_info

Protected Member Functions
	ExtraTypeInfo (const ExtraTypeInfo &other)
ExtraTypeInfo &	operator= (const ExtraTypeInfo &other)
virtual bool	EqualsInternal (ExtraTypeInfo *other_p) const

Constructor & Destructor Documentation

ExtraTypeInfo() [1/3]

duckdb::ExtraTypeInfo::ExtraTypeInfo ( ExtraTypeInfoType  type )

explicit

                                                   : type(type) {
}

ExtraTypeInfo() [2/3]

duckdb::ExtraTypeInfo::ExtraTypeInfo ( ExtraTypeInfoType  type, string  alias  )

explicit

                                                                 : type(type), alias(std::move(alias)) {
}

~ExtraTypeInfo()

duckdb::ExtraTypeInfo::~ExtraTypeInfo ( )

virtual

                              {
}

ExtraTypeInfo() [3/3]

duckdb::ExtraTypeInfo::ExtraTypeInfo ( const ExtraTypeInfo &  other )

protected

                                                       : type(other.type), alias(other.alias) {
    if (other.extension_info) {
        extension_info = make_uniq<ExtensionTypeInfo>(*other.extension_info);
    }
}

Member Function Documentation

operator=()

ExtraTypeInfo & duckdb::ExtraTypeInfo::operator= ( const ExtraTypeInfo &  other )

protected

                                                                  {
    type = other.type;
    alias = other.alias;
    if (other.extension_info) {
        extension_info = make_uniq<ExtensionTypeInfo>(*other.extension_info);
    }
    return *this;
}

Equals()

bool duckdb::ExtraTypeInfo::Equals

(

ExtraTypeInfo *

other_p

)

const

We only need to compare aliases when both types have them in this case

                                                       {
    if (type == ExtraTypeInfoType::INVALID_TYPE_INFO || type == ExtraTypeInfoType::STRING_TYPE_INFO ||
        type == ExtraTypeInfoType::GENERIC_TYPE_INFO) {
        if (!other_p) {
            if (!alias.empty()) {
                return false;
            }
            if (extension_info) {
                return false;
            }
            return true;
        }
        if (alias != other_p->alias) {
            return false;
        }
        if (!ExtensionTypeInfo::Equals(extension_info, other_p->extension_info)) {
            return false;
        }
        return true;
    }
    if (!other_p) {
        return false;
    }
    if (type != other_p->type) {
        return false;
    }
    if (alias != other_p->alias) {
        return false;
    }
    if (!ExtensionTypeInfo::Equals(extension_info, other_p->extension_info)) {
        return false;
    }
    return EqualsInternal(other_p);
}

Copy()

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

virtual

                                                    {
    return shared_ptr<ExtraTypeInfo>(new ExtraTypeInfo(*this));
}

DeepCopy()

shared_ptr< ExtraTypeInfo > duckdb::ExtraTypeInfo::DeepCopy ( ) const

virtual

                                                        {
    return Copy();
}

Cast() [1/2]

template<class TARGET >

TARGET & duckdb::ExtraTypeInfo::Cast ( )

inline

                   {
        DynamicCastCheck<TARGET>(this);
        return reinterpret_cast<TARGET &>(*this);
    }

Cast() [2/2]

template<class TARGET >

const TARGET & duckdb::ExtraTypeInfo::Cast ( ) const

inline

                               {
        DynamicCastCheck<TARGET>(this);
        return reinterpret_cast<const TARGET &>(*this);
    }

EqualsInternal()

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

protectedvirtual

                                                               {
    // Do nothing
    return true;
}

---

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

• external/duckdb/duckdb.cpp