```
SELECT version()
─version()─┐
│ 21.8.5.7  │
└───────────┘
```
We have a request, as a result of which we get an array.
When getting an item using a computed value, there is no value
```
SELECT
    arrayMap(x -> x, [[1], [2], [3]]) AS x,
    toTypeName(x),
    x[3 - 2] AS y,
    x[toInt64(1)] AS yy,
    x[toUInt8(1)] AS yyy

┌─x─────────────┬─toTypeName(arrayMap(lambda(tuple(x), x), [[1], [2], [3]]))─┬─y──┬─yy─┬─yyy─┐
│ [[1],[2],[3]] │ Array(Array(UInt8))                                        │ [] │ [] │ [1] │
└───────────────┴────────────────────────────────────────────────────────────┴────┴────┴─────┘
```
However, when the array is explicitly specified, the value is present.
The types are the same.
```
SELECT
    [[1], [2], [3]] AS x,
    toTypeName(x),
    x[3 - 2] AS y,
    x[toInt64(1)] AS yy,
    x[toInt8(1)] AS yyy

┌─x─────────────┬─toTypeName([[1], [2], [3]])─┬─y───┬─yy──┬─yyy─┐
│ [[1],[2],[3]] │ Array(Array(UInt8))         │ [1] │ [1] │ [1] │
└───────────────┴─────────────────────────────┴─────┴─────┴─────┘
```


const IColumn & data, const Offsets & offsets, bool is_key_const,
    const IColumn & index, PaddedPODArray<UInt64> & matched_idxs)
{
    return castColumnString(&data, [&](const auto & data_column)
    {
        return castColumnString(&index, [&](const auto & index_column)
        {
            using DataColumn = std::decay_t<decltype(data_column)>;
            using IndexColumn = std::decay_t<decltype(index_column)>;
            MatcherString<DataColumn, IndexColumn> matcher{data_column, index_column};
            if (is_key_const)
                executeMatchConstKeyToIndex(index.size(), data.size(), matched_idxs, matcher);
            else
                executeMatchKeyToIndex(offsets, matched_idxs, matcher);
            return true;
        });
    });
}
template <typename FromType, typename ToType>
static constexpr bool areConvertibleTypes =
    std::is_same_v<FromType, ToType>
        || (is_integer<FromType> && is_integer<ToType>
            && std::is_convertible_v<FromType, ToType>);
template <typename F>
static bool castColumnNumeric(const IColumn * column, F && f)