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


bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & ) const override { return false; }
    size_t getNumberOfArguments() const override { return 2; }
    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override;
private:
    ColumnPtr perform(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type,
                      ArrayImpl::NullMapBuilder & builder, size_t input_rows_count) const;
    template <typename DataType>
    static ColumnPtr executeNumberConst(const ColumnsWithTypeAndName & arguments, const Field & index, ArrayImpl::NullMapBuilder & builder);
    template <typename IndexType, typename DataType>
    static ColumnPtr executeNumber(const ColumnsWithTypeAndName & arguments, const PaddedPODArray<IndexType> & indices, ArrayImpl::NullMapBuilder & builder);
    static ColumnPtr executeStringConst(const ColumnsWithTypeAndName & arguments, const Field & index, ArrayImpl::NullMapBuilder & builder);
    template <typename IndexType>
    static ColumnPtr executeString(const ColumnsWithTypeAndName & arguments, const PaddedPODArray<IndexType> & indices, ArrayImpl::NullMapBuilder & builder);
    static ColumnPtr executeGenericConst(const ColumnsWithTypeAndName & arguments, const Field & index, ArrayImpl::NullMapBuilder & builder);
    template <typename IndexType>
    static ColumnPtr executeGeneric(const ColumnsWithTypeAndName & arguments, const PaddedPODArray<IndexType> & indices, ArrayImpl::NullMapBuilder & builder);
    template <typename IndexType>
    static ColumnPtr executeConst(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type,
                                  const PaddedPODArray <IndexType> & indices, ArrayImpl::NullMapBuilder & builder,
                                  size_t input_rows_count);
    template <typename IndexType>
    ColumnPtr executeArgument(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type,
                              ArrayImpl::NullMapBuilder & builder, size_t input_rows_count) const;
    /** For a tuple array, the function is evaluated component-wise for each element of the tuple.
      */