```
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] │
└───────────────┴─────────────────────────────┴─────┴─────┴─────┘
```


ColumnWithTypeAndName array_of_tuple_section;
        array_of_tuple_section.column = ColumnArray::create(tuple_columns[i], col_array->getOffsetsPtr());
        array_of_tuple_section.type = std::make_shared<DataTypeArray>(tuple_types[i]);
        temporary_results[0] = array_of_tuple_section;
        auto type = getReturnTypeImpl({temporary_results[0].type, temporary_results[1].type});
        auto col = executeImpl(temporary_results, type, input_rows_count);
        result_tuple_columns[i] = std::move(col);
    }
    return ColumnTuple::create(result_tuple_columns);
}
namespace
{
template<typename DataColumn, typename IndexColumn>
struct MatcherString
{
    const DataColumn & data;
    const IndexColumn & index;
    bool match(size_t row_data, size_t row_index) const
    {
        auto data_ref = data.getDataAt(row_data);
        auto index_ref = index.getDataAt(row_index);
        return memequalSmallAllowOverflow15(index_ref.data, index_ref.size, data_ref.data, data_ref.size);
    }
};
template<typename DataColumn>
struct MatcherStringConst
{
    const DataColumn & data;
    const String & index;
    bool match(size_t row_data, size_t ) const