Function getLeastCommonTypeForObject

src/DataTypes/ObjectUtils.cpp:317–369

}

static DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguous_paths)
{
    /// Types of subcolumns by path from all tuples.
    std::unordered_map<PathInData, DataTypes, PathInData::Hash> subcolumns_types;

    /// First we flatten tuples, then get common type for paths
    /// and finally unflatten paths and create new tuple type.
    for (const auto & type : types)
    {
        const auto * type_tuple = typeid_cast<const DataTypeTuple *>(type.get());
        if (!type_tuple)
            throw Exception(ErrorCodes::LOGICAL_ERROR,
                "Least common type for object can be deduced only from tuples, but {} given", type->getName());

        auto [tuple_paths, tuple_types] = flattenTuple(type);
        assert(tuple_paths.size() == tuple_types.size());

        for (size_t i = 0; i < tuple_paths.size(); ++i)
            subcolumns_types[tuple_paths[i]].push_back(tuple_types[i]);
    }

    PathsInData tuple_paths;
    DataTypes tuple_types;

    /// Get the least common type for all paths.
    for (const auto & [key, subtypes] : subcolumns_types)
    {
        assert(!subtypes.empty());
        if (key.getPath() == ColumnObject::COLUMN_NAME_DUMMY)
            continue;

        size_t first_dim = getNumberOfDimensions(*subtypes[0]);
        for (size_t i = 1; i < subtypes.size(); ++i)
            if (first_dim != getNumberOfDimensions(*subtypes[i]))
                throw Exception(ErrorCodes::TYPE_MISMATCH,
                    "Uncompatible types of subcolumn '{}': {} and {}",
                    key.getPath(), subtypes[0]->getName(), subtypes[i]->getName());

        tuple_paths.emplace_back(key);
        tuple_types.emplace_back(getLeastSupertypeOrString(subtypes));
    }

    if (tuple_paths.empty())
    {
        tuple_paths.emplace_back(ColumnObject::COLUMN_NAME_DUMMY);
        tuple_types.emplace_back(std::make_shared<DataTypeUInt8>());
    }

    if (check_ambiguous_paths)
        checkObjectHasNoAmbiguousPaths(tuple_paths);

    return unflattenTuple(tuple_paths, tuple_types);
}

static DataTypePtr getLeastCommonTypeForDynamicColumnsImpl(
    const DataTypePtr & type_in_storage, const DataTypes & concrete_types, bool check_ambiguos_paths);