Method executeMap

src/Functions/array/arrayElement.cpp:952–1047

}

ColumnPtr FunctionArrayElement::executeMap(
    const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count, ColumnPtr index_null_map_col) const
{
    const auto * col_map = checkAndGetColumn<ColumnMap>(arguments[0].column.get());
    const auto * col_const_map = checkAndGetColumnConst<ColumnMap>(arguments[0].column.get());
    const DataTypeMap * map_type = checkAndGetDataType<DataTypeMap>(arguments[0].type.get());
    if ((!col_map && !col_const_map) || !map_type)
        return nullptr;

    if (col_const_map)
        col_map = typeid_cast<const ColumnMap *>(&col_const_map->getDataColumn());

    const auto & nested_column = col_map->getNestedColumn();
    const auto & keys_data = col_map->getNestedData().getColumn(0);
    const auto & values_data = col_map->getNestedData().getColumn(1);
    const auto & offsets = nested_column.getOffsets();

    /// At first step calculate indices in array of values for requested keys.
    auto indices_column = DataTypeNumber<UInt64>().createColumn();
    indices_column->reserve(input_rows_count);
    auto & indices_data = assert_cast<ColumnVector<UInt64> &>(*indices_column).getData();

    bool executed = false;
    if (!isColumnConst(*arguments[1].column))
    {
        executed = matchKeyToIndexNumber(keys_data, offsets, !!col_const_map, *arguments[1].column, indices_data)
            || matchKeyToIndexString(keys_data, offsets, !!col_const_map, *arguments[1].column, indices_data);
    }
    else
    {
        Field index = (*arguments[1].column)[0];

        /// try convert const index to right type
        auto index_lit = std::make_shared<ASTLiteral>(index);
        Field key_field = tryConvertToMapKeyField(map_type->getKeyType(), index_lit->getColumnName());
        if (!key_field.isNull())
            index = key_field;

        executed = matchKeyToIndexNumberConst(keys_data, offsets, index, indices_data)
            || matchKeyToIndexStringConst(keys_data, offsets, index, indices_data);
    }

    if (!executed)
        throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
            "Illegal types of arguments: {}, {} for function {}",
            arguments[0].type->getName(), arguments[1].type->getName(), getName());

    ColumnPtr values_array_nested = values_data.getPtr();
    DataTypePtr result_value_type = map_type->getValueType();

    // TODO(shiyuze): Map can be nested in Map but cannot wrapped in Nullable
    if (is_mysql_dialect && result_type->isNullable())
    {
        /// In MYSQL dialect type, non-exists indices will return Null, so we need to wrap
        /// new arguments in nullable
        values_array_nested = makeNullable(values_array_nested);
        result_value_type = makeNullable(result_value_type);
    }