duckdb::UnboundTypeInfo Struct Reference

Inheritance diagram for duckdb::UnboundTypeInfo:

Collaboration diagram for duckdb::UnboundTypeInfo:

Public Member Functions
	UnboundTypeInfo (unique_ptr< ParsedExpression > expr_p)
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 shared_ptr< ExtraTypeInfo >	Deserialize (Deserializer &source)
Static Public Member Functions inherited from duckdb::ExtraTypeInfo
static shared_ptr< ExtraTypeInfo >	Deserialize (Deserializer &source)

Public Attributes
unique_ptr< ParsedExpression >	expr
Public Attributes inherited from duckdb::ExtraTypeInfo
ExtraTypeInfoType	type
string	alias
unique_ptr< ExtensionTypeInfo >	extension_info

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)

Constructor & Destructor Documentation

UnboundTypeInfo() [1/2]

duckdb::UnboundTypeInfo::UnboundTypeInfo ( unique_ptr< ParsedExpression >  expr_p )

explicit

    : ExtraTypeInfo(ExtraTypeInfoType::UNBOUND_TYPE_INFO), expr(std::move(expr_p)) {
}

UnboundTypeInfo() [2/2]

duckdb::UnboundTypeInfo::UnboundTypeInfo ( )

private

                                 : ExtraTypeInfo(ExtraTypeInfoType::UNBOUND_TYPE_INFO) {
}

Member Function Documentation

Serialize()

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

overridevirtual

Reimplemented from duckdb::ExtraTypeInfo.

                                                            {
    ExtraTypeInfo::Serialize(serializer);
 
    if (serializer.ShouldSerialize(7)) {
        serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(204, "expr", expr);
        return;
    }
 
    // Try to write this as an old "USER" type, if possible
    if (expr->type != ExpressionType::TYPE) {
        throw SerializationException(
            "Cannot serialize non-type type expression when targeting database storage version '%s'",
            serializer.GetOptions().serialization_compatibility.duckdb_version);
    }
 
    auto &type_expr = expr->Cast<TypeExpression>();
    serializer.WritePropertyWithDefault<string>(200, "name", type_expr.GetTypeName());
    serializer.WritePropertyWithDefault<string>(201, "catalog", type_expr.GetCatalog());
    serializer.WritePropertyWithDefault<string>(202, "schema", type_expr.GetSchema());
 
    // Try to write the user type mods too
    vector<Value> user_type_mods;
    for (auto &param : type_expr.GetChildren()) {
        if (param->type != ExpressionType::VALUE_CONSTANT) {
            throw SerializationException(
                "Cannot serialize non-constant type parameter when targeting serialization version %s",
                serializer.GetOptions().serialization_compatibility.duckdb_version);
        }
 
        auto &const_expr = param->Cast<ConstantExpression>();
        user_type_mods.push_back(const_expr.value);
    }
 
    serializer.WritePropertyWithDefault<vector<Value>>(203, "user_type_modifiers", user_type_mods);
}

Deserialize()

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

static

                                                                                 {
    auto result = duckdb::shared_ptr<UnboundTypeInfo>(new UnboundTypeInfo());
 
    deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(204, "expr", result->expr);
 
    if (!result->expr) {
        // This is a legacy "USER" type
        string name;
        deserializer.ReadPropertyWithDefault<string>(200, "name", name);
        string catalog;
        deserializer.ReadPropertyWithDefault<string>(201, "catalog", catalog);
        string schema;
        deserializer.ReadPropertyWithDefault<string>(202, "schema", schema);
 
        vector<unique_ptr<ParsedExpression>> user_type_mods;
        auto mods = deserializer.ReadPropertyWithDefault<vector<Value>>(203, "user_type_modifiers");
        for (auto &mod : mods) {
            user_type_mods.push_back(make_uniq_base<ParsedExpression, ConstantExpression>(mod));
        }
 
        result->expr = make_uniq<TypeExpression>(catalog, schema, name, std::move(user_type_mods));
    }
 
    return std::move(result);
}

Copy()

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

overridevirtual

Reimplemented from duckdb::ExtraTypeInfo.

                                                      {
    return make_shared_ptr<UnboundTypeInfo>(expr->Copy());
}

EqualsInternal()

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

overrideprotectedvirtual

Reimplemented from duckdb::ExtraTypeInfo.

                                                                 {
    auto &other = other_p->Cast<UnboundTypeInfo>();
    if (!expr->Equals(*other.expr)) {
        return false;
    }
    return true;
}

---

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

• external/duckdb/duckdb.cpp