`SELECT * FROM values('x Decimal256(0)', (1))`

```
Code: 53. DB::Exception: Type mismatch in IN or VALUES section. Expected: Decimal(76, 0). Got: UInt64. (TYPE_MISMATCH)
```
const auto & key = map_entry[0];
                const auto & value = map_entry[1];
                Tuple updated_entry(2);
                updated_entry[0] = convertFieldToType(key, key_type);
                if (updated_entry[0].isNull() && !key_type.isNullable())
                    have_unconvertible_element = true;
                updated_entry[1] = convertFieldToType(value, value_type);
                if (updated_entry[1].isNull() && !value_type.isNullable())
                    have_unconvertible_element = true;
                res[i] = updated_entry;
            }
            return have_unconvertible_element ? Field(Null()) : Field(res);
        }
    }
    else if (const DataTypeAggregateFunction * agg_func_type = typeid_cast<const DataTypeAggregateFunction *>(&type))
    {
        if (src.getType() != Field::Types::AggregateFunctionState)
            throw Exception(ErrorCodes::TYPE_MISMATCH,
                "Cannot convert {} to {}",
                src.getTypeName(), agg_func_type->getName());
        const auto & name = src.get<AggregateFunctionStateData>().name;
        if (agg_func_type->getName() != name)
            throw Exception("Cannot convert " + name + " to " + agg_func_type->getName(), ErrorCodes::TYPE_MISMATCH);
        return src;
    }
    else if (isObject(type))
    {
        const auto * from_type_tuple = typeid_cast<const DataTypeTuple *>(from_type_hint);
        if (src.getType() == Field::Types::Tuple && from_type_tuple && from_type_tuple->haveExplicitNames())
        {