Method getDynamicSubcolumnData

src/DataTypes/DataTypeDynamic.cpp:890–1056

}

std::unique_ptr<IDataType::SubstreamData> DataTypeDynamic::getDynamicSubcolumnData(std::string_view subcolumn_name, const SubstreamData & data, size_t initial_array_level, bool throw_if_null) const
{
    auto [type_subcolumn_name, subcolumn_nested_name] = splitSubcolumnName(subcolumn_name);
    /// Check if requested subcolumn is a valid data type.
    auto subcolumn_type = DataTypeFactory::instance().tryGet(String(type_subcolumn_name));
    if (!subcolumn_type)
    {
        if (throw_if_null)
            throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Dynamic type doesn't have subcolumn '{}'", type_subcolumn_name);
        return nullptr;
    }

    const auto & dynamic_serialization = assert_cast<const SerializationDynamic &>(*removeNamedSerialization(data.serialization));
    auto subcolumn_serialization = dynamic_serialization.createSerializationForType(subcolumn_type);
    std::unique_ptr<SubstreamData> res = std::make_unique<SubstreamData>(subcolumn_serialization);
    res->type = subcolumn_type;
    std::optional<ColumnVariant::Discriminator> discriminator;
    ColumnPtr null_map_for_variant_from_shared_variant;
    if (data.column)
    {
        /// If column was provided, we should extract subcolumn from Dynamic column.
        const auto & dynamic_column = assert_cast<const ColumnDynamic &>(*data.column);
        const auto & variant_info = dynamic_column.getVariantInfo();
        const auto & variant_column = dynamic_column.getVariantColumn();
        const auto & shared_variant = dynamic_column.getSharedVariant();
        /// Check if provided Dynamic column has subcolumn of this type.
        String subcolumn_type_name = subcolumn_type->getName();
        auto it = variant_info.variant_name_to_discriminator.find(subcolumn_type_name);
        if (it != variant_info.variant_name_to_discriminator.end())
        {
            discriminator = it->second;
            res->column = variant_column.getVariantPtrByGlobalDiscriminator(*discriminator);
        }
        /// Otherwise if there is data in shared variant try to find requested type there.
        else if (!shared_variant.empty())
        {
            /// Create null map for resulting subcolumn to make it Nullable.
            auto null_map_column = ColumnUInt8::create();
            NullMap & null_map = assert_cast<ColumnUInt8 &>(*null_map_column).getData();
            null_map.reserve(variant_column.size());
            auto subcolumn = subcolumn_type->createColumn();
            auto shared_variant_local_discr = variant_column.localDiscriminatorByGlobal(dynamic_column.getSharedVariantDiscriminator());
            const auto & local_discriminators = variant_column.getLocalDiscriminators();
            const auto & offsets = variant_column.getOffsets();
            const FormatSettings format_settings;
            for (size_t i = 0; i != local_discriminators.size(); ++i)
            {
                if (local_discriminators[i] == shared_variant_local_discr)
                {
                    auto value = shared_variant.getDataAt(offsets[i]);
                    ReadBufferFromMemory buf(value);
                    auto type = decodeDataType(buf);
                    if (type->getName() == subcolumn_type_name)
                    {
                        subcolumn_serialization->deserializeBinary(*subcolumn, buf, format_settings);
                        null_map.push_back(static_cast<UInt8>(0));
                    }
                    else