for the last year I replied 3 times with a silly snippet:
```
SELECT
    [2, 3, 4] AS x,
    pow(2, arraySum(i -> log2(i), x)) AS arrayProduct
┌─x───────┬─arrayProduct─┐
│ [2,3,4] │           24 │
└─────────┴──────────────┘
```

I think we need a function to multiply elements of an array.
using DecimalReturnType = ArrayAggregateResult<typename DataType::FieldType, aggregate_operation>;
                UInt32 scale = getDecimalScale(*expression_return);
                result = std::make_shared<DataTypeDecimal<DecimalReturnType>>(DecimalUtils::max_precision<DecimalReturnType>, scale);
                return true;
            }
            return false;
        };
        if (!callOnIndexAndDataType<void>(expression_return->getTypeId(), call))
        {
            throw Exception(
                "array aggregation function cannot be performed on type " + expression_return->getName(),
                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
        }
        return result;
    }
    template <typename Element>
    static NO_SANITIZE_UNDEFINED bool executeType(const ColumnPtr & mapped, const ColumnArray::Offsets & offsets, ColumnPtr & res_ptr)
    {
        using Result = ArrayAggregateResult<Element, aggregate_operation>;
        using ColVecType = std::conditional_t<IsDecimalNumber<Element>, ColumnDecimal<Element>, ColumnVector<Element>>;
        using ColVecResult = std::conditional_t<IsDecimalNumber<Result>, ColumnDecimal<Result>, ColumnVector<Result>>;
        
        
        static constexpr bool is_average_operation = aggregate_operation == AggregateOperation::average;
        using SummAggregationType = ArrayAggregateResult<Element, AggregateOperation::sum>;
        using AggregationType = std::conditional_t<is_average_operation, SummAggregationType, Result>;
        const ColVecType * column = checkAndGetColumn<ColVecType>(&*mapped);
        
        if (!column)
        {