duckdb::ExtensionTypeInfo Struct Reference

Collaboration diagram for duckdb::ExtensionTypeInfo:

Public Member Functions
void	Serialize (Serializer &serializer) const

Static Public Member Functions
static unique_ptr< ExtensionTypeInfo >	Deserialize (Deserializer &source)
static bool	Equals (optional_ptr< ExtensionTypeInfo > rhs, optional_ptr< ExtensionTypeInfo > lhs)

Public Attributes
vector< LogicalTypeModifier >	modifiers
unordered_map< string, Value >	properties

Member Function Documentation

Equals()

bool duckdb::ExtensionTypeInfo::Equals ( optional_ptr< ExtensionTypeInfo >  rhs, optional_ptr< ExtensionTypeInfo >  lhs  )

static

                                                                                                       {
    // Either both are null, or both are the same, so they are equal
    if (lhs.get() == rhs.get()) {
        return true;
    }
    // If one is null, then we cant compare them
    if (lhs == nullptr || rhs == nullptr) {
        return true;
    }
 
    // Both are not null, so we can compare them
    D_ASSERT(lhs != nullptr && rhs != nullptr);
 
    // Compare modifiers
    const auto &lhs_mods = lhs->modifiers;
    const auto &rhs_mods = rhs->modifiers;
    const auto common_mods = MinValue(lhs_mods.size(), rhs_mods.size());
    for (idx_t i = 0; i < common_mods; i++) {
        // If the types are not strictly equal, they are not equal
        auto &lhs_val = lhs_mods[i].value;
        auto &rhs_val = rhs_mods[i].value;
 
        if (lhs_val.type() != rhs_val.type()) {
            return false;
        }
 
        // If both are null, its fine
        if (lhs_val.IsNull() && rhs_val.IsNull()) {
            continue;
        }
 
        // If one is null, the other must be null too
        if (lhs_val.IsNull() != rhs_val.IsNull()) {
            return false;
        }
 
        if (lhs_val != rhs_val) {
            return false;
        }
    }
 
    // Properties are optional, so only compare those present in both
    const auto &lhs_props = lhs->properties;
    const auto &rhs_props = rhs->properties;
 
    for (const auto &kv : lhs_props) {
        auto it = rhs_props.find(kv.first);
        if (it == rhs_props.end()) {
            // Continue
            continue;
        }
        if (kv.second != it->second) {
            // Mismatch!
            return false;
        }
    }
 
    // All ok!
    return true;
}

---

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

• external/duckdb/duckdb.cpp