From c3fe8bb026038f3547597c3683a530e53e13e063 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Wed, 16 Aug 2017 20:50:12 +0300
Subject: [PATCH 01/30] added FunctionArrayConcat [#CLICKHOUSE-2090]

---
 dbms/src/Functions/CMakeLists.txt     |   1 +
 dbms/src/Functions/FunctionsArray.cpp | 111 ++++++++++++++++++++++++++
 dbms/src/Functions/FunctionsArray.h   |  19 +++++
 3 files changed, 131 insertions(+)

diff --git a/dbms/src/Functions/CMakeLists.txt b/dbms/src/Functions/CMakeLists.txt
index a0827afdd1e..f726e78883c 100644
--- a/dbms/src/Functions/CMakeLists.txt
+++ b/dbms/src/Functions/CMakeLists.txt
@@ -52,6 +52,7 @@ generate_function_register(Array
   FunctionRange
   FunctionArrayReduce
   FunctionArrayReverse
+  FunctionArrayConcat
 )
 
 
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 6fae2c7e525..4d17e7d20e9 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -7,6 +7,7 @@
 #include <Functions/FunctionsConversion.h>
 #include <Functions/Conditional/getArrayType.h>
 #include <Functions/Conditional/CondException.h>
+#include <Functions/GatherUtils.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/HashTable/ClearableHashMap.h>
 #include <Parsers/ExpressionListParsers.h>
@@ -18,6 +19,7 @@
 #include <Columns/ColumnAggregateFunction.h>
 #include <tuple>
 #include <array>
+#include <iostream>
 
 
 namespace DB
@@ -2876,4 +2878,113 @@ void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & argum
     }
 }
 
+/// Implementation of FunctionArrayConcat.
+
+FunctionPtr FunctionArrayConcat::create(const Context & context)
+{
+    return std::make_shared<FunctionArrayConcat>();
+}
+
+String FunctionArrayConcat::getName() const
+{
+    return name;
+}
+
+DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments) const
+{
+    bool has_nullable = false;
+    DataTypePtr common_type;
+
+    for (size_t i : ext::range(0, arguments.size()))
+    {
+        const auto & argument = arguments[i];
+        auto data_type_array = checkAndGetDataType<DataTypeArray>(argument.get());
+        if (!data_type_array)
+            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
+                            + argument->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+        DataTypePtr nested_type = data_type_array->getNestedType();
+        if (nested_type->isNullable())
+        {
+            has_nullable = true;
+            auto nullable_type = static_cast<const DataTypeNullable *>(nested_type.get());
+            nested_type = nullable_type->getNestedType();
+        }
+
+        if (!common_type)
+            common_type = nested_type;
+        else if (!common_type->equals(*nested_type.get()))
+            throw Exception("Arguments for function " + getName() + " has different nested types: "
+                            + common_type->getName() + " and " + nested_type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+
+    if (has_nullable)
+        common_type = std::make_shared<DataTypeNullable>(common_type);
+
+    return std::make_shared<DataTypeArray>(common_type);
+}
+
+void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+{
+    std::cerr << block.dumpStructure() << std::endl;
+    auto & result_column = block.getByPosition(result).column;
+
+    ColumnPtr column_to_clone_for_result = block.getByPosition(arguments.front()).column;
+    bool is_nullable_result = false;
+    size_t size = 0;
+
+    for (auto argument : arguments)
+    {
+        const auto & argument_column = block.safeGetByPosition(argument).column;
+        auto argument_column_array = typeid_cast<ColumnArray *>(argument_column.get());
+        if (checkColumn<ColumnNullable>(&argument_column_array->getData()))
+        {
+            is_nullable_result = true;
+            column_to_clone_for_result = argument_column;
+            break;
+        }
+        size = argument_column->size();
+    }
+
+    std::vector<ColumnPtr> nullable_columns_holder;
+    std::vector<GenericArraySource> sources;
+
+    for (auto argument : arguments)
+    {
+        auto & argument_column = block.getByPosition(argument).column;
+        auto argument_column_array = typeid_cast<ColumnArray *>(argument_column.get());
+
+        if (is_nullable_result)
+        {
+            if (!checkColumn<ColumnNullable>(&argument_column_array->getData()))
+            {
+                ColumnPtr null_map = std::make_shared<ColumnUInt8>(argument_column_array->getData().size(), 0);
+                argument_column = std::make_shared<ColumnArray>(
+                        std::make_shared<ColumnNullable>(argument_column_array->getDataPtr(), null_map),
+                        argument_column_array->getOffsetsColumn()
+                );
+            }
+            nullable_columns_holder.push_back(argument_column);
+        }
+        sources.emplace_back(static_cast<ColumnArray &>(*argument_column.get()));
+    }
+
+    result_column = column_to_clone_for_result->cloneEmpty();
+    GenericArraySink sink(typeid_cast<ColumnArray &>(*result_column.get()), size);
+
+    while (!sink.isEnd())
+    {
+        for (auto & source : sources)
+        {
+            auto slice = source.getWhole();
+            std::cerr << slice.size << std::endl;
+            writeSlice(slice, sink);
+            source.next();
+        }
+        sink.next();
+        std::cerr << sink.elements.size() << std::endl;
+    }
+    std::cerr << block.dumpStructure() << std::endl;
+}
+
 }
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index e79242e4c9b..1af4df8ca84 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -1406,6 +1406,25 @@ private:
 };
 
 
+class FunctionArrayConcat : public IFunction
+{
+public:
+    static constexpr auto name = "arrayConcat";
+    static FunctionPtr create(const Context & context);
+
+    String getName() const override;
+
+    bool isVariadic() const override { return false; }
+    size_t getNumberOfArguments() const override { return 2; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+};
+
+
 struct NameHas { static constexpr auto name = "has"; };
 struct NameIndexOf { static constexpr auto name = "indexOf"; };
 struct NameCountEqual { static constexpr auto name = "countEqual"; };

From c1479a55946d37b896dda8affbd6f83d5b66e4ad Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 17 Aug 2017 22:33:02 +0300
Subject: [PATCH 02/30] updated GatherUtils [#CLICKHOUSE-2090]

---
 dbms/src/Common/TypeList.h            |  51 ++
 dbms/src/Core/TypeListNumber.h        |  10 +
 dbms/src/Functions/FunctionsArray.cpp | 106 ++--
 dbms/src/Functions/FunctionsArray.h   |   4 +-
 dbms/src/Functions/GatherUtils.h      | 664 ++++++++++++++++++++++++--
 5 files changed, 736 insertions(+), 99 deletions(-)
 create mode 100644 dbms/src/Common/TypeList.h
 create mode 100644 dbms/src/Core/TypeListNumber.h

diff --git a/dbms/src/Common/TypeList.h b/dbms/src/Common/TypeList.h
new file mode 100644
index 00000000000..607f81720c0
--- /dev/null
+++ b/dbms/src/Common/TypeList.h
@@ -0,0 +1,51 @@
+#pragma once
+
+namespace DB
+{
+
+template <typename ... Types>
+struct TypeList;
+
+template <typename Type, typename ... Types>
+struct TypeList<Type, Types...>
+{
+    using Head = Type;
+    using Tail = TypeList<Types ...>;
+};
+
+template<>
+struct TypeList<>
+{
+};
+
+/// Append Type to TypeList
+/// Usage:
+///     using TypeListWithType = typename AppendToTypeList<Type, ConcreteTypeList>::Type;
+template <typename TypeToAppend, typename List, typename ... Types>
+struct AppendToTypeList
+{
+    using Type = typename AppendToTypeList<TypeToAppend, typename List::Tail, Types ..., typename List::Head>::Type;
+};
+
+template <typename TypeToAppend, typename ... Types>
+struct AppendToTypeList<TypeToAppend, TypeList<>, Types ...>
+{
+    using Type = TypeList<TypeToAppend, Types ...>;
+};
+
+/// Apply TypeList as variadic template argument of Class.
+/// Usage:
+///     using ClassWithAppliedTypeList = typename ApplyTypeListForClass<Class, ConcreteTypeList>::Type;
+template <template <typename ...> typename Class, typename List, typename ... Types>
+struct ApplyTypeListForClass
+{
+    using Type = typename ApplyTypeListForClass<Class, typename List::Tail, Types ..., typename List::Head>::Type;
+};
+
+template <template <typename ...> typename Class, typename ... Types>
+struct ApplyTypeListForClass<Class, TypeList<>, Types ...>
+{
+    using Type = Class<Types ...>;
+};
+
+}
diff --git a/dbms/src/Core/TypeListNumber.h b/dbms/src/Core/TypeListNumber.h
new file mode 100644
index 00000000000..db7dcc2e5d0
--- /dev/null
+++ b/dbms/src/Core/TypeListNumber.h
@@ -0,0 +1,10 @@
+#pragma once
+#include <Core/Types.h>
+#include <Common/TypeList.h>
+
+namespace DB
+{
+
+using TypeListNumber = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
+
+}
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 4d17e7d20e9..3e374995afc 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -2892,98 +2892,88 @@ String FunctionArrayConcat::getName() const
 
 DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    bool has_nullable = false;
-    DataTypePtr common_type;
+    if (arguments.empty())
+        throw Exception{"Function array requires at least one argument.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
+    DataTypes nested_types;
+    nested_types.reserve(arguments.size());
     for (size_t i : ext::range(0, arguments.size()))
     {
-        const auto & argument = arguments[i];
-        auto data_type_array = checkAndGetDataType<DataTypeArray>(argument.get());
-        if (!data_type_array)
+        auto argument = arguments[i].get();
+
+        if (auto data_type_array = checkAndGetDataType<DataTypeArray>(argument))
+            nested_types.push_back(data_type_array->getNestedType());
+        else
             throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
                             + argument->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-
-        DataTypePtr nested_type = data_type_array->getNestedType();
-        if (nested_type->isNullable())
-        {
-            has_nullable = true;
-            auto nullable_type = static_cast<const DataTypeNullable *>(nested_type.get());
-            nested_type = nullable_type->getNestedType();
-        }
-
-        if (!common_type)
-            common_type = nested_type;
-        else if (!common_type->equals(*nested_type.get()))
-            throw Exception("Arguments for function " + getName() + " has different nested types: "
-                            + common_type->getName() + " and " + nested_type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
-    if (has_nullable)
-        common_type = std::make_shared<DataTypeNullable>(common_type);
+    if (foundNumericType(nested_types))
+    {
+        /// Since we have found at least one numeric argument, we infer that all
+        /// the arguments are numeric up to nullity. Let's determine the least
+        /// common type.
+        auto enriched_result_type = Conditional::getArrayType(nested_types);
+        return std::make_shared<DataTypeArray>(enriched_result_type);
+    }
+    else
+    {
+        /// Otherwise all the arguments must have the same type up to nullability or nullity.
+        if (!hasArrayIdenticalTypes(nested_types))
+            throw Exception{"Arguments for function " + getName() + " must have same type or behave as number.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
-    return std::make_shared<DataTypeArray>(common_type);
+        return std::make_shared<DataTypeArray>(getArrayElementType(nested_types));
+    }
 }
 
 void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     std::cerr << block.dumpStructure() << std::endl;
     auto & result_column = block.getByPosition(result).column;
+    const DataTypePtr & return_type = block.getByPosition(result).type;
+    result_column = return_type->createColumn();
 
-    ColumnPtr column_to_clone_for_result = block.getByPosition(arguments.front()).column;
-    bool is_nullable_result = false;
     size_t size = 0;
 
     for (auto argument : arguments)
     {
         const auto & argument_column = block.safeGetByPosition(argument).column;
-        auto argument_column_array = typeid_cast<ColumnArray *>(argument_column.get());
-        if (checkColumn<ColumnNullable>(&argument_column_array->getData()))
-        {
-            is_nullable_result = true;
-            column_to_clone_for_result = argument_column;
-            break;
-        }
         size = argument_column->size();
     }
 
-    std::vector<ColumnPtr> nullable_columns_holder;
-    std::vector<GenericArraySource> sources;
+    std::vector<std::unique_ptr<IArraySource>> sources;
 
     for (auto argument : arguments)
     {
-        auto & argument_column = block.getByPosition(argument).column;
-        auto argument_column_array = typeid_cast<ColumnArray *>(argument_column.get());
+        auto argument_column = block.getByPosition(argument).column.get();
+        size_t column_size = argument_column->size();
+        bool is_const = false;
 
-        if (is_nullable_result)
+        if (auto argument_column_const = typeid_cast<ColumnConst *>(argument_column))
         {
-            if (!checkColumn<ColumnNullable>(&argument_column_array->getData()))
-            {
-                ColumnPtr null_map = std::make_shared<ColumnUInt8>(argument_column_array->getData().size(), 0);
-                argument_column = std::make_shared<ColumnArray>(
-                        std::make_shared<ColumnNullable>(argument_column_array->getDataPtr(), null_map),
-                        argument_column_array->getOffsetsColumn()
-                );
-            }
-            nullable_columns_holder.push_back(argument_column);
+            is_const = true;
+            argument_column = &argument_column_const->getDataColumn();
         }
-        sources.emplace_back(static_cast<ColumnArray &>(*argument_column.get()));
+
+        if (auto argument_column_array = typeid_cast<ColumnArray *>(argument_column))
+            sources.emplace_back(createArraySource(*argument_column_array, is_const, column_size));
+        else
+            throw Exception{"Arguments for function " + getName() + " must be arrays.", ErrorCodes::LOGICAL_ERROR};
     }
 
-    result_column = column_to_clone_for_result->cloneEmpty();
-    GenericArraySink sink(typeid_cast<ColumnArray &>(*result_column.get()), size);
+    auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column.get()), size);
+    concat(sources, *sink);
 
-    while (!sink.isEnd())
+    auto array = checkAndGetColumn<ColumnArray>(result_column.get());
+    if (array)
     {
-        for (auto & source : sources)
-        {
-            auto slice = source.getWhole();
-            std::cerr << slice.size << std::endl;
-            writeSlice(slice, sink);
-            source.next();
-        }
-        sink.next();
-        std::cerr << sink.elements.size() << std::endl;
+        auto & offsets = array->getOffsets();
+        std::cerr << offsets.size()  << " " << array->size()<< std::endl;
+        for (auto & val : offsets)
+            std::cerr << val << ' ';
+        std::cerr << std::endl;
     }
+
     std::cerr << block.dumpStructure() << std::endl;
 }
 
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index 1af4df8ca84..60970b733f9 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -1414,8 +1414,8 @@ public:
 
     String getName() const override;
 
-    bool isVariadic() const override { return false; }
-    size_t getNumberOfArguments() const override { return 2; }
+    bool isVariadic() const override { return true; }
+    size_t getNumberOfArguments() const override { return 0; }
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
 
diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index d0f90733c95..bf825c818cc 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -7,13 +7,19 @@
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnFixedString.h>
 #include <Columns/ColumnConst.h>
+#include <Columns/ColumnNullable.h>
 
 #include <Functions/FunctionHelpers.h>
 #include <DataTypes/NumberTraits.h>
 
 #include <Common/typeid_cast.h>
 #include <Common/memcpySmall.h>
+#include <ext/range.h>
+#include <Core/TypeListNumber.h>
 
+#include <DataTypes/DataTypeTraits.h>
+#include <iostream>
+#include <typeindex>
 
 /** These methods are intended for implementation of functions, that
   *  copy ranges from one or more columns to another column.
@@ -36,6 +42,11 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
 template <typename T>
 struct NumericArraySlice
 {
@@ -44,8 +55,24 @@ struct NumericArraySlice
 };
 
 
+struct IArraySource
+{
+    virtual ~IArraySource() {}
+
+    virtual size_t getSizeForReserve() const = 0;
+    virtual const typename ColumnArray::Offsets_t & getOffsets() const = 0;
+    virtual size_t getColumnSize() const = 0;
+    virtual bool isConst() const { return false; }
+    virtual bool isNullable() const { return false; }
+};
+struct IArraySink
+{
+    virtual ~IArraySink() {}
+};
+
+
 template <typename T>
-struct NumericArraySource
+struct NumericArraySource : public IArraySource
 {
     using Slice = NumericArraySlice<T>;
     using Column = ColumnArray;
@@ -77,12 +104,22 @@ struct NumericArraySource
         return row_num;
     }
 
+    const typename ColumnArray::Offsets_t & getOffsets() const
+    {
+        return offsets;
+    }
+
     /// Get size for corresponding call or Sink::reserve to reserve memory for elements.
-    size_t getSizeForReserve() const
+    size_t getSizeForReserve() const override
     {
         return elements.size();
     }
 
+    size_t getColumnSize() const override
+    {
+        return offsets.size();
+    }
+
     Slice getWhole() const
     {
         return {&elements[prev_offset], offsets[row_num] - prev_offset};
@@ -123,7 +160,7 @@ struct NumericArraySource
 
 
 template <typename Base>
-struct ConstSource
+struct ConstSource : public Base
 {
     using Slice = typename Base::Slice;
     using Column = ColumnConst;
@@ -131,10 +168,21 @@ struct ConstSource
     size_t total_rows;
     size_t row_num = 0;
 
-    Base base;
+    /// Base base;
 
-    ConstSource(const ColumnConst & col)
-        : total_rows(col.size()), base(static_cast<const typename Base::Column &>(col.getDataColumn()))
+    /// template <typename ColumnType>
+    explicit ConstSource(const ColumnConst & col)
+        : Base(static_cast<const typename Base::Column &>(col.getDataColumn())), total_rows(col.size())
+    {
+    }
+
+    template <typename ColumnType>
+    ConstSource(const ColumnType & col, size_t total_rows) : Base(col), total_rows(total_rows)
+    {
+    }
+
+    template <typename ColumnType>
+    ConstSource(const ColumnType & col, const ColumnUInt8 & null_map, size_t total_rows) : Base(col, null_map), total_rows(total_rows)
     {
     }
 
@@ -155,33 +203,43 @@ struct ConstSource
 
     size_t getSizeForReserve() const
     {
-        return total_rows * base.getSizeForReserve();
+        return total_rows * Base::getSizeForReserve();
     }
 
-    Slice getWhole() const
+    size_t getColumnSize() const // overrides for IArraySource
     {
-        return base.getWhole();
+        return total_rows;
     }
 
-    Slice getSliceFromLeft(size_t offset) const
+    bool isConst() const // overrides for IArraySource
     {
-        return base.getSliceFromLeft(offset);
+        return true;
     }
 
-    Slice getSliceFromLeft(size_t offset, size_t length) const
-    {
-        return base.getSliceFromLeft(offset, length);
-    }
-
-    Slice getSliceFromRight(size_t offset) const
-    {
-        return base.getSliceFromRight(offset);
-    }
-
-    Slice getSliceFromRight(size_t offset, size_t length) const
-    {
-        return base.getSliceFromRight(offset, length);
-    }
+//    Slice getWhole() const
+//    {
+//        return base.getWhole();
+//    }
+//
+//    Slice getSliceFromLeft(size_t offset) const
+//    {
+//        return base.getSliceFromLeft(offset);
+//    }
+//
+//    Slice getSliceFromLeft(size_t offset, size_t length) const
+//    {
+//        return base.getSliceFromLeft(offset, length);
+//    }
+//
+//    Slice getSliceFromRight(size_t offset) const
+//    {
+//        return base.getSliceFromRight(offset);
+//    }
+//
+//    Slice getSliceFromRight(size_t offset, size_t length) const
+//    {
+//        return base.getSliceFromRight(offset, length);
+//    }
 };
 
 
@@ -336,7 +394,7 @@ struct FixedStringSource
 
 
 template <typename T>
-struct NumericArraySink
+struct NumericArraySink : public IArraySink
 {
     typename ColumnVector<T>::Container_t & elements;
     typename ColumnArray::Offsets_t & offsets;
@@ -499,7 +557,7 @@ struct GenericArraySlice
 };
 
 
-struct GenericArraySource
+struct GenericArraySource : public IArraySource
 {
     using Slice = GenericArraySlice;
     using Column = ColumnArray;
@@ -531,7 +589,17 @@ struct GenericArraySource
         return row_num;
     }
 
-    size_t getSizeForReserve() const
+    const typename ColumnArray::Offsets_t & getOffsets() const
+    {
+        return offsets;
+    }
+
+    size_t getSizeForReserve() const override
+    {
+        return elements.size();
+    }
+
+    size_t getColumnSize() const override
     {
         return elements.size();
     }
@@ -574,7 +642,7 @@ struct GenericArraySource
     }
 };
 
-struct GenericArraySink
+struct GenericArraySink : public IArraySink
 {
     IColumn & elements;
     ColumnArray::Offsets_t & offsets;
@@ -611,6 +679,200 @@ struct GenericArraySink
 };
 
 
+template <typename Slice>
+struct NullableArraySlice : public Slice
+{
+    const UInt8 * null_map;
+
+    NullableArraySlice() {}
+    NullableArraySlice(const Slice & base) : Slice(base) {}
+};
+
+
+template <typename ArraySource>
+struct NullableArraySource : public ArraySource
+{
+    using Slice = NullableArraySlice<typename ArraySource::Slice>;
+    using ArraySource::prev_offset;
+    using ArraySource::row_num;
+    using ArraySource::offsets;
+
+    const ColumnUInt8::Container_t & null_map;
+
+    NullableArraySource(const ColumnArray & arr, const ColumnUInt8 & null_map)
+            : ArraySource(arr), null_map(null_map.getData())
+    {
+    }
+
+    Slice getWhole() const
+    {
+        Slice slice = ArraySource::getWhole();
+        slice.null_map = &null_map[prev_offset];
+        return slice;
+    }
+
+    Slice getSliceFromLeft(size_t offset) const
+    {
+        Slice slice = ArraySource::getSliceFromLeft(offset);
+        if (!slice.size)
+            slice.null_map = &null_map[prev_offset];
+        else
+            slice.null_map = &null_map[prev_offset + offset];
+        return slice;
+    }
+
+    Slice getSliceFromLeft(size_t offset, size_t length) const
+    {
+        Slice slice = ArraySource::getSliceFromLeft(offset, length);
+        if (!slice.size)
+            slice.null_map = &null_map[prev_offset];
+        else
+            slice.null_map = &null_map[prev_offset + offset];
+        return slice;
+    }
+
+    Slice getSliceFromRight(size_t offset) const
+    {
+        Slice slice = ArraySource::getSliceFromRight(offset);
+        if (!slice.size)
+            slice.null_map = &null_map[prev_offset];
+        else
+            slice.null_map = &null_map[offsets[row_num] - offset];
+        return slice;
+    }
+
+    Slice getSliceFromRight(size_t offset, size_t length) const
+    {
+        Slice slice = ArraySource::getSliceFromRight(offset, length);
+        if (!slice.size)
+            slice.null_map = &null_map[prev_offset];
+        else
+            slice.null_map = &null_map[offsets[row_num] - offset];
+        return slice;
+    }
+
+    bool isNullable() const override
+    {
+        return true;
+    }
+};
+
+template <typename ArraySink>
+struct NullableArraySink : public ArraySink
+{
+    ColumnUInt8::Container_t & null_map;
+
+    NullableArraySink(ColumnArray & arr, ColumnUInt8 & null_map, size_t column_size)
+        : ArraySink(arr, column_size), null_map(null_map.getData())
+    {
+    }
+
+    void reserve(size_t num_elements)
+    {
+        ArraySink::reserve(num_elements);
+        null_map.reserve(num_elements);
+    }
+};
+
+template <typename ... Types>
+struct ArraySourceCreator;
+
+template <typename Type, typename ... Types>
+struct ArraySourceCreator<Type, Types ...>
+{
+    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    {
+        std::cerr << "Numeric " << typeid(Type).name() << std::endl;
+        if (typeid_cast<const ColumnVector<Type> *>(&col.getData()))
+        {
+            std::cerr << "Created" << typeid(NumericArraySource<Type>).name() << std::endl;
+            if (null_map)
+            {
+                if (is_const)
+                    return std::make_unique<ConstSource<NullableArraySource<NumericArraySource<Type>>>>(col, *null_map, total_rows);
+                return std::make_unique<NullableArraySource<NumericArraySource<Type>>>(col, *null_map);
+            }
+            if (is_const)
+                return std::make_unique<ConstSource<NumericArraySource<Type>>>(col, total_rows);
+            return std::make_unique<NumericArraySource<Type>>(col);
+        }
+
+        return ArraySourceCreator<Types...>::create(col, null_map, is_const, total_rows);
+    }
+};
+
+template <>
+struct ArraySourceCreator<>
+{
+    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    {
+        std::cerr << "Generic " << typeid(GenericArraySource).name() << std::endl;
+        if (null_map)
+        {
+            if (is_const)
+                return std::make_unique<ConstSource<NullableArraySource<GenericArraySource>>>(col, *null_map, total_rows);
+            return std::make_unique<NullableArraySource<GenericArraySource>>(col, *null_map);
+        }
+        if (is_const)
+            return std::make_unique<ConstSource<GenericArraySource>>(col, total_rows);
+        return std::make_unique<GenericArraySource>(col);
+    }
+};
+
+inline std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
+{
+    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumber>::Type;
+    if (auto column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
+    {
+        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
+        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), is_const, total_rows);
+    }
+    return Creator::create(col, nullptr, is_const, total_rows);
+}
+
+
+template <typename ... Types>
+struct ArraySinkCreator;
+
+template <typename Type, typename ... Types>
+struct ArraySinkCreator<Type, Types ...>
+{
+    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
+    {
+        if (typeid_cast<ColumnVector<Type> *>(&col.getData()))
+        {
+            if (null_map)
+                return std::make_unique<NullableArraySink<NumericArraySink<Type>>>(col, *null_map, column_size);
+            return std::make_unique<NumericArraySink<Type>>(col, column_size);
+        }
+
+        return ArraySinkCreator<Types ...>::create(col, null_map, column_size);
+    }
+};
+
+template <>
+struct ArraySinkCreator<>
+{
+    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
+    {
+        if (null_map)
+            return std::make_unique<NullableArraySink<GenericArraySink>>(col, *null_map, column_size);
+        return std::make_unique<GenericArraySink>(col, column_size);
+    }
+};
+
+inline std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
+{
+    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumber>::Type;
+    if (auto column_nullable = typeid_cast<ColumnNullable *>(&col.getData()))
+    {
+        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
+        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), column_size);
+    }
+    return Creator::create(col, nullptr, column_size);
+}
+
+
 template <typename T>
 using NumericSlice = const T *;
 
@@ -700,15 +962,17 @@ struct NumericSink
 template <typename T>
 void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<T> & sink)
 {
-    sink.elements.resize(sink.current_offset + slice.size);
-    memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size * sizeof(T));
+    if (sink.elements.size() < sink.current_offset + slice.size)
+        sink.elements.resize(sink.current_offset + slice.size);
+    memcpy(&sink.elements[sink.current_offset], slice.data, slice.size * sizeof(T));
     sink.current_offset += slice.size;
 }
 
 template <typename T, typename U>
 void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 {
-    sink.elements.resize(sink.current_offset + slice.size);
+    if (sink.elements.size() < sink.current_offset + slice.size)
+        sink.elements.resize(sink.current_offset + slice.size);
     for (size_t i = 0; i < slice.size; ++i)
     {
         sink.elements[sink.current_offset] = slice.data[i];
@@ -718,7 +982,8 @@ void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 
 inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, StringSink & sink)
 {
-    sink.elements.resize(sink.current_offset + slice.size);
+    if (sink.elements.size() < sink.current_offset + slice.size)
+        sink.elements.resize(sink.current_offset + slice.size);
     memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size);
     sink.current_offset += slice.size;
 }
@@ -728,24 +993,179 @@ inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, FixedStr
     memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size);
 }
 
-/// Assuming same types of underlying columns for slice and sink.
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArraySink & sink)
 {
-    sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
+    if (std::type_index(typeid(slice.elements)) == std::type_index(typeid(&sink.elements)))
+        sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
+    else
+    {
+        for (size_t i = 0; i < slice.size; ++i)
+        {
+            Field field;
+            slice.elements->get(slice.begin + i, field);
+            sink.elements.insert(field);
+        }
+    }
     sink.current_offset += slice.size;
 }
 
-template <typename T, typename U>
-void ALWAYS_INLINE writeSlice(const NumericSlice<T> & slice, NumericSink<U> & sink)
+template <typename T>
+inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, NumericArraySink<T> & sink)
 {
-    *sink.pos = *slice;
+    if (sink.elements.size() < sink.current_offset + slice.size)
+        sink.elements.resize(sink.current_offset + slice.size);
+    for (size_t i = 0; i < slice.size; ++i)
+    {
+        Field field;
+        slice.elements->get(slice.begin + i, field);
+        sink.elements.push_back(field.get<T>());
+    }
+    sink.current_offset += slice.size;
 }
 
+template <typename T>
+inline ALWAYS_INLINE void writeSlice(const NumericArraySlice<T> & slice, GenericArraySink & sink)
+{
+    for (size_t i = 0; i < slice.size; ++i)
+    {
+        Field field = static_cast<typename NearestFieldType<T>::Type>(slice.data[i]);
+        sink.elements.insert(field);
+    }
+    sink.current_offset += slice.size;
+}
+
+/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
+template <typename ArraySlice, typename ArraySink>
+inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slice, NullableArraySink<ArraySink> & sink)
+{
+    if (sink.null_map.size() < sink.current_offset + slice.size)
+        sink.null_map.resize(sink.current_offset + slice.size);
+    memcpy(&sink.null_map[sink.current_offset], slice.null_map, slice.size * sizeof(UInt8));
+    writeSlice(static_cast<const ArraySlice &>(slice), static_cast<ArraySink &>(sink));
+}
+
+/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
+template <typename ArraySlice, typename ArraySink>
+inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink<ArraySink> & sink)
+{
+    if (sink.null_map.size() < sink.current_offset + slice.size)
+        sink.null_map.resize(sink.current_offset + slice.size);
+    memset(&sink.null_map[sink.current_offset], 0, slice.size * sizeof(UInt8));
+    writeSlice(slice, static_cast<ArraySink &>(sink));
+}
 
 /// Algorithms
 
+template <typename Source, typename Sink>
+static void append(Source & source, Sink & sink)
+{
+    sink.row_num = 0;
+    while (!source.isEnd())
+    {
+        sink.current_offset = sink.offsets[sink.row_num];
+        writeSlice(source.getWhole(), sink);
+        sink.next();
+        source.next();
+    }
+}
+
+template <template <typename ...> typename Base, typename ... Types>
+struct ArraySourceSelector;
+
+template <template <typename ...> typename Base, typename Type, typename ... Types>
+struct ArraySourceSelector<Base, Type, Types ...>
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, Args & ... args)
+    {
+        if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
+            Base<Types ...>::selectImpl(*array, args ...);
+        else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
+            Base<Types ...>::selectImpl(*nullable_array, args ...);
+        else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
+            Base<Types ...>::selectImpl(*const_array, args ...);
+        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
+            Base<Types ...>::selectImpl(*const_nullable_array, args ...);
+        else
+            Base<Types ...>::select(source, args ...);
+    }
+};
+
+template <template <typename ...> typename Base>
+struct ArraySourceSelector<Base>
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, Args & ... args)
+    {
+        if (auto array = typeid_cast<GenericArraySource *>(&source))
+            Base<>::selectImpl(*array, args ...);
+        else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
+            Base<>::selectImpl(*nullable_array, args ...);
+        else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
+            Base<>::selectImpl(*const_array, args ...);
+        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
+            Base<>::selectImpl(*const_nullable_array, args ...);
+        else
+            throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
+    }
+};
+
+
+template <template <typename ...> typename Base, typename ... Types>
+struct ArraySinkSelector;
+
+template <template <typename ...> typename Base, typename Type, typename ... Types>
+struct ArraySinkSelector<Base, Type, Types ...>
+{
+    template <typename ... Args>
+    static void select(IArraySink & sink, Args & ... args)
+    {
+        if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
+            Base<>::selectImpl(*nullable_numeric_sink, args ...);
+        else if (auto numeric_sink = typeid_cast<NumericArraySink<Type> *>(&sink))
+            Base<>::selectImpl(*numeric_sink, args ...);
+        else
+            Base<Types ...>::select(sink, args ...);
+    }
+};
+
+template <template <typename ...> typename Base>
+struct ArraySinkSelector<Base>
+{
+    template <typename ... Args>
+    static void select(IArraySink & sink, Args & ... args)
+    {
+        if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
+            Base<>::selectImpl(*nullable_generic_sink, args ...);
+        else if (auto generic_sink = typeid_cast<GenericArraySink *>(&sink))
+            Base<>::selectImpl(*generic_sink, args ...);
+        else
+            throw Exception(std::string("Unknown ArraySink type: ") + typeid(sink).name(), ErrorCodes::LOGICAL_ERROR);
+    }
+};
+
+
+template <typename ... Types>
+struct ArrayAppend : public ArraySourceSelector<ArrayAppend, Types ...>
+{
+    template <typename Source, typename Sink>
+    static void selectImpl(Source & source, Sink & sink)
+    {
+        append<Source, Sink>(source, sink);
+    }
+};
+
+template <typename Sink>
+static void append(IArraySource & source, Sink & sink)
+{
+    // using List = typename AppendToTypeList<Sink, TypeListNumber>::Type;
+    using AppendImpl = typename ApplyTypeListForClass<ArrayAppend, TypeListNumber>::Type;
+    AppendImpl::select(source, sink);
+}
+
+
 template <typename SourceA, typename SourceB, typename Sink>
-void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
+void NO_INLINE concat(SourceA & src_a, SourceB & src_b, Sink & sink)
 {
     sink.reserve(src_a.getSizeForReserve() + src_b.getSizeForReserve());
 
@@ -760,6 +1180,12 @@ void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
     }
 }
 
+template <typename SourceA, typename SourceB, typename Sink>
+void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
+{
+    concat(src_a, src_b, sink);
+}
+
 template <typename Sink>
 void NO_INLINE concat(StringSources & sources, Sink && sink)
 {
@@ -774,6 +1200,163 @@ void NO_INLINE concat(StringSources & sources, Sink && sink)
     }
 }
 
+template <typename SourceType, typename SinkType>
+struct ConcatGenericImpl
+{
+    static void concat(GenericArraySource * generic_source, SinkType & sink)
+    {
+        auto source = static_cast<SourceType *>(generic_source);
+        writeSlice(source->getWhole(), sink);
+        source->next();
+    }
+};
+
+template <typename Sink>
+static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+{
+    std::vector<GenericArraySource *> generic_sources;
+    std::vector<bool> is_nullable;
+    std::vector<bool> is_const;
+
+    generic_sources.reserve(sources.size());
+    is_nullable.assign(sources.size(), false);
+    is_const.assign(sources.size(), false);
+
+    for (auto i : ext::range(0, sources.size()))
+    {
+        const auto &source = sources[i];
+        if (auto generic_source = typeid_cast<GenericArraySource *>(source.get()))
+            generic_sources.push_back(static_cast<GenericArraySource *>(generic_source));
+        else if (auto const_generic_source = typeid_cast<ConstSource<GenericArraySource> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(const_generic_source));
+            is_const[i] = true;
+        }
+        else if (auto nullable_source = typeid_cast<NullableArraySource<GenericArraySource> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(nullable_source));
+            is_nullable[i] = true;
+        }
+        else if (auto const_nullable_source = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(const_nullable_source));
+            is_nullable[i] = is_const[i] = true;
+        }
+        else
+            throw Exception(std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
+                            ErrorCodes::LOGICAL_ERROR);
+    }
+
+    while (!sink.isEnd())
+    {
+        for (auto i : ext::range(0, sources.size()))
+        {
+            auto source = generic_sources[i];
+            if (is_const[i])
+            {
+                if (is_nullable[i])
+                    ConcatGenericImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::concat(source, sink);
+                else
+                    ConcatGenericImpl<ConstSource<GenericArraySource>, Sink>::concat(source, sink);
+            }
+            else
+            {
+                if (is_nullable[i])
+                    ConcatGenericImpl<NullableArraySource<GenericArraySource>, Sink>::concat(source, sink);
+                else
+                    ConcatGenericImpl<GenericArraySource, Sink>::concat(source, sink);
+            }
+        }
+        sink.next();
+    }
+}
+
+template <typename Sink>
+void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+{
+    size_t elements_to_reserve = 0;
+    bool is_first = true;
+    /// Prepare offsets column. Offsets should point to starts of result arrays.
+
+    for (const auto & source : sources)
+    {
+        elements_to_reserve += source->getSizeForReserve();
+        const auto & offsets = source->getOffsets();
+
+        if (is_first)
+        {
+            sink.offsets.resize(source->getColumnSize());
+            memset(&sink.offsets[0], 0, sink.offsets.size() * sizeof(offsets[0]));
+            is_first = false;
+        }
+        std::cerr << "Offsets:";
+        for (size_t i : ext::range(1, offsets.size()))
+        {
+            std::cerr << ' ' << offsets[i];
+        }
+        std::cerr << std::endl;
+
+        if (source->isConst())
+        {
+            for (size_t i : ext::range(1, offsets.size()))
+                sink.offsets[i] += offsets[0];
+        }
+        else
+        {
+            for (size_t i : ext::range(1, offsets.size()))
+                sink.offsets[i] += offsets[i - 1] - (i > 1 ? offsets[i - 2] : 0);
+        }
+    }
+
+    std::cerr << "Sink offsets:";
+    for (size_t i : ext::range(1, sink.offsets.size()))
+    {
+        sink.offsets[i] += sink.offsets[i - 1];
+        std::cerr << ' ' << sink.offsets[i];
+    }
+    std::cerr << std::endl;
+
+    sink.reserve(elements_to_reserve);
+
+    for (const auto & source : sources)
+    {
+        append<Sink>(*source, sink);
+    }
+}
+
+template <typename ... Types>
+struct ArrayConcat;
+
+template <typename ... Types>
+struct ArrayConcat : public ArraySinkSelector<ArrayConcat, Types ...>
+{
+    using Sources = std::vector<std::unique_ptr<IArraySource>>;
+
+    template <typename Sink>
+    static void selectImpl(Sink & sink, Sources & sources)
+    {
+        concat<Sink>(sources, sink);
+    }
+
+    static void selectImpl(GenericArraySink & sink, Sources & sources)
+    {
+        concatGeneric<GenericArraySink>(sources, sink);
+    }
+
+    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
+    {
+        concatGeneric<NullableArraySink<GenericArraySink>>(sources, sink);
+    }
+};
+
+
+inline void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
+{
+    /// using List = typename AppendToTypeList<std::vector<std::unique_ptr<IArraySource>>, TypeListNumber>::Type;
+    using ConcatImpl = typename ApplyTypeListForClass<ArrayConcat, TypeListNumber>::Type;
+    using Sources = std::vector<std::unique_ptr<IArraySource>>;
+    return ConcatImpl::select(sink, sources);
+}
 
 template <typename Source, typename Sink>
 void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
@@ -870,6 +1453,9 @@ void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn &
 }
 
 
+
+
+
 template <typename SourceA, typename SourceB, typename Sink>
 void NO_INLINE conditional(SourceA && src_a, SourceB && src_b, Sink && sink, const PaddedPODArray<UInt8> & condition)
 {

From 096d34bb7f120694a2779ffe05f17e8f328b3d30 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Tue, 22 Aug 2017 20:54:14 +0300
Subject: [PATCH 03/30] added arraySlice function [#CLICKHOUSE-2090]

---
 dbms/src/Functions/CMakeLists.txt     |   1 +
 dbms/src/Functions/FunctionsArray.cpp | 124 +++++++++++
 dbms/src/Functions/FunctionsArray.h   |  21 ++
 dbms/src/Functions/GatherUtils.h      | 282 ++++++++++++++++++++++----
 4 files changed, 383 insertions(+), 45 deletions(-)

diff --git a/dbms/src/Functions/CMakeLists.txt b/dbms/src/Functions/CMakeLists.txt
index f726e78883c..a1a1946984a 100644
--- a/dbms/src/Functions/CMakeLists.txt
+++ b/dbms/src/Functions/CMakeLists.txt
@@ -53,6 +53,7 @@ generate_function_register(Array
   FunctionArrayReduce
   FunctionArrayReverse
   FunctionArrayConcat
+  FunctionArraySlice
 )
 
 
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 3e374995afc..e803fc46551 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -2977,4 +2977,128 @@ void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & argum
     std::cerr << block.dumpStructure() << std::endl;
 }
 
+
+/// Implementation of FunctionArraySlice.
+
+FunctionPtr FunctionArraySlice::create(const Context & context)
+{
+    return std::make_shared<FunctionArraySlice>();
+}
+
+String FunctionArraySlice::getName() const
+{
+    return name;
+}
+
+DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) const
+{
+    if (arguments[0]->isNull())
+        return arguments[0];
+
+    auto array_type = typeid_cast<DataTypeArray *>(arguments[0].get());
+    if (!array_type)
+        throw Exception("First argument for function " + getName() + " must be an array but it has type "
+                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+    for (size_t i = 1; i < arguments.size(); ++i)
+    {
+        if (!arguments[i]->isNumeric() && !arguments[i]->isNull())
+            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be numeric but it has type "
+                            + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+
+    return arguments[0];
+}
+
+void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+{
+    std::cerr << block.dumpStructure() << std::endl;
+
+    auto & result_colum_with_name_and_type = block.getByPosition(result);
+    auto & result_column = result_colum_with_name_and_type.column;
+    auto & return_type = result_colum_with_name_and_type.type;
+    result_column = return_type->createColumn();
+
+    if (return_type->isNull())
+        return;
+
+    auto & array_column = block.getByPosition(arguments[0]).column;
+    auto & offset_column = block.getByPosition(arguments[1]).column;
+    auto & length_column = block.getByPosition(arguments[2]).column;
+
+    std::unique_ptr<IArraySource> source;
+
+
+    size_t size = array_column->size();
+    bool is_const = false;
+
+    if (auto const_array_column = typeid_cast<ColumnConst *>(array_column.get()))
+    {
+        is_const = true;
+        array_column = const_array_column->getDataColumnPtr();
+    }
+
+    if (auto argument_column_array = typeid_cast<ColumnArray *>(array_column.get()))
+        source = createArraySource(*argument_column_array, is_const, size);
+    else
+        throw Exception{"First arguments for function " + getName() + " must be array.", ErrorCodes::LOGICAL_ERROR};
+
+    auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column), size);
+
+    if (offset_column->isNull())
+    {
+        if (length_column->isNull())
+            result_column = array_column->clone();
+        else if (length_column->isConst())
+            sliceFromLeftConstantOffsetBounded(*source, *sink, 0, length_column->getInt(0));
+        else
+        {
+            auto const_offset_column = std::make_shared<ColumnConst>(std::make_shared<ColumnInt8>(1, 1), size);
+            sliceDynamicOffsetBounded(*source, *sink, *const_offset_column, *length_column);
+        }
+    }
+    else if (offset_column->isConst())
+    {
+        ssize_t offset = offset_column->getUInt(0);
+
+        if (length_column->isNull())
+        {
+            if (offset > 0)
+                sliceFromLeftConstantOffsetUnbounded(*source, *sink, static_cast<size_t>(offset - 1));
+            else
+                sliceFromRightConstantOffsetUnbounded(*source, *sink, static_cast<size_t>(-offset));
+        }
+        else if (length_column->isConst())
+        {
+            ssize_t length = length_column->getInt(0);
+            if (offset > 0)
+                sliceFromLeftConstantOffsetBounded(*source, *sink, static_cast<size_t>(offset - 1), length);
+            else
+                sliceFromRightConstantOffsetBounded(*source, *sink, static_cast<size_t>(-offset), length);
+        }
+        else
+            sliceDynamicOffsetBounded(*source, *sink, *offset_column, *length_column);
+    }
+    else
+    {
+        if (length_column->isNull())
+            sliceDynamicOffsetUnbounded(*source, *sink, *offset_column);
+        else
+            sliceDynamicOffsetBounded(*source, *sink, *offset_column, *length_column);
+    }
+
+
+    auto array = checkAndGetColumn<ColumnArray>(result_column.get());
+    if (array)
+    {
+        auto & offsets = array->getOffsets();
+        std::cerr << offsets.size()  << " " << array->size()<< std::endl;
+        for (auto & val : offsets)
+            std::cerr << val << ' ';
+        std::cerr << std::endl;
+    }
+
+    std::cerr << block.dumpStructure() << std::endl;
+}
+
 }
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index 60970b733f9..f6cfd4744e3 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -1425,6 +1425,27 @@ public:
 };
 
 
+class FunctionArraySlice : public IFunction
+{
+public:
+    static constexpr auto name = "arraySlice";
+    static FunctionPtr create(const Context & context);
+
+    String getName() const override;
+
+    bool isVariadic() const override { return false; }
+    size_t getNumberOfArguments() const override { return 3; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+    bool useDefaultImplementationForNulls() const { return false; }
+};
+
+
+
 struct NameHas { static constexpr auto name = "has"; };
 struct NameIndexOf { static constexpr auto name = "indexOf"; };
 struct NameCountEqual { static constexpr auto name = "countEqual"; };
diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index bf825c818cc..cfd445723f9 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -120,6 +120,11 @@ struct NumericArraySource : public IArraySource
         return offsets.size();
     }
 
+    size_t getElementSize() const
+    {
+        return offsets[row_num] - prev_offset;
+    }
+
     Slice getWhole() const
     {
         return {&elements[prev_offset], offsets[row_num] - prev_offset};
@@ -280,6 +285,11 @@ struct StringSource
         return elements.size();
     }
 
+    size_t getElementSize() const
+    {
+        return offsets[row_num] - prev_offset;
+    }
+
     Slice getWhole() const
     {
         return {&elements[prev_offset], offsets[row_num] - prev_offset - 1};
@@ -358,6 +368,11 @@ struct FixedStringSource
         return end - pos;
     }
 
+    size_t getElementSize() const
+    {
+        return string_size;
+    }
+
     Slice getWhole() const
     {
         return {pos, string_size};
@@ -604,6 +619,11 @@ struct GenericArraySource : public IArraySource
         return elements.size();
     }
 
+    size_t getElementSize() const
+    {
+        return offsets[row_num] - prev_offset;
+    }
+
     Slice getWhole() const
     {
         return {&elements, prev_offset, offsets[row_num] - prev_offset};
@@ -1069,84 +1089,110 @@ static void append(Source & source, Sink & sink)
     }
 }
 
-template <template <typename ...> typename Base, typename ... Types>
+template <typename Base, typename ... Types>
 struct ArraySourceSelector;
 
-template <template <typename ...> typename Base, typename Type, typename ... Types>
+template <typename Base, typename Type, typename ... Types>
 struct ArraySourceSelector<Base, Type, Types ...>
 {
     template <typename ... Args>
     static void select(IArraySource & source, Args & ... args)
     {
         if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
-            Base<Types ...>::selectImpl(*array, args ...);
+            Base::selectImpl(*array, args ...);
         else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
-            Base<Types ...>::selectImpl(*nullable_array, args ...);
+            Base::selectImpl(*nullable_array, args ...);
         else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
-            Base<Types ...>::selectImpl(*const_array, args ...);
+            Base::selectImpl(*const_array, args ...);
         else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
-            Base<Types ...>::selectImpl(*const_nullable_array, args ...);
+            Base::selectImpl(*const_nullable_array, args ...);
         else
-            Base<Types ...>::select(source, args ...);
+            ArraySourceSelector<Base, Types ...>::select(source, args ...);
     }
 };
 
-template <template <typename ...> typename Base>
+template <typename Base>
 struct ArraySourceSelector<Base>
 {
     template <typename ... Args>
     static void select(IArraySource & source, Args & ... args)
     {
         if (auto array = typeid_cast<GenericArraySource *>(&source))
-            Base<>::selectImpl(*array, args ...);
+            Base::selectImpl(*array, args ...);
         else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
-            Base<>::selectImpl(*nullable_array, args ...);
+            Base::selectImpl(*nullable_array, args ...);
         else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
-            Base<>::selectImpl(*const_array, args ...);
+            Base::selectImpl(*const_array, args ...);
         else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
-            Base<>::selectImpl(*const_nullable_array, args ...);
+            Base::selectImpl(*const_nullable_array, args ...);
         else
             throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
     }
 };
 
+template <typename Base>
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
 
-template <template <typename ...> typename Base, typename ... Types>
+template <typename Base, typename ... Types>
 struct ArraySinkSelector;
 
-template <template <typename ...> typename Base, typename Type, typename ... Types>
+template <typename Base, typename Type, typename ... Types>
 struct ArraySinkSelector<Base, Type, Types ...>
 {
     template <typename ... Args>
     static void select(IArraySink & sink, Args & ... args)
     {
         if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
-            Base<>::selectImpl(*nullable_numeric_sink, args ...);
+            Base::selectImpl(*nullable_numeric_sink, args ...);
         else if (auto numeric_sink = typeid_cast<NumericArraySink<Type> *>(&sink))
-            Base<>::selectImpl(*numeric_sink, args ...);
+            Base::selectImpl(*numeric_sink, args ...);
         else
-            Base<Types ...>::select(sink, args ...);
+            ArraySinkSelector<Base, Types ...>::select(sink, args ...);
     }
 };
 
-template <template <typename ...> typename Base>
+template <typename Base>
 struct ArraySinkSelector<Base>
 {
     template <typename ... Args>
     static void select(IArraySink & sink, Args & ... args)
     {
         if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
-            Base<>::selectImpl(*nullable_generic_sink, args ...);
+            Base::selectImpl(*nullable_generic_sink, args ...);
         else if (auto generic_sink = typeid_cast<GenericArraySink *>(&sink))
-            Base<>::selectImpl(*generic_sink, args ...);
+            Base::selectImpl(*generic_sink, args ...);
         else
             throw Exception(std::string("Unknown ArraySink type: ") + typeid(sink).name(), ErrorCodes::LOGICAL_ERROR);
     }
 };
 
+template <typename Base>
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
 
-template <typename ... Types>
-struct ArrayAppend : public ArraySourceSelector<ArrayAppend, Types ...>
+template <typename Base>
+struct ArraySinkSourceSelector
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, IArraySink & sink, Args & ... args)
+    {
+        GetArraySinkSelector<Base>::select(sink, source, args ...);
+    }
+
+    template <typename Sink, typename ... Args>
+    static void selectImpl(Sink & sink, IArraySource & source, Args & ... args)
+    {
+        GetArraySourceSelector<Base>::select(source, sink, args ...);
+    }
+
+    template <typename Source, typename Sink, typename ... Args>
+    static void selectImpl(Source & source, Sink & sink, Args & ... args)
+    {
+        Base::selectSourceSink(source, sink, args ...);
+    }
+};
+
+
+struct ArrayAppend : public GetArraySourceSelector<ArrayAppend>
 {
     template <typename Source, typename Sink>
     static void selectImpl(Source & source, Sink & sink)
@@ -1158,9 +1204,7 @@ struct ArrayAppend : public ArraySourceSelector<ArrayAppend, Types ...>
 template <typename Sink>
 static void append(IArraySource & source, Sink & sink)
 {
-    // using List = typename AppendToTypeList<Sink, TypeListNumber>::Type;
-    using AppendImpl = typename ApplyTypeListForClass<ArrayAppend, TypeListNumber>::Type;
-    AppendImpl::select(source, sink);
+    ArrayAppend::select(source, sink);
 }
 
 
@@ -1324,11 +1368,7 @@ void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources
     }
 }
 
-template <typename ... Types>
-struct ArrayConcat;
-
-template <typename ... Types>
-struct ArrayConcat : public ArraySinkSelector<ArrayConcat, Types ...>
+struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
 {
     using Sources = std::vector<std::unique_ptr<IArraySource>>;
 
@@ -1352,14 +1392,12 @@ struct ArrayConcat : public ArraySinkSelector<ArrayConcat, Types ...>
 
 inline void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
 {
-    /// using List = typename AppendToTypeList<std::vector<std::unique_ptr<IArraySource>>, TypeListNumber>::Type;
-    using ConcatImpl = typename ApplyTypeListForClass<ArrayConcat, TypeListNumber>::Type;
     using Sources = std::vector<std::unique_ptr<IArraySource>>;
-    return ConcatImpl::select(sink, sources);
+    return ArrayConcat::select(sink, sources);
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
+void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
 {
     while (!src.isEnd())
     {
@@ -1370,18 +1408,24 @@ void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink,
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetBounded(Source && src, Sink && sink, size_t offset, size_t length)
+void NO_INLINE sliceFromLeftConstantOffsetBounded(Source & src, Sink & sink, size_t offset, ssize_t length)
 {
     while (!src.isEnd())
     {
-        writeSlice(src.getSliceFromLeft(offset, length), sink);
+        ssize_t size = length;
+        if (size < 0)
+            size += static_cast<ssize_t>(src.getElementSize()) - offset;
+
+        if (size > 0)
+            writeSlice(src.getSliceFromLeft(offset, size), sink);
+
         sink.next();
         src.next();
     }
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
+void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
 {
     while (!src.isEnd())
     {
@@ -1392,22 +1436,34 @@ void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetBounded(Source && src, Sink && sink, size_t offset, size_t length)
+void NO_INLINE sliceFromRightConstantOffsetBounded(Source & src, Sink & sink, size_t offset, ssize_t length)
 {
     while (!src.isEnd())
     {
-        writeSlice(src.getSliceFromRight(offset, length), sink);
+        ssize_t size = length;
+        if (size < 0)
+            size += static_cast<ssize_t>(src.getElementSize()) - offset;
+
+        if (size > 0)
+            writeSlice(src.getSliceFromRight(offset, size), sink);
+
         sink.next();
         src.next();
     }
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn & offset_column)
+void NO_INLINE sliceDynamicOffsetUnbounded(Source & src, Sink & sink, IColumn & offset_column)
 {
+    const bool is_null = offset_column.isNull();
+    const bool is_nullable = offset_column.isNullable();
+    auto null_map = is_nullable ? &static_cast<ColumnNullable &>(offset_column).getNullMapConcreteColumn().getData() : nullptr;
+
     while (!src.isEnd())
     {
-        Int64 offset = offset_column.getInt(src.rowNum());
+        auto row_num = src.rowNum();
+        bool has_offset = !is_null && !(is_nullable && (*null_map)[row_num]);
+        Int64 offset = has_offset ? offset_column.getInt(row_num) : 1;
 
         if (offset != 0)
         {
@@ -1427,15 +1483,28 @@ void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn & offset_column, IColumn & length_column)
+void NO_INLINE sliceDynamicOffsetBounded(Source & src, Sink & sink, IColumn & offset_column, IColumn & length_column)
 {
+    const bool is_offset_null = offset_column.isNull();
+    const bool is_offset_nullable = offset_column.isNullable();
+    auto offset_null_map = is_offset_nullable ? &static_cast<ColumnNullable &>(offset_column).getNullMapConcreteColumn().getData() : nullptr;
+
+    const bool is_length_null = length_column.isNull();
+    const bool is_length_nullable = length_column.isNullable();
+    auto length_null_map = is_length_nullable ? &static_cast<ColumnNullable &>(length_column).getNullMapConcreteColumn().getData() : nullptr;
+
     while (!src.isEnd())
     {
         size_t row_num = src.rowNum();
-        Int64 offset = offset_column.getInt(row_num);
-        UInt64 size = length_column.getInt(row_num);
+        bool has_offset = !is_offset_null && !(is_offset_nullable && (*offset_null_map)[row_num]);
+        bool has_length = !is_length_null && !(is_length_nullable && (*length_null_map)[row_num]);
+        Int64 offset = has_offset ? offset_column.getInt(row_num) : 1;
+        Int64 size = has_length ? length_column.getInt(row_num) : static_cast<Int64>(src.getElementSize());
 
-        if (offset != 0 && size < 0x8000000000000000ULL)
+        if (size < 0)
+            size += offset > 0 ? static_cast<Int64>(src.getElementSize()) - (offset - 1) : -offset;
+
+        if (offset != 0 && size > 0)
         {
             typename std::decay<Source>::type::Slice slice;
 
@@ -1453,8 +1522,131 @@ void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn &
 }
 
 
+template <typename Source, typename Sink>
+void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
+{
+    sliceFromLeftConstantOffsetUnbounded(src, sink, offset);
+}
 
+template <typename Source, typename Sink>
+void NO_INLINE sliceFromLeftConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
+{
+    sliceFromLeftConstantOffsetBounded(src, sink, offset, length);
+}
 
+template <typename Source, typename Sink>
+void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
+{
+    sliceFromRightConstantOffsetUnbounded(src, sink, offset);
+}
+
+template <typename Source, typename Sink>
+void NO_INLINE sliceFromRightConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
+{
+    sliceFromRightConstantOffsetBounded(src, sink, offset, length);
+}
+
+template <typename Source, typename Sink>
+void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn & offset_column)
+{
+    sliceDynamicOffsetUnbounded(src, sink, offset_column);
+}
+
+template <typename Source, typename Sink>
+void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn & offset_column, IColumn & length_column)
+{
+    sliceDynamicOffsetBounded(src, sink, offset_column, length_column);
+}
+
+struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    {
+        sliceFromLeftConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+    }
+};
+
+struct SliceFromLeftConstantOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    {
+        sliceFromLeftConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+    }
+};
+
+struct SliceFromRightConstantOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    {
+        sliceFromRightConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+    }
+};
+
+struct SliceFromRightConstantOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    {
+        sliceFromRightConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+    }
+};
+
+struct SliceDynamicOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceDynamicOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
+    {
+        sliceDynamicOffsetUnbounded<Source, Sink>(source, sink, offset_column);
+    }
+};
+
+struct SliceDynamicOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceDynamicOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
+    {
+        sliceDynamicOffsetBounded<Source, Sink>(source, sink, offset_column, length_column);
+    }
+};
+
+inline void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
+{
+    SliceFromLeftConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
+}
+
+inline void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
+{
+    SliceFromLeftConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
+}
+
+inline void sliceFromRightConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
+{
+    SliceFromRightConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
+}
+
+inline void sliceFromRightConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
+{
+    SliceFromRightConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
+}
+
+inline void sliceDynamicOffsetUnbounded(IArraySource & src, IArraySink & sink, IColumn & offset_column)
+{
+    SliceDynamicOffsetUnboundedSelectArraySource::select(src, sink, offset_column);
+}
+
+inline void sliceDynamicOffsetBounded(IArraySource & src, IArraySink & sink, IColumn & offset_column, IColumn & length_column)
+{
+    SliceDynamicOffsetBoundedSelectArraySource::select(src, sink, offset_column, length_column);
+}
 
 template <typename SourceA, typename SourceB, typename Sink>
 void NO_INLINE conditional(SourceA && src_a, SourceB && src_b, Sink && sink, const PaddedPODArray<UInt8> & condition)

From e6fd55ff42ba97f5f2b1c5549f1477f591c1c0d7 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 16:00:23 +0300
Subject: [PATCH 04/30] added arrayPushBack arrayPushFront arrayPopBack
 arrayPopFront function [#CLICKHOUSE-2090]

---
 dbms/src/Functions/CMakeLists.txt     |    4 +
 dbms/src/Functions/FunctionsArray.cpp | 1940 ++++++++++++++-----------
 dbms/src/Functions/FunctionsArray.h   |   86 +-
 dbms/src/Functions/GatherUtils.cpp    |  482 ++++++
 dbms/src/Functions/GatherUtils.h      |  528 +------
 5 files changed, 1680 insertions(+), 1360 deletions(-)
 create mode 100644 dbms/src/Functions/GatherUtils.cpp

diff --git a/dbms/src/Functions/CMakeLists.txt b/dbms/src/Functions/CMakeLists.txt
index a1a1946984a..dde2fe117c3 100644
--- a/dbms/src/Functions/CMakeLists.txt
+++ b/dbms/src/Functions/CMakeLists.txt
@@ -54,6 +54,10 @@ generate_function_register(Array
   FunctionArrayReverse
   FunctionArrayConcat
   FunctionArraySlice
+  FunctionArrayPushBack
+  FunctionArrayPushFront
+  FunctionArrayPopBack
+  FunctionArrayPopFront
 )
 
 
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index e803fc46551..ca57755cec1 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -33,13 +33,13 @@ String FunctionArray::getName() const
     return name;
 }
 
-FunctionPtr FunctionArray::create(const Context & context)
+FunctionPtr FunctionArray::create(const Context &context)
 {
     return std::make_shared<FunctionArray>(context);
 }
 
-FunctionArray::FunctionArray(const Context & context)
-    : context(context)
+FunctionArray::FunctionArray(const Context &context)
+        : context(context)
 {
 }
 
@@ -48,7 +48,7 @@ namespace
 {
 
 /// Is there at least one numeric argument among the specified ones?
-bool foundNumericType(const DataTypes & args)
+bool foundNumericType(const DataTypes &args)
 {
     for (size_t i = 0; i < args.size(); ++i)
     {
@@ -63,7 +63,7 @@ bool foundNumericType(const DataTypes & args)
 
 
 /// Check if the specified arguments have the same type up to nullability or nullity.
-bool hasArrayIdenticalTypes(const DataTypes & args)
+bool hasArrayIdenticalTypes(const DataTypes &args)
 {
     std::string first_type_name;
 
@@ -71,8 +71,8 @@ bool hasArrayIdenticalTypes(const DataTypes & args)
     {
         if (!args[i]->isNull())
         {
-            const IDataType * observed_type = DataTypeTraits::removeNullable(args[i]).get();
-            const std::string & name = observed_type->getName();
+            const IDataType *observed_type = DataTypeTraits::removeNullable(args[i]).get();
+            const std::string &name = observed_type->getName();
 
             if (first_type_name.empty())
                 first_type_name = name;
@@ -88,16 +88,16 @@ bool hasArrayIdenticalTypes(const DataTypes & args)
 /// function hasArrayIdenticalTypes(), deduce the element type of an array that
 /// would be constructed from a set of values V, such that, for each i, the
 /// type of V[i] is args[i].
-DataTypePtr getArrayElementType(const DataTypes & args)
+DataTypePtr getArrayElementType(const DataTypes &args)
 {
     bool found_null = false;
     bool found_nullable = false;
 
-    const DataTypePtr * ret = nullptr;
+    const DataTypePtr *ret = nullptr;
 
     for (size_t i = 0; i < args.size(); ++i)
     {
-        const auto & type = args[i];
+        const auto &type = args[i];
 
         if (type->isNull())
             found_null = true;
@@ -129,8 +129,8 @@ DataTypePtr getArrayElementType(const DataTypes & args)
     }
 }
 
-template <typename T0, typename T1>
-bool tryAddField(DataTypePtr type_res, const Field & f, Array & arr)
+template<typename T0, typename T1>
+bool tryAddField(DataTypePtr type_res, const Field &f, Array &arr)
 {
     if (typeid_cast<const T0 *>(type_res.get()))
     {
@@ -145,28 +145,28 @@ bool tryAddField(DataTypePtr type_res, const Field & f, Array & arr)
 
 }
 
-bool FunctionArray::addField(DataTypePtr type_res, const Field & f, Array & arr) const
+bool FunctionArray::addField(DataTypePtr type_res, const Field &f, Array &arr) const
 {
     /// Otherwise, it is necessary
-    if (    tryAddField<DataTypeUInt8, DataTypeUInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeUInt16, DataTypeUInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeUInt32, DataTypeUInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeUInt64, DataTypeUInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeInt8, DataTypeInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeInt16, DataTypeInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeInt32, DataTypeInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeInt64, DataTypeInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeFloat32, DataTypeFloat64>(type_res, f, arr)
-        ||    tryAddField<DataTypeFloat64, DataTypeFloat64>(type_res, f, arr) )
+    if (tryAddField<DataTypeUInt8, DataTypeUInt64>(type_res, f, arr)
+        || tryAddField<DataTypeUInt16, DataTypeUInt64>(type_res, f, arr)
+        || tryAddField<DataTypeUInt32, DataTypeUInt64>(type_res, f, arr)
+        || tryAddField<DataTypeUInt64, DataTypeUInt64>(type_res, f, arr)
+        || tryAddField<DataTypeInt8, DataTypeInt64>(type_res, f, arr)
+        || tryAddField<DataTypeInt16, DataTypeInt64>(type_res, f, arr)
+        || tryAddField<DataTypeInt32, DataTypeInt64>(type_res, f, arr)
+        || tryAddField<DataTypeInt64, DataTypeInt64>(type_res, f, arr)
+        || tryAddField<DataTypeFloat32, DataTypeFloat64>(type_res, f, arr)
+        || tryAddField<DataTypeFloat64, DataTypeFloat64>(type_res, f, arr))
         return true;
     else
     {
         throw Exception{"Illegal result type " + type_res->getName() + " of function " + getName(),
-            ErrorCodes::LOGICAL_ERROR};
+                        ErrorCodes::LOGICAL_ERROR};
     }
 }
 
-const DataTypePtr & FunctionArray::getScalarType(const DataTypePtr & type)
+const DataTypePtr &FunctionArray::getScalarType(const DataTypePtr &type)
 {
     const auto array = checkAndGetDataType<DataTypeArray>(type.get());
 
@@ -176,7 +176,7 @@ const DataTypePtr & FunctionArray::getScalarType(const DataTypePtr & type)
     return getScalarType(array->getNestedType());
 }
 
-DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const DataTypes & arguments) const
+DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const DataTypes &arguments) const
 {
     DataTypeTraits::EnrichedDataTypePtr result_type;
 
@@ -184,26 +184,26 @@ DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const Data
     {
         result_type = Conditional::getArrayType(arguments);
     }
-    catch (const Conditional::CondException & ex)
+    catch (const Conditional::CondException &ex)
     {
         /// Translate a context-free error into a contextual error.
         if (ex.getCode() == Conditional::CondErrorCodes::TYPE_DEDUCER_ILLEGAL_COLUMN_TYPE)
             throw Exception{"Illegal type of column " + ex.getMsg1() +
-                " in array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+                            " in array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         else if (ex.getCode() == Conditional::CondErrorCodes::TYPE_DEDUCER_UPSCALING_ERROR)
             throw Exception("Arguments of function " + getName() + " are not upscalable "
-                "to a common type without loss of precision.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                                    "to a common type without loss of precision.",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
         else
             throw Exception{"An unexpected error has occurred in function " + getName(),
-                ErrorCodes::LOGICAL_ERROR};
+                            ErrorCodes::LOGICAL_ERROR};
     }
 
     return result_type;
 }
 
 
-DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes &arguments) const
 {
     if (arguments.empty())
         throw Exception{"Function array requires at least one argument.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
@@ -220,13 +220,14 @@ DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes & arguments) const
     {
         /// Otherwise all the arguments must have the same type up to nullability or nullity.
         if (!hasArrayIdenticalTypes(arguments))
-            throw Exception{"Arguments for function array must have same type or behave as number.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Arguments for function array must have same type or behave as number.",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeArray>(getArrayElementType(arguments));
     }
 }
 
-void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     size_t num_elements = arguments.size();
     bool is_const = true;
@@ -240,17 +241,17 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments,
         }
     }
 
-    const DataTypePtr & return_type = block.getByPosition(result).type;
-    const DataTypePtr & elem_type = static_cast<const DataTypeArray &>(*return_type).getNestedType();
+    const DataTypePtr &return_type = block.getByPosition(result).type;
+    const DataTypePtr &elem_type = static_cast<const DataTypeArray &>(*return_type).getNestedType();
 
     if (is_const)
     {
-        const DataTypePtr & observed_type = DataTypeTraits::removeNullable(elem_type);
+        const DataTypePtr &observed_type = DataTypeTraits::removeNullable(elem_type);
 
         Array arr;
         for (const auto arg_num : arguments)
         {
-            const auto & elem = block.getByPosition(arg_num);
+            const auto &elem = block.getByPosition(arg_num);
 
             if (DataTypeTraits::removeNullable(elem.type)->equals(*observed_type))
             {
@@ -280,11 +281,11 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments,
           */
 
         Columns columns_holder(num_elements);
-        const IColumn * columns[num_elements];
+        const IColumn *columns[num_elements];
 
         for (size_t i = 0; i < num_elements; ++i)
         {
-            const auto & arg = block.getByPosition(arguments[i]);
+            const auto &arg = block.getByPosition(arguments[i]);
 
             String elem_type_name = elem_type->getName();
             ColumnPtr preprocessed_column = arg.column;
@@ -292,29 +293,30 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments,
             if (arg.type->getName() != elem_type_name)
             {
                 Block temporary_block
-                {
-                    {
-                        arg.column,
-                        arg.type,
-                        arg.name
-                    },
-                    {
-                        DataTypeString().createConstColumn(block_size, elem_type_name),
-                        std::make_shared<DataTypeString>(),
-                        ""
-                    },
-                    {
-                        nullptr,
-                        elem_type,
-                        ""
-                    }
-                };
+                        {
+                                {
+                                        arg.column,
+                                        arg.type,
+                                        arg.name
+                                },
+                                {
+                                        DataTypeString().createConstColumn(block_size, elem_type_name),
+                                        std::make_shared<DataTypeString>(),
+                                        ""
+                                },
+                                {
+                                        nullptr,
+                                        elem_type,
+                                        ""
+                                }
+                        };
 
                 FunctionCast func_cast(context);
 
                 {
                     DataTypePtr unused_return_type;
-                    ColumnsWithTypeAndName arguments{ temporary_block.getByPosition(0), temporary_block.getByPosition(1) };
+                    ColumnsWithTypeAndName arguments{temporary_block.getByPosition(0),
+                                                     temporary_block.getByPosition(1)};
                     std::vector<ExpressionAction> unused_prerequisites;
 
                     /// Prepares function to execution. TODO It is not obvious.
@@ -336,8 +338,8 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments,
           */
 
         auto out = std::make_shared<ColumnArray>(elem_type->createColumn());
-        IColumn & out_data = out->getData();
-        IColumn::Offsets_t & out_offsets = out->getOffsets();
+        IColumn &out_data = out->getData();
+        IColumn::Offsets_t &out_offsets = out->getOffsets();
 
         out_data.reserve(block_size * num_elements);
         out_offsets.resize(block_size);
@@ -364,15 +366,18 @@ namespace ArrayImpl
 class NullMapBuilder
 {
 public:
-    operator bool() const { return src_nullable_col || src_array; }
-    bool operator!() const { return !src_nullable_col && !src_array; }
+    operator bool() const
+    { return src_nullable_col || src_array; }
 
-    void initSource(const ColumnNullable & src_nullable_col_)
+    bool operator!() const
+    { return !src_nullable_col && !src_array; }
+
+    void initSource(const ColumnNullable &src_nullable_col_)
     {
         src_nullable_col = &src_nullable_col_;
     }
 
-    void initSource(const Array & src_array_)
+    void initSource(const Array &src_array_)
     {
         src_array = &src_array_;
     }
@@ -386,7 +391,8 @@ public:
     void update(size_t from)
     {
         if (index >= size)
-            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.", ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.",
+                            ErrorCodes::LOGICAL_ERROR};
 
         bool is_null;
         if (src_nullable_col)
@@ -394,7 +400,7 @@ public:
         else
             is_null = from < src_array->size() ? (*src_array)[from].isNull() : true;
 
-        auto & null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
+        auto &null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
         null_map_data[index] = is_null ? 1 : 0;
 
         ++index;
@@ -403,18 +409,20 @@ public:
     void update()
     {
         if (index >= size)
-            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.", ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.",
+                            ErrorCodes::LOGICAL_ERROR};
 
-        auto & null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
+        auto &null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
         null_map_data[index] = 0;
         ++index;
     }
 
-    ColumnPtr getNullMap() const { return sink_null_map; }
+    ColumnPtr getNullMap() const
+    { return sink_null_map; }
 
 private:
-    const ColumnNullable * src_nullable_col = nullptr;
-    const Array * src_array = nullptr;
+    const ColumnNullable *src_nullable_col = nullptr;
+    const Array *src_array = nullptr;
     ColumnPtr sink_null_map;
     size_t size = 0;
     size_t index = 0;
@@ -425,18 +433,18 @@ private:
 namespace
 {
 
-template <typename T>
+template<typename T>
 struct ArrayElementNumImpl
 {
     /** Implementation for constant index.
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template <bool negative>
+    template<bool negative>
     static void vectorConst(
-        const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
-        const ColumnArray::Offset_t index,
-        PaddedPODArray<T> & result, ArrayImpl::NullMapBuilder & builder)
+            const PaddedPODArray<T> &data, const ColumnArray::Offsets_t &offsets,
+            const ColumnArray::Offset_t index,
+            PaddedPODArray<T> &result, ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result.resize(size);
@@ -467,11 +475,11 @@ struct ArrayElementNumImpl
 
     /** Implementation for non-constant index.
       */
-    template <typename TIndex>
+    template<typename TIndex>
     static void vector(
-        const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
-        const PaddedPODArray<TIndex> & indices,
-        PaddedPODArray<T> & result, ArrayImpl::NullMapBuilder & builder)
+            const PaddedPODArray<T> &data, const ColumnArray::Offsets_t &offsets,
+            const PaddedPODArray<TIndex> &indices,
+            PaddedPODArray<T> &result, ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result.resize(size);
@@ -517,12 +525,13 @@ struct ArrayElementStringImpl
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template <bool negative>
+    template<bool negative>
     static void vectorConst(
-        const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
-        const ColumnArray::Offset_t index,
-        ColumnString::Chars_t & result_data, ColumnArray::Offsets_t & result_offsets,
-        ArrayImpl::NullMapBuilder & builder)
+            const ColumnString::Chars_t &data, const ColumnArray::Offsets_t &offsets,
+            const ColumnString::Offsets_t &string_offsets,
+            const ColumnArray::Offset_t index,
+            ColumnString::Chars_t &result_data, ColumnArray::Offsets_t &result_offsets,
+            ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result_offsets.resize(size);
@@ -538,18 +547,19 @@ struct ArrayElementStringImpl
             {
                 size_t adjusted_index = !negative ? index : (array_size - index - 1);
 
-                size_t j =  (current_offset == 0 && adjusted_index == 0) ? 0 : current_offset + adjusted_index;
+                size_t j = (current_offset == 0 && adjusted_index == 0) ? 0 : current_offset + adjusted_index;
                 if (builder)
                     builder.update(j);
 
                 ColumnArray::Offset_t string_pos = current_offset == 0 && adjusted_index == 0
-                    ? 0
-                    : string_offsets[current_offset + adjusted_index - 1];
+                                                   ? 0
+                                                   : string_offsets[current_offset + adjusted_index - 1];
 
                 ColumnArray::Offset_t string_size = string_offsets[current_offset + adjusted_index] - string_pos;
 
                 result_data.resize(current_result_offset + string_size);
-                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos], string_size);
+                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos],
+                                                    string_size);
                 current_result_offset += string_size;
                 result_offsets[i] = current_result_offset;
             }
@@ -571,12 +581,13 @@ struct ArrayElementStringImpl
 
     /** Implementation for non-constant index.
       */
-    template <typename TIndex>
+    template<typename TIndex>
     static void vector(
-        const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
-        const PaddedPODArray<TIndex> & indices,
-        ColumnString::Chars_t & result_data, ColumnArray::Offsets_t & result_offsets,
-        ArrayImpl::NullMapBuilder & builder)
+            const ColumnString::Chars_t &data, const ColumnArray::Offsets_t &offsets,
+            const ColumnString::Offsets_t &string_offsets,
+            const PaddedPODArray<TIndex> &indices,
+            ColumnString::Chars_t &result_data, ColumnArray::Offsets_t &result_offsets,
+            ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result_offsets.resize(size);
@@ -604,13 +615,14 @@ struct ArrayElementStringImpl
                     builder.update(j);
 
                 ColumnArray::Offset_t string_pos = current_offset == 0 && adjusted_index == 0
-                    ? 0
-                    : string_offsets[current_offset + adjusted_index - 1];
+                                                   ? 0
+                                                   : string_offsets[current_offset + adjusted_index - 1];
 
                 ColumnArray::Offset_t string_size = string_offsets[current_offset + adjusted_index] - string_pos;
 
                 result_data.resize(current_result_offset + string_size);
-                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos], string_size);
+                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos],
+                                                    string_size);
                 current_result_offset += string_size;
                 result_offsets[i] = current_result_offset;
             }
@@ -638,11 +650,11 @@ struct ArrayElementGenericImpl
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template <bool negative>
+    template<bool negative>
     static void vectorConst(
-        const IColumn & data, const ColumnArray::Offsets_t & offsets,
-        const ColumnArray::Offset_t index,
-        IColumn & result, ArrayImpl::NullMapBuilder & builder)
+            const IColumn &data, const ColumnArray::Offsets_t &offsets,
+            const ColumnArray::Offset_t index,
+            IColumn &result, ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result.reserve(size);
@@ -672,11 +684,11 @@ struct ArrayElementGenericImpl
 
     /** Implementation for non-constant index.
       */
-    template <typename TIndex>
+    template<typename TIndex>
     static void vector(
-        const IColumn & data, const ColumnArray::Offsets_t & offsets,
-        const PaddedPODArray<TIndex> & indices,
-        IColumn & result, ArrayImpl::NullMapBuilder & builder)
+            const IColumn &data, const ColumnArray::Offsets_t &offsets,
+            const PaddedPODArray<TIndex> &indices,
+            IColumn &result, ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result.reserve(size);
@@ -716,22 +728,23 @@ struct ArrayElementGenericImpl
 }
 
 
-FunctionPtr FunctionArrayElement::create(const Context & context)
+FunctionPtr FunctionArrayElement::create(const Context &context)
 {
     return std::make_shared<FunctionArrayElement>();
 }
 
 
-template <typename DataType>
-bool FunctionArrayElement::executeNumberConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename DataType>
+bool FunctionArrayElement::executeNumberConst(Block &block, const ColumnNumbers &arguments, size_t result,
+                                              const Field &index,
+                                              ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnVector<DataType> * col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
+    const ColumnVector<DataType> *col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -741,26 +754,29 @@ bool FunctionArrayElement::executeNumberConst(Block & block, const ColumnNumbers
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementNumImpl<DataType>::template vectorConst<false>(
-            col_nested->getData(), col_array->getOffsets(), safeGet<UInt64>(index) - 1, col_res->getData(), builder);
+                col_nested->getData(), col_array->getOffsets(), safeGet<UInt64>(index) - 1, col_res->getData(),
+                builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementNumImpl<DataType>::template vectorConst<true>(
-            col_nested->getData(), col_array->getOffsets(), -safeGet<Int64>(index) - 1, col_res->getData(), builder);
+                col_nested->getData(), col_array->getOffsets(), -safeGet<Int64>(index) - 1, col_res->getData(),
+                builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template <typename IndexType, typename DataType>
-bool FunctionArrayElement::executeNumber(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType, typename DataType>
+bool FunctionArrayElement::executeNumber(Block &block, const ColumnNumbers &arguments, size_t result,
+                                         const PaddedPODArray<IndexType> &indices,
+                                         ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnVector<DataType> * col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
+    const ColumnVector<DataType> *col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -769,20 +785,21 @@ bool FunctionArrayElement::executeNumber(Block & block, const ColumnNumbers & ar
     block.getByPosition(result).column = col_res;
 
     ArrayElementNumImpl<DataType>::template vector<IndexType>(
-        col_nested->getData(), col_array->getOffsets(), indices, col_res->getData(), builder);
+            col_nested->getData(), col_array->getOffsets(), indices, col_res->getData(), builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeStringConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
-    ArrayImpl::NullMapBuilder & builder)
+bool FunctionArrayElement::executeStringConst(Block &block, const ColumnNumbers &arguments, size_t result,
+                                              const Field &index,
+                                              ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnString * col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
+    const ColumnString *col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -792,38 +809,39 @@ bool FunctionArrayElement::executeStringConst(Block & block, const ColumnNumbers
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementStringImpl::vectorConst<false>(
-            col_nested->getChars(),
-            col_array->getOffsets(),
-            col_nested->getOffsets(),
-            safeGet<UInt64>(index) - 1,
-            col_res->getChars(),
-            col_res->getOffsets(),
-            builder);
+                col_nested->getChars(),
+                col_array->getOffsets(),
+                col_nested->getOffsets(),
+                safeGet<UInt64>(index) - 1,
+                col_res->getChars(),
+                col_res->getOffsets(),
+                builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementStringImpl::vectorConst<true>(
-            col_nested->getChars(),
-            col_array->getOffsets(),
-            col_nested->getOffsets(),
-            -safeGet<Int64>(index) - 1,
-            col_res->getChars(),
-            col_res->getOffsets(),
-            builder);
+                col_nested->getChars(),
+                col_array->getOffsets(),
+                col_nested->getOffsets(),
+                -safeGet<Int64>(index) - 1,
+                col_res->getChars(),
+                col_res->getOffsets(),
+                builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template <typename IndexType>
-bool FunctionArrayElement::executeString(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType>
+bool FunctionArrayElement::executeString(Block &block, const ColumnNumbers &arguments, size_t result,
+                                         const PaddedPODArray<IndexType> &indices,
+                                         ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnString * col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
+    const ColumnString *col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -832,64 +850,67 @@ bool FunctionArrayElement::executeString(Block & block, const ColumnNumbers & ar
     block.getByPosition(result).column = col_res;
 
     ArrayElementStringImpl::vector<IndexType>(
-        col_nested->getChars(),
-        col_array->getOffsets(),
-        col_nested->getOffsets(),
-        indices,
-        col_res->getChars(),
-        col_res->getOffsets(),
-        builder);
+            col_nested->getChars(),
+            col_array->getOffsets(),
+            col_nested->getOffsets(),
+            indices,
+            col_res->getChars(),
+            col_res->getOffsets(),
+            builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeGenericConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
-    ArrayImpl::NullMapBuilder & builder)
+bool FunctionArrayElement::executeGenericConst(Block &block, const ColumnNumbers &arguments, size_t result,
+                                               const Field &index,
+                                               ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const auto & col_nested = col_array->getData();
+    const auto &col_nested = col_array->getData();
     auto col_res = col_nested.cloneEmpty();
     block.getByPosition(result).column = col_res;
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementGenericImpl::vectorConst<false>(
-            col_nested, col_array->getOffsets(), safeGet<UInt64>(index) - 1, *col_res, builder);
+                col_nested, col_array->getOffsets(), safeGet<UInt64>(index) - 1, *col_res, builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementGenericImpl::vectorConst<true>(
-            col_nested, col_array->getOffsets(), -safeGet<Int64>(index) - 1, *col_res, builder);
+                col_nested, col_array->getOffsets(), -safeGet<Int64>(index) - 1, *col_res, builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template <typename IndexType>
-bool FunctionArrayElement::executeGeneric(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType>
+bool FunctionArrayElement::executeGeneric(Block &block, const ColumnNumbers &arguments, size_t result,
+                                          const PaddedPODArray<IndexType> &indices,
+                                          ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const auto & col_nested = col_array->getData();
+    const auto &col_nested = col_array->getData();
     auto col_res = col_nested.cloneEmpty();
     block.getByPosition(result).column = col_res;
 
     ArrayElementGenericImpl::vector<IndexType>(
-        col_nested, col_array->getOffsets(), indices, *col_res, builder);
+            col_nested, col_array->getOffsets(), indices, *col_res, builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeConstConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
-    ArrayImpl::NullMapBuilder & builder)
+bool
+FunctionArrayElement::executeConstConst(Block &block, const ColumnNumbers &arguments, size_t result, const Field &index,
+                                        ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnConst * col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst *col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
@@ -913,8 +934,8 @@ bool FunctionArrayElement::executeConstConst(Block & block, const ColumnNumbers
         value = block.getByPosition(result).type->getDefault();
 
     block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
-        block.rows(),
-        value);
+            block.rows(),
+            value);
 
     if (builder)
         builder.update(real_index);
@@ -922,11 +943,12 @@ bool FunctionArrayElement::executeConstConst(Block & block, const ColumnNumbers
     return true;
 }
 
-template <typename IndexType>
-bool FunctionArrayElement::executeConst(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType>
+bool FunctionArrayElement::executeConst(Block &block, const ColumnNumbers &arguments, size_t result,
+                                        const PaddedPODArray<IndexType> &indices,
+                                        ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnConst * col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst *col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
@@ -964,52 +986,52 @@ bool FunctionArrayElement::executeConst(Block & block, const ColumnNumbers & arg
     return true;
 }
 
-template <typename IndexType>
-bool FunctionArrayElement::executeArgument(Block & block, const ColumnNumbers & arguments, size_t result,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType>
+bool FunctionArrayElement::executeArgument(Block &block, const ColumnNumbers &arguments, size_t result,
+                                           ArrayImpl::NullMapBuilder &builder)
 {
     auto index = checkAndGetColumn<ColumnVector<IndexType>>(block.getByPosition(arguments[1]).column.get());
 
     if (!index)
         return false;
 
-    const auto & index_data = index->getData();
+    const auto &index_data = index->getData();
 
     if (builder)
         builder.initSink(index_data.size());
 
-    if (!(    executeNumber<IndexType, UInt8>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, UInt16>    (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, UInt32>    (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, UInt64>    (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Int8>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Int16>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Int32>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Int64>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Float32>    (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Float64>    (block, arguments, result, index_data, builder)
-        ||    executeConst <IndexType>            (block, arguments, result, index_data, builder)
-        ||    executeString<IndexType>            (block, arguments, result, index_data, builder)
-        ||    executeGeneric<IndexType>            (block, arguments, result, index_data, builder)))
-    throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+    if (!(executeNumber<IndexType, UInt8>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, UInt16>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, UInt32>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, UInt64>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Int8>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Int16>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Int32>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Int64>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Float32>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Float64>(block, arguments, result, index_data, builder)
+          || executeConst<IndexType>(block, arguments, result, index_data, builder)
+          || executeString<IndexType>(block, arguments, result, index_data, builder)
+          || executeGeneric<IndexType>(block, arguments, result, index_data, builder)))
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
+                        + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
 
     return true;
 }
 
-bool FunctionArrayElement::executeTuple(Block & block, const ColumnNumbers & arguments, size_t result)
+bool FunctionArrayElement::executeTuple(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    ColumnArray * col_array = typeid_cast<ColumnArray *>(block.getByPosition(arguments[0]).column.get());
+    ColumnArray *col_array = typeid_cast<ColumnArray *>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    ColumnTuple * col_nested = typeid_cast<ColumnTuple *>(&col_array->getData());
+    ColumnTuple *col_nested = typeid_cast<ColumnTuple *>(&col_array->getData());
 
     if (!col_nested)
         return false;
 
-    Block & tuple_block = col_nested->getData();
+    Block &tuple_block = col_nested->getData();
     size_t tuple_size = tuple_block.columns();
 
     /** We will calculate the function for the tuple of the internals of the array.
@@ -1032,9 +1054,9 @@ bool FunctionArrayElement::executeTuple(Block & block, const ColumnNumbers & arg
     {
         ColumnWithTypeAndName array_of_tuple_section;
         array_of_tuple_section.column = std::make_shared<ColumnArray>(
-            tuple_block.getByPosition(i).column, col_array->getOffsetsColumn());
+                tuple_block.getByPosition(i).column, col_array->getOffsetsColumn());
         array_of_tuple_section.type = std::make_shared<DataTypeArray>(
-            tuple_block.getByPosition(i).type);
+                tuple_block.getByPosition(i).type);
         block_of_temporary_results.insert(array_of_tuple_section);
 
         ColumnWithTypeAndName array_elements_of_tuple_section;
@@ -1056,26 +1078,28 @@ String FunctionArrayElement::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes &arguments) const
 {
-    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
-        throw Exception("First argument for function " + getName() + " must be array.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("First argument for function " + getName() + " must be array.",
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     if (!arguments[1]->isNumeric()
         || (!startsWith(arguments[1]->getName(), "UInt") && !startsWith(arguments[1]->getName(), "Int")))
-        throw Exception("Second argument for function " + getName() + " must have UInt or Int type.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("Second argument for function " + getName() + " must have UInt or Int type.",
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return array_type->getNestedType();
 }
 
-void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     /// Check nullability.
     bool is_nullable;
 
-    const ColumnArray * col_array = nullptr;
-    const ColumnConst * col_const_array = nullptr;
+    const ColumnArray *col_array = nullptr;
+    const ColumnConst *col_const_array = nullptr;
 
     col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (col_array)
@@ -1086,11 +1110,12 @@ void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & argu
         if (col_const_array)
         {
             Array arr = col_const_array->getValue<Array>();
-            is_nullable = std::any_of(arr.begin(), arr.end(), [](const Field & f){ return f.isNull(); });
+            is_nullable = std::any_of(arr.begin(), arr.end(), [](const Field &f)
+            { return f.isNull(); });
         }
         else
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-            + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+                            + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
     }
 
     if (!is_nullable)
@@ -1104,30 +1129,32 @@ void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & argu
         ArrayImpl::NullMapBuilder builder;
         Block source_block;
 
-        const auto & input_type = static_cast<const DataTypeNullable &>(*block.getByPosition(arguments[0]).type).getNestedType();
-        const auto & tmp_ret_type = static_cast<const DataTypeNullable &>(*block.getByPosition(result).type).getNestedType();
+        const auto &input_type = static_cast<const DataTypeNullable &>(*block.getByPosition(
+                arguments[0]).type).getNestedType();
+        const auto &tmp_ret_type = static_cast<const DataTypeNullable &>(*block.getByPosition(
+                result).type).getNestedType();
 
         Array const_array;
         if (col_array)
         {
-            const auto & nullable_col = static_cast<const ColumnNullable &>(col_array->getData());
-            const auto & nested_col = nullable_col.getNestedColumn();
+            const auto &nullable_col = static_cast<const ColumnNullable &>(col_array->getData());
+            const auto &nested_col = nullable_col.getNestedColumn();
 
             /// Put nested_col inside a ColumnArray.
             source_block =
-            {
-                {
-                    std::make_shared<ColumnArray>(nested_col, col_array->getOffsetsColumn()),
-                    std::make_shared<DataTypeArray>(input_type),
-                    ""
-                },
-                block.getByPosition(arguments[1]),
-                {
-                    nullptr,
-                    tmp_ret_type,
-                    ""
-                }
-            };
+                    {
+                            {
+                                    std::make_shared<ColumnArray>(nested_col, col_array->getOffsetsColumn()),
+                                    std::make_shared<DataTypeArray>(input_type),
+                                    ""
+                            },
+                            block.getByPosition(arguments[1]),
+                            {
+                                    nullptr,
+                                    tmp_ret_type,
+                                    ""
+                            }
+                    };
 
             builder.initSource(nullable_col);
         }
@@ -1135,15 +1162,15 @@ void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & argu
         {
             /// Almost a copy of block.
             source_block =
-            {
-                block.getByPosition(arguments[0]),
-                block.getByPosition(arguments[1]),
-                {
-                    nullptr,
-                    tmp_ret_type,
-                    ""
-                }
-            };
+                    {
+                            block.getByPosition(arguments[0]),
+                            block.getByPosition(arguments[1]),
+                            {
+                                    nullptr,
+                                    tmp_ret_type,
+                                    ""
+                            }
+                    };
 
             const_array = col_const_array->getValue<Array>();
             builder.initSource(const_array);
@@ -1152,30 +1179,30 @@ void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & argu
         perform(source_block, {0, 1}, 2, builder);
 
         /// Store the result.
-        const ColumnWithTypeAndName & source_col = source_block.getByPosition(2);
-        ColumnWithTypeAndName & dest_col = block.getByPosition(result);
+        const ColumnWithTypeAndName &source_col = source_block.getByPosition(2);
+        ColumnWithTypeAndName &dest_col = block.getByPosition(result);
         dest_col.column = std::make_shared<ColumnNullable>(source_col.column, builder.getNullMap());
     }
 }
 
-void FunctionArrayElement::perform(Block & block, const ColumnNumbers & arguments, size_t result,
-    ArrayImpl::NullMapBuilder & builder)
+void FunctionArrayElement::perform(Block &block, const ColumnNumbers &arguments, size_t result,
+                                   ArrayImpl::NullMapBuilder &builder)
 {
     if (executeTuple(block, arguments, result))
     {
     }
     else if (!block.getByPosition(arguments[1]).column->isConst())
     {
-        if (!(    executeArgument<UInt8>   (block, arguments, result, builder)
-            ||    executeArgument<UInt16>  (block, arguments, result, builder)
-            ||    executeArgument<UInt32>  (block, arguments, result, builder)
-            ||    executeArgument<UInt64>  (block, arguments, result, builder)
-            ||    executeArgument<Int8>    (block, arguments, result, builder)
-            ||    executeArgument<Int16>   (block, arguments, result, builder)
-            ||    executeArgument<Int32>   (block, arguments, result, builder)
-            ||    executeArgument<Int64>   (block, arguments, result, builder)))
-        throw Exception("Second argument for function " + getName() + " must must have UInt or Int type.",
-                        ErrorCodes::ILLEGAL_COLUMN);
+        if (!(executeArgument<UInt8>(block, arguments, result, builder)
+              || executeArgument<UInt16>(block, arguments, result, builder)
+              || executeArgument<UInt32>(block, arguments, result, builder)
+              || executeArgument<UInt64>(block, arguments, result, builder)
+              || executeArgument<Int8>(block, arguments, result, builder)
+              || executeArgument<Int16>(block, arguments, result, builder)
+              || executeArgument<Int32>(block, arguments, result, builder)
+              || executeArgument<Int64>(block, arguments, result, builder)))
+            throw Exception("Second argument for function " + getName() + " must must have UInt or Int type.",
+                            ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1187,28 +1214,28 @@ void FunctionArrayElement::perform(Block & block, const ColumnNumbers & argument
         if (index == UInt64(0))
             throw Exception("Array indices is 1-based", ErrorCodes::ZERO_ARRAY_OR_TUPLE_INDEX);
 
-        if (!(    executeNumberConst<UInt8>   (block, arguments, result, index, builder)
-            ||    executeNumberConst<UInt16>  (block, arguments, result, index, builder)
-            ||    executeNumberConst<UInt32>  (block, arguments, result, index, builder)
-            ||    executeNumberConst<UInt64>  (block, arguments, result, index, builder)
-            ||    executeNumberConst<Int8>    (block, arguments, result, index, builder)
-            ||    executeNumberConst<Int16>   (block, arguments, result, index, builder)
-            ||    executeNumberConst<Int32>   (block, arguments, result, index, builder)
-            ||    executeNumberConst<Int64>   (block, arguments, result, index, builder)
-            ||    executeNumberConst<Float32> (block, arguments, result, index, builder)
-            ||    executeNumberConst<Float64> (block, arguments, result, index, builder)
-            ||    executeConstConst           (block, arguments, result, index, builder)
-            ||    executeStringConst          (block, arguments, result, index, builder)
-            ||    executeGenericConst         (block, arguments, result, index, builder)))
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-            + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+        if (!(executeNumberConst<UInt8>(block, arguments, result, index, builder)
+              || executeNumberConst<UInt16>(block, arguments, result, index, builder)
+              || executeNumberConst<UInt32>(block, arguments, result, index, builder)
+              || executeNumberConst<UInt64>(block, arguments, result, index, builder)
+              || executeNumberConst<Int8>(block, arguments, result, index, builder)
+              || executeNumberConst<Int16>(block, arguments, result, index, builder)
+              || executeNumberConst<Int32>(block, arguments, result, index, builder)
+              || executeNumberConst<Int64>(block, arguments, result, index, builder)
+              || executeNumberConst<Float32>(block, arguments, result, index, builder)
+              || executeNumberConst<Float64>(block, arguments, result, index, builder)
+              || executeConstConst(block, arguments, result, index, builder)
+              || executeStringConst(block, arguments, result, index, builder)
+              || executeGenericConst(block, arguments, result, index, builder)))
+            throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
+                            + " of first argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_COLUMN);
     }
 }
 
 /// Implementation of FunctionArrayEnumerate.
 
-FunctionPtr FunctionArrayEnumerate::create(const Context & context)
+FunctionPtr FunctionArrayEnumerate::create(const Context &context)
 {
     return std::make_shared<FunctionArrayEnumerate>();
 }
@@ -1218,27 +1245,27 @@ String FunctionArrayEnumerate::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayEnumerate::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayEnumerate::getReturnTypeImpl(const DataTypes &arguments) const
 {
-    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("First argument for function " + getName() + " must be an array but it has type "
-            + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt32>());
 }
 
-void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayEnumerate::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    if (const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
+    if (const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
     {
-        const ColumnArray::Offsets_t & offsets = array->getOffsets();
+        const ColumnArray::Offsets_t &offsets = array->getOffsets();
 
         auto res_nested = std::make_shared<ColumnUInt32>();
         auto res_array = std::make_shared<ColumnArray>(res_nested, array->getOffsetsColumn());
         block.getByPosition(result).column = res_array;
 
-        ColumnUInt32::Container_t & res_values = res_nested->getData();
+        ColumnUInt32::Container_t &res_values = res_nested->getData();
         res_values.resize(array->getData().size());
         size_t prev_off = 0;
         for (size_t i = 0; i < offsets.size(); ++i)
@@ -1251,7 +1278,8 @@ void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & ar
             prev_off = off;
         }
     }
-    else if (const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
+    else if (const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(
+            block.getByPosition(arguments[0]).column.get()))
     {
         Array values = array->getValue<Array>();
 
@@ -1261,50 +1289,53 @@ void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & ar
             res_values[i] = i + 1;
         }
 
-        block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(), res_values);
+        block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(),
+                                                                                                 res_values);
     }
     else
     {
         throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+                        + " of first argument of function " + getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
     }
 }
 
 /// Implementation of FunctionArrayUniq.
 
-FunctionPtr FunctionArrayUniq::create(const Context & context) { return std::make_shared<FunctionArrayUniq>(); }
+FunctionPtr FunctionArrayUniq::create(const Context &context)
+{ return std::make_shared<FunctionArrayUniq>(); }
 
 String FunctionArrayUniq::getName() const
 {
     return name;
 }
 
-DataTypePtr FunctionArrayUniq::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayUniq::getReturnTypeImpl(const DataTypes &arguments) const
 {
     if (arguments.size() == 0)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-            + toString(arguments.size()) + ", should be at least 1.",
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                        + toString(arguments.size()) + ", should be at least 1.",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     for (size_t i = 0; i < arguments.size(); ++i)
     {
-        const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
+        const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
         if (!array_type)
             throw Exception("All arguments for function " + getName() + " must be arrays but argument " +
-                toString(i + 1) + " has type " + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                            toString(i + 1) + " has type " + arguments[i]->getName() + ".",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return std::make_shared<DataTypeUInt32>();
 }
 
-void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     if (arguments.size() == 1 && executeConst(block, arguments, result))
         return;
 
     Columns array_columns(arguments.size());
-    const ColumnArray::Offsets_t * offsets = nullptr;
+    const ColumnArray::Offsets_t *offsets = nullptr;
     ConstColumnPlainPtrs data_columns(arguments.size());
     ConstColumnPlainPtrs original_data_columns(arguments.size());
     ConstColumnPlainPtrs null_maps(arguments.size());
@@ -1314,27 +1345,28 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen
     for (size_t i = 0; i < arguments.size(); ++i)
     {
         ColumnPtr array_ptr = block.getByPosition(arguments[i]).column;
-        const ColumnArray * array = checkAndGetColumn<ColumnArray>(array_ptr.get());
+        const ColumnArray *array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         if (!array)
         {
-            const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(
-                block.getByPosition(arguments[i]).column.get());
+            const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
+                    block.getByPosition(arguments[i]).column.get());
             if (!const_array)
                 throw Exception("Illegal column " + block.getByPosition(arguments[i]).column->getName()
-                    + " of " + toString(i + 1) + getOrdinalSuffix(i + 1) + " argument of function " + getName(),
-                    ErrorCodes::ILLEGAL_COLUMN);
+                                + " of " + toString(i + 1) + getOrdinalSuffix(i + 1) + " argument of function " +
+                                getName(),
+                                ErrorCodes::ILLEGAL_COLUMN);
             array_ptr = const_array->convertToFullColumn();
             array = static_cast<const ColumnArray *>(array_ptr.get());
         }
 
         array_columns[i] = array_ptr;
 
-        const ColumnArray::Offsets_t & offsets_i = array->getOffsets();
+        const ColumnArray::Offsets_t &offsets_i = array->getOffsets();
         if (i == 0)
             offsets = &offsets_i;
         else if (offsets_i != *offsets)
             throw Exception("Lengths of all arrays passsed to " + getName() + " must be equal.",
-                ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
+                            ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
 
         data_columns[i] = &array->getData();
         original_data_columns[i] = data_columns[i];
@@ -1342,7 +1374,7 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen
         if (data_columns[i]->isNullable())
         {
             has_nullable_columns = true;
-            const auto & nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
+            const auto &nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
             data_columns[i] = nullable_col.getNestedColumn().get();
             null_maps[i] = nullable_col.getNullMapColumn().get();
         }
@@ -1350,30 +1382,30 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen
             null_maps[i] = nullptr;
     }
 
-    const ColumnArray * first_array = static_cast<const ColumnArray *>(array_columns[0].get());
-    const IColumn * first_null_map = null_maps[0];
+    const ColumnArray *first_array = static_cast<const ColumnArray *>(array_columns[0].get());
+    const IColumn *first_null_map = null_maps[0];
     auto res = std::make_shared<ColumnUInt32>();
     block.getByPosition(result).column = res;
 
-    ColumnUInt32::Container_t & res_values = res->getData();
+    ColumnUInt32::Container_t &res_values = res->getData();
     res_values.resize(offsets->size());
 
     if (arguments.size() == 1)
     {
-        if (!(    executeNumber<UInt8>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt16>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt64>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int8>        (first_array, first_null_map, res_values)
-            ||    executeNumber<Int16>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int64>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Float32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Float64>    (first_array, first_null_map, res_values)
-            ||    executeString            (first_array, first_null_map, res_values)))
+        if (!(executeNumber<UInt8>(first_array, first_null_map, res_values)
+              || executeNumber<UInt16>(first_array, first_null_map, res_values)
+              || executeNumber<UInt32>(first_array, first_null_map, res_values)
+              || executeNumber<UInt64>(first_array, first_null_map, res_values)
+              || executeNumber<Int8>(first_array, first_null_map, res_values)
+              || executeNumber<Int16>(first_array, first_null_map, res_values)
+              || executeNumber<Int32>(first_array, first_null_map, res_values)
+              || executeNumber<Int64>(first_array, first_null_map, res_values)
+              || executeNumber<Float32>(first_array, first_null_map, res_values)
+              || executeNumber<Float64>(first_array, first_null_map, res_values)
+              || executeString(first_array, first_null_map, res_values)))
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                    + " of first argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN);
+                            + " of first argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1382,30 +1414,31 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen
     }
 }
 
-template <typename T>
-bool FunctionArrayUniq::executeNumber(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
+template<typename T>
+bool FunctionArrayUniq::executeNumber(const ColumnArray *array, const IColumn *null_map,
+                                      ColumnUInt32::Container_t &res_values)
 {
-    const IColumn * inner_col;
+    const IColumn *inner_col;
 
-    const auto & array_data = array->getData();
+    const auto &array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnVector<T> * nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
+    const ColumnVector<T> *nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
-    const typename ColumnVector<T>::Container_t & values = nested->getData();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    const typename ColumnVector<T>::Container_t &values = nested->getData();
 
     using Set = ClearableHashSet<T, DefaultHash<T>, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
 
-    const PaddedPODArray<UInt8> * null_map_data = nullptr;
+    const PaddedPODArray<UInt8> *null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1430,28 +1463,29 @@ bool FunctionArrayUniq::executeNumber(const ColumnArray * array, const IColumn *
     return true;
 }
 
-bool FunctionArrayUniq::executeString(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
+bool FunctionArrayUniq::executeString(const ColumnArray *array, const IColumn *null_map,
+                                      ColumnUInt32::Container_t &res_values)
 {
-    const IColumn * inner_col;
+    const IColumn *inner_col;
 
-    const auto & array_data = array->getData();
+    const auto &array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnString * nested = checkAndGetColumn<ColumnString>(inner_col);
+    const ColumnString *nested = checkAndGetColumn<ColumnString>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
 
     using Set = ClearableHashSet<StringRef, StringRefHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
 
-    const PaddedPODArray<UInt8> * null_map_data = nullptr;
+    const PaddedPODArray<UInt8> *null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1476,9 +1510,9 @@ bool FunctionArrayUniq::executeString(const ColumnArray * array, const IColumn *
     return true;
 }
 
-bool FunctionArrayUniq::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
+bool FunctionArrayUniq::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
         return false;
     Array values = array->getValue<Array>();
@@ -1492,11 +1526,11 @@ bool FunctionArrayUniq::executeConst(Block & block, const ColumnNumbers & argume
 }
 
 bool FunctionArrayUniq::execute128bit(
-    const ColumnArray::Offsets_t & offsets,
-    const ConstColumnPlainPtrs & columns,
-    const ConstColumnPlainPtrs & null_maps,
-    ColumnUInt32::Container_t & res_values,
-    bool has_nullable_columns)
+        const ColumnArray::Offsets_t &offsets,
+        const ConstColumnPlainPtrs &columns,
+        const ConstColumnPlainPtrs &null_maps,
+        ColumnUInt32::Container_t &res_values,
+        bool has_nullable_columns)
 {
     size_t count = columns.size();
     size_t keys_bytes = 0;
@@ -1516,7 +1550,7 @@ bool FunctionArrayUniq::execute128bit(
         return false;
 
     using Set = ClearableHashSet<UInt128, UInt128HashCRC32, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     /// Suppose that, for a given row, each of the N columns has an array whose length is M.
     /// Denote arr_i each of these arrays (1 <= i <= N). Then the following is performed:
@@ -1547,7 +1581,7 @@ bool FunctionArrayUniq::execute128bit(
                 {
                     if (null_maps[i])
                     {
-                        const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
+                        const auto &null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
                         if (null_map[j] == 1)
                         {
                             size_t bucket = i / 8;
@@ -1570,14 +1604,14 @@ bool FunctionArrayUniq::execute128bit(
 }
 
 void FunctionArrayUniq::executeHashed(
-    const ColumnArray::Offsets_t & offsets,
-    const ConstColumnPlainPtrs & columns,
-    ColumnUInt32::Container_t & res_values)
+        const ColumnArray::Offsets_t &offsets,
+        const ConstColumnPlainPtrs &columns,
+        ColumnUInt32::Container_t &res_values)
 {
     size_t count = columns.size();
 
     using Set = ClearableHashSet<UInt128, UInt128TrivialHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     Set set;
     size_t prev_off = 0;
@@ -1595,7 +1629,7 @@ void FunctionArrayUniq::executeHashed(
 
 /// Implementation of FunctionArrayEnumerateUniq.
 
-FunctionPtr FunctionArrayEnumerateUniq::create(const Context & context)
+FunctionPtr FunctionArrayEnumerateUniq::create(const Context &context)
 {
     return std::make_shared<FunctionArrayEnumerateUniq>();
 }
@@ -1605,31 +1639,32 @@ String FunctionArrayEnumerateUniq::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayEnumerateUniq::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayEnumerateUniq::getReturnTypeImpl(const DataTypes &arguments) const
 {
     if (arguments.size() == 0)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-            + toString(arguments.size()) + ", should be at least 1.",
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                        + toString(arguments.size()) + ", should be at least 1.",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     for (size_t i = 0; i < arguments.size(); ++i)
     {
-        const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
+        const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
         if (!array_type)
             throw Exception("All arguments for function " + getName() + " must be arrays but argument " +
-                toString(i + 1) + " has type " + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                            toString(i + 1) + " has type " + arguments[i]->getName() + ".",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt32>());
 }
 
-void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     if (arguments.size() == 1 && executeConst(block, arguments, result))
         return;
 
     Columns array_columns(arguments.size());
-    const ColumnArray::Offsets_t * offsets = nullptr;
+    const ColumnArray::Offsets_t *offsets = nullptr;
     ConstColumnPlainPtrs data_columns(arguments.size());
     ConstColumnPlainPtrs original_data_columns(arguments.size());
     ConstColumnPlainPtrs null_maps(arguments.size());
@@ -1639,25 +1674,25 @@ void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers
     for (size_t i = 0; i < arguments.size(); ++i)
     {
         ColumnPtr array_ptr = block.getByPosition(arguments[i]).column;
-        const ColumnArray * array = checkAndGetColumn<ColumnArray>(array_ptr.get());
+        const ColumnArray *array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         if (!array)
         {
-            const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(
-                block.getByPosition(arguments[i]).column.get());
+            const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
+                    block.getByPosition(arguments[i]).column.get());
             if (!const_array)
                 throw Exception("Illegal column " + block.getByPosition(arguments[i]).column->getName()
-                    + " of " + toString(i + 1) + "-th argument of function " + getName(),
-                    ErrorCodes::ILLEGAL_COLUMN);
+                                + " of " + toString(i + 1) + "-th argument of function " + getName(),
+                                ErrorCodes::ILLEGAL_COLUMN);
             array_ptr = const_array->convertToFullColumn();
             array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         }
         array_columns[i] = array_ptr;
-        const ColumnArray::Offsets_t & offsets_i = array->getOffsets();
+        const ColumnArray::Offsets_t &offsets_i = array->getOffsets();
         if (i == 0)
             offsets = &offsets_i;
         else if (offsets_i != *offsets)
             throw Exception("Lengths of all arrays passsed to " + getName() + " must be equal.",
-                ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
+                            ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
 
         data_columns[i] = &array->getData();
         original_data_columns[i] = data_columns[i];
@@ -1665,7 +1700,7 @@ void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers
         if (data_columns[i]->isNullable())
         {
             has_nullable_columns = true;
-            const auto & nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
+            const auto &nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
             data_columns[i] = nullable_col.getNestedColumn().get();
             null_maps[i] = nullable_col.getNullMapColumn().get();
         }
@@ -1673,32 +1708,32 @@ void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers
             null_maps[i] = nullptr;
     }
 
-    const ColumnArray * first_array = checkAndGetColumn<ColumnArray>(array_columns[0].get());
-    const IColumn * first_null_map = null_maps[0];
+    const ColumnArray *first_array = checkAndGetColumn<ColumnArray>(array_columns[0].get());
+    const IColumn *first_null_map = null_maps[0];
     auto res_nested = std::make_shared<ColumnUInt32>();
     auto res_array = std::make_shared<ColumnArray>(res_nested, first_array->getOffsetsColumn());
     block.getByPosition(result).column = res_array;
 
-    ColumnUInt32::Container_t & res_values = res_nested->getData();
+    ColumnUInt32::Container_t &res_values = res_nested->getData();
     if (!offsets->empty())
         res_values.resize(offsets->back());
 
     if (arguments.size() == 1)
     {
-        if (!(    executeNumber<UInt8>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt16>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt64>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int8>        (first_array, first_null_map, res_values)
-            ||    executeNumber<Int16>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int64>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Float32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Float64>    (first_array, first_null_map, res_values)
-            ||    executeString            (first_array, first_null_map, res_values)))
+        if (!(executeNumber<UInt8>(first_array, first_null_map, res_values)
+              || executeNumber<UInt16>(first_array, first_null_map, res_values)
+              || executeNumber<UInt32>(first_array, first_null_map, res_values)
+              || executeNumber<UInt64>(first_array, first_null_map, res_values)
+              || executeNumber<Int8>(first_array, first_null_map, res_values)
+              || executeNumber<Int16>(first_array, first_null_map, res_values)
+              || executeNumber<Int32>(first_array, first_null_map, res_values)
+              || executeNumber<Int64>(first_array, first_null_map, res_values)
+              || executeNumber<Float32>(first_array, first_null_map, res_values)
+              || executeNumber<Float64>(first_array, first_null_map, res_values)
+              || executeString(first_array, first_null_map, res_values)))
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                    + " of first argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN);
+                            + " of first argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1708,30 +1743,31 @@ void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers
 }
 
 
-template <typename T>
-bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
+template<typename T>
+bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray *array, const IColumn *null_map,
+                                               ColumnUInt32::Container_t &res_values)
 {
-    const IColumn * inner_col;
+    const IColumn *inner_col;
 
-    const auto & array_data = array->getData();
+    const auto &array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnVector<T> * nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
+    const ColumnVector<T> *nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
-    const typename ColumnVector<T>::Container_t & values = nested->getData();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    const typename ColumnVector<T>::Container_t &values = nested->getData();
 
     using ValuesToIndices = ClearableHashMap<T, UInt32, DefaultHash<T>, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
 
-    const PaddedPODArray<UInt8> * null_map_data = nullptr;
+    const PaddedPODArray<UInt8> *null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1754,29 +1790,30 @@ bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray * array, const
     return true;
 }
 
-bool FunctionArrayEnumerateUniq::executeString(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
+bool FunctionArrayEnumerateUniq::executeString(const ColumnArray *array, const IColumn *null_map,
+                                               ColumnUInt32::Container_t &res_values)
 {
-    const IColumn * inner_col;
+    const IColumn *inner_col;
 
-    const auto & array_data = array->getData();
+    const auto &array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnString * nested = checkAndGetColumn<ColumnString>(inner_col);
+    const ColumnString *nested = checkAndGetColumn<ColumnString>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
 
     size_t prev_off = 0;
     using ValuesToIndices = ClearableHashMap<StringRef, UInt32, StringRefHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
 
-    const PaddedPODArray<UInt8> * null_map_data = nullptr;
+    const PaddedPODArray<UInt8> *null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1798,9 +1835,9 @@ bool FunctionArrayEnumerateUniq::executeString(const ColumnArray * array, const
     return true;
 }
 
-bool FunctionArrayEnumerateUniq::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
+bool FunctionArrayEnumerateUniq::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
         return false;
     Array values = array->getValue<Array>();
@@ -1818,11 +1855,11 @@ bool FunctionArrayEnumerateUniq::executeConst(Block & block, const ColumnNumbers
 }
 
 bool FunctionArrayEnumerateUniq::execute128bit(
-    const ColumnArray::Offsets_t & offsets,
-    const ConstColumnPlainPtrs & columns,
-    const ConstColumnPlainPtrs & null_maps,
-    ColumnUInt32::Container_t & res_values,
-    bool has_nullable_columns)
+        const ColumnArray::Offsets_t &offsets,
+        const ConstColumnPlainPtrs &columns,
+        const ConstColumnPlainPtrs &null_maps,
+        ColumnUInt32::Container_t &res_values,
+        bool has_nullable_columns)
 {
     size_t count = columns.size();
     size_t keys_bytes = 0;
@@ -1842,7 +1879,7 @@ bool FunctionArrayEnumerateUniq::execute128bit(
         return false;
 
     using ValuesToIndices = ClearableHashMap<UInt128, UInt32, UInt128HashCRC32, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     ValuesToIndices indices;
     size_t prev_off = 0;
@@ -1860,7 +1897,7 @@ bool FunctionArrayEnumerateUniq::execute128bit(
                 {
                     if (null_maps[i])
                     {
-                        const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
+                        const auto &null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
                         if (null_map[j] == 1)
                         {
                             size_t bucket = i / 8;
@@ -1881,14 +1918,14 @@ bool FunctionArrayEnumerateUniq::execute128bit(
 }
 
 void FunctionArrayEnumerateUniq::executeHashed(
-    const ColumnArray::Offsets_t & offsets,
-    const ConstColumnPlainPtrs & columns,
-    ColumnUInt32::Container_t & res_values)
+        const ColumnArray::Offsets_t &offsets,
+        const ConstColumnPlainPtrs &columns,
+        ColumnUInt32::Container_t &res_values)
 {
     size_t count = columns.size();
 
     using ValuesToIndices = ClearableHashMap<UInt128, UInt32, UInt128TrivialHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     ValuesToIndices indices;
     size_t prev_off = 0;
@@ -1906,19 +1943,20 @@ void FunctionArrayEnumerateUniq::executeHashed(
 
 /// Implementation of FunctionEmptyArrayToSingle.
 
-FunctionPtr FunctionEmptyArrayToSingle::create(const Context & context) { return std::make_shared<FunctionEmptyArrayToSingle>(); }
+FunctionPtr FunctionEmptyArrayToSingle::create(const Context &context)
+{ return std::make_shared<FunctionEmptyArrayToSingle>(); }
 
 String FunctionEmptyArrayToSingle::getName() const
 {
     return name;
 }
 
-DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes &arguments) const
 {
-    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("Argument for function " + getName() + " must be array.",
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return arguments[0]->clone();
 }
@@ -1926,347 +1964,366 @@ DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes & argu
 
 namespace
 {
-    namespace FunctionEmptyArrayToSingleImpl
+namespace FunctionEmptyArrayToSingleImpl
+{
+bool executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
+{
+    if (const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
+            block.getByPosition(arguments[0]).column.get()))
     {
-        bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
+        if (const_array->getValue<Array>().empty())
         {
-            if (const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
-            {
-                if (const_array->getValue<Array>().empty())
-                {
-                    auto nested_type = typeid_cast<const DataTypeArray &>(*block.getByPosition(arguments[0]).type).getNestedType();
+            auto nested_type = typeid_cast<const DataTypeArray &>(
+                    *block.getByPosition(arguments[0]).type).getNestedType();
 
-                    block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
-                        block.rows(),
-                        Array{nested_type->getDefault()});
-                }
-                else
-                    block.getByPosition(result).column = block.getByPosition(arguments[0]).column;
-
-                return true;
-            }
-            else
-                return false;
+            block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
+                    block.rows(),
+                    Array{nested_type->getDefault()});
         }
+        else
+            block.getByPosition(result).column = block.getByPosition(arguments[0]).column;
 
-        template <typename T, bool nullable>
-        bool executeNumber(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-            IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
+        return true;
+    }
+    else
+        return false;
+}
+
+template<typename T, bool nullable>
+bool executeNumber(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data_col, ColumnArray::Offsets_t &res_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    if (const ColumnVector<T> *src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
+    {
+        const PaddedPODArray<T> &src_data = src_data_concrete->getData();
+        PaddedPODArray<T> &res_data = static_cast<ColumnVector<T> &>(res_data_col).getData();
+
+        size_t size = src_offsets.size();
+        res_offsets.resize(size);
+        res_data.reserve(src_data.size());
+
+        if (nullable)
+            res_null_map->reserve(src_null_map->size());
+
+        ColumnArray::Offset_t src_prev_offset = 0;
+        ColumnArray::Offset_t res_prev_offset = 0;
+
+        for (size_t i = 0; i < size; ++i)
         {
-            if (const ColumnVector<T> * src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
+            if (src_offsets[i] != src_prev_offset)
             {
-                const PaddedPODArray<T> & src_data = src_data_concrete->getData();
-                PaddedPODArray<T> & res_data = static_cast<ColumnVector<T> &>(res_data_col).getData();
-
-                size_t size = src_offsets.size();
-                res_offsets.resize(size);
-                res_data.reserve(src_data.size());
+                size_t size_to_write = src_offsets[i] - src_prev_offset;
+                res_data.resize(res_prev_offset + size_to_write);
+                memcpy(&res_data[res_prev_offset], &src_data[src_prev_offset], size_to_write * sizeof(T));
 
                 if (nullable)
-                    res_null_map->reserve(src_null_map->size());
-
-                ColumnArray::Offset_t src_prev_offset = 0;
-                ColumnArray::Offset_t res_prev_offset = 0;
-
-                for (size_t i = 0; i < size; ++i)
                 {
-                    if (src_offsets[i] != src_prev_offset)
-                    {
-                        size_t size_to_write = src_offsets[i] - src_prev_offset;
-                        res_data.resize(res_prev_offset + size_to_write);
-                        memcpy(&res_data[res_prev_offset], &src_data[src_prev_offset], size_to_write * sizeof(T));
-
-                        if (nullable)
-                        {
-                            res_null_map->resize(res_prev_offset + size_to_write);
-                            memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
-                        }
-
-                        res_prev_offset += size_to_write;
-                        res_offsets[i] = res_prev_offset;
-                    }
-                    else
-                    {
-                        res_data.push_back(T());
-                        ++res_prev_offset;
-                        res_offsets[i] = res_prev_offset;
-
-                        if (nullable)
-                            res_null_map->push_back(1); /// Push NULL.
-                    }
-
-                    src_prev_offset = src_offsets[i];
+                    res_null_map->resize(res_prev_offset + size_to_write);
+                    memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
                 }
 
-                return true;
+                res_prev_offset += size_to_write;
+                res_offsets[i] = res_prev_offset;
             }
             else
-                return false;
-        }
-
-
-        template <bool nullable>
-        bool executeFixedString(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-            IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
-        {
-            if (const ColumnFixedString * src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
             {
-                const size_t n = src_data_concrete->getN();
-                const ColumnFixedString::Chars_t & src_data = src_data_concrete->getChars();
-
-                auto concrete_res_data = typeid_cast<ColumnFixedString *>(&res_data_col);
-                if (!concrete_res_data)
-                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-
-                ColumnFixedString::Chars_t & res_data = concrete_res_data->getChars();
-                size_t size = src_offsets.size();
-                res_offsets.resize(size);
-                res_data.reserve(src_data.size());
+                res_data.push_back(T());
+                ++res_prev_offset;
+                res_offsets[i] = res_prev_offset;
 
                 if (nullable)
-                    res_null_map->reserve(src_null_map->size());
-
-                ColumnArray::Offset_t src_prev_offset = 0;
-                ColumnArray::Offset_t res_prev_offset = 0;
-
-                for (size_t i = 0; i < size; ++i)
-                {
-                    if (src_offsets[i] != src_prev_offset)
-                    {
-                        size_t size_to_write = src_offsets[i] - src_prev_offset;
-                        size_t prev_res_data_size = res_data.size();
-                        res_data.resize(prev_res_data_size + size_to_write * n);
-                        memcpy(&res_data[prev_res_data_size], &src_data[src_prev_offset * n], size_to_write * n);
-
-                        if (nullable)
-                        {
-                            res_null_map->resize(res_prev_offset + size_to_write);
-                            memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
-                        }
-
-                        res_prev_offset += size_to_write;
-                        res_offsets[i] = res_prev_offset;
-                    }
-                    else
-                    {
-                        size_t prev_res_data_size = res_data.size();
-                        res_data.resize(prev_res_data_size + n);
-                        memset(&res_data[prev_res_data_size], 0, n);
-                        ++res_prev_offset;
-                        res_offsets[i] = res_prev_offset;
-
-                        if (nullable)
-                            res_null_map->push_back(1);
-                    }
-
-                    src_prev_offset = src_offsets[i];
-                }
-
-                return true;
+                    res_null_map->push_back(1); /// Push NULL.
             }
-            else
-                return false;
+
+            src_prev_offset = src_offsets[i];
         }
 
+        return true;
+    }
+    else
+        return false;
+}
 
-        template <bool nullable>
-        bool executeString(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
-            IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
+
+template<bool nullable>
+bool executeFixedString(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data_col, ColumnArray::Offsets_t &res_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    if (const ColumnFixedString *src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
+    {
+        const size_t n = src_data_concrete->getN();
+        const ColumnFixedString::Chars_t &src_data = src_data_concrete->getChars();
+
+        auto concrete_res_data = typeid_cast<ColumnFixedString *>(&res_data_col);
+        if (!concrete_res_data)
+            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+
+        ColumnFixedString::Chars_t &res_data = concrete_res_data->getChars();
+        size_t size = src_offsets.size();
+        res_offsets.resize(size);
+        res_data.reserve(src_data.size());
+
+        if (nullable)
+            res_null_map->reserve(src_null_map->size());
+
+        ColumnArray::Offset_t src_prev_offset = 0;
+        ColumnArray::Offset_t res_prev_offset = 0;
+
+        for (size_t i = 0; i < size; ++i)
         {
-            if (const ColumnString * src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+            if (src_offsets[i] != src_prev_offset)
             {
-                const ColumnString::Offsets_t & src_string_offsets = src_data_concrete->getOffsets();
-
-                auto concrete_res_string_offsets = typeid_cast<ColumnString *>(&res_data_col);
-                if (!concrete_res_string_offsets)
-                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-                ColumnString::Offsets_t & res_string_offsets = concrete_res_string_offsets->getOffsets();
-
-                const ColumnString::Chars_t & src_data = src_data_concrete->getChars();
-
-                auto concrete_res_data = typeid_cast<ColumnString *>(&res_data_col);
-                if (!concrete_res_data)
-                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-                ColumnString::Chars_t & res_data = concrete_res_data->getChars();
-
-                size_t size = src_array_offsets.size();
-                res_array_offsets.resize(size);
-                res_string_offsets.reserve(src_string_offsets.size());
-                res_data.reserve(src_data.size());
+                size_t size_to_write = src_offsets[i] - src_prev_offset;
+                size_t prev_res_data_size = res_data.size();
+                res_data.resize(prev_res_data_size + size_to_write * n);
+                memcpy(&res_data[prev_res_data_size], &src_data[src_prev_offset * n], size_to_write * n);
 
                 if (nullable)
-                    res_null_map->reserve(src_null_map->size());
-
-                ColumnArray::Offset_t src_array_prev_offset = 0;
-                ColumnArray::Offset_t res_array_prev_offset = 0;
-
-                ColumnString::Offset_t src_string_prev_offset = 0;
-                ColumnString::Offset_t res_string_prev_offset = 0;
-
-                for (size_t i = 0; i < size; ++i)
                 {
-                    if (src_array_offsets[i] != src_array_prev_offset)
-                    {
-                        size_t array_size = src_array_offsets[i] - src_array_prev_offset;
-
-                        size_t bytes_to_copy = 0;
-                        size_t from_string_prev_offset_local = src_string_prev_offset;
-                        for (size_t j = 0; j < array_size; ++j)
-                        {
-                            size_t string_size = src_string_offsets[src_array_prev_offset + j] - from_string_prev_offset_local;
-
-                            res_string_prev_offset += string_size;
-                            res_string_offsets.push_back(res_string_prev_offset);
-
-                            from_string_prev_offset_local += string_size;
-                            bytes_to_copy += string_size;
-                        }
-
-                        size_t res_data_old_size = res_data.size();
-                        res_data.resize(res_data_old_size + bytes_to_copy);
-                        memcpy(&res_data[res_data_old_size], &src_data[src_string_prev_offset], bytes_to_copy);
-
-                        if (nullable)
-                        {
-                            res_null_map->resize(res_array_prev_offset + array_size);
-                            memcpy(&(*res_null_map)[res_array_prev_offset], &(*src_null_map)[src_array_prev_offset], array_size);
-                        }
-
-                        res_array_prev_offset += array_size;
-                        res_array_offsets[i] = res_array_prev_offset;
-                    }
-                    else
-                    {
-                        res_data.push_back(0);  /// An empty string, including zero at the end.
-
-                        if (nullable)
-                            res_null_map->push_back(1);
-
-                        ++res_string_prev_offset;
-                        res_string_offsets.push_back(res_string_prev_offset);
-
-                        ++res_array_prev_offset;
-                        res_array_offsets[i] = res_array_prev_offset;
-                    }
-
-                    src_array_prev_offset = src_array_offsets[i];
-
-                    if (src_array_prev_offset)
-                        src_string_prev_offset = src_string_offsets[src_array_prev_offset - 1];
+                    res_null_map->resize(res_prev_offset + size_to_write);
+                    memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
                 }
 
-                return true;
+                res_prev_offset += size_to_write;
+                res_offsets[i] = res_prev_offset;
             }
             else
-                return false;
+            {
+                size_t prev_res_data_size = res_data.size();
+                res_data.resize(prev_res_data_size + n);
+                memset(&res_data[prev_res_data_size], 0, n);
+                ++res_prev_offset;
+                res_offsets[i] = res_prev_offset;
+
+                if (nullable)
+                    res_null_map->push_back(1);
+            }
+
+            src_prev_offset = src_offsets[i];
         }
 
+        return true;
+    }
+    else
+        return false;
+}
 
-        template <bool nullable>
-        void executeGeneric(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-            IColumn & res_data, ColumnArray::Offsets_t & res_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
+
+template<bool nullable>
+bool executeString(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
+        IColumn &res_data_col, ColumnArray::Offsets_t &res_array_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    if (const ColumnString *src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+    {
+        const ColumnString::Offsets_t &src_string_offsets = src_data_concrete->getOffsets();
+
+        auto concrete_res_string_offsets = typeid_cast<ColumnString *>(&res_data_col);
+        if (!concrete_res_string_offsets)
+            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+        ColumnString::Offsets_t &res_string_offsets = concrete_res_string_offsets->getOffsets();
+
+        const ColumnString::Chars_t &src_data = src_data_concrete->getChars();
+
+        auto concrete_res_data = typeid_cast<ColumnString *>(&res_data_col);
+        if (!concrete_res_data)
+            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+        ColumnString::Chars_t &res_data = concrete_res_data->getChars();
+
+        size_t size = src_array_offsets.size();
+        res_array_offsets.resize(size);
+        res_string_offsets.reserve(src_string_offsets.size());
+        res_data.reserve(src_data.size());
+
+        if (nullable)
+            res_null_map->reserve(src_null_map->size());
+
+        ColumnArray::Offset_t src_array_prev_offset = 0;
+        ColumnArray::Offset_t res_array_prev_offset = 0;
+
+        ColumnString::Offset_t src_string_prev_offset = 0;
+        ColumnString::Offset_t res_string_prev_offset = 0;
+
+        for (size_t i = 0; i < size; ++i)
         {
-            size_t size = src_offsets.size();
-            res_offsets.resize(size);
-            res_data.reserve(src_data.size());
+            if (src_array_offsets[i] != src_array_prev_offset)
+            {
+                size_t array_size = src_array_offsets[i] - src_array_prev_offset;
+
+                size_t bytes_to_copy = 0;
+                size_t from_string_prev_offset_local = src_string_prev_offset;
+                for (size_t j = 0; j < array_size; ++j)
+                {
+                    size_t string_size = src_string_offsets[src_array_prev_offset + j] - from_string_prev_offset_local;
+
+                    res_string_prev_offset += string_size;
+                    res_string_offsets.push_back(res_string_prev_offset);
+
+                    from_string_prev_offset_local += string_size;
+                    bytes_to_copy += string_size;
+                }
+
+                size_t res_data_old_size = res_data.size();
+                res_data.resize(res_data_old_size + bytes_to_copy);
+                memcpy(&res_data[res_data_old_size], &src_data[src_string_prev_offset], bytes_to_copy);
+
+                if (nullable)
+                {
+                    res_null_map->resize(res_array_prev_offset + array_size);
+                    memcpy(&(*res_null_map)[res_array_prev_offset], &(*src_null_map)[src_array_prev_offset],
+                           array_size);
+                }
+
+                res_array_prev_offset += array_size;
+                res_array_offsets[i] = res_array_prev_offset;
+            }
+            else
+            {
+                res_data.push_back(0);  /// An empty string, including zero at the end.
+
+                if (nullable)
+                    res_null_map->push_back(1);
+
+                ++res_string_prev_offset;
+                res_string_offsets.push_back(res_string_prev_offset);
+
+                ++res_array_prev_offset;
+                res_array_offsets[i] = res_array_prev_offset;
+            }
+
+            src_array_prev_offset = src_array_offsets[i];
+
+            if (src_array_prev_offset)
+                src_string_prev_offset = src_string_offsets[src_array_prev_offset - 1];
+        }
+
+        return true;
+    }
+    else
+        return false;
+}
+
+
+template<bool nullable>
+void executeGeneric(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data, ColumnArray::Offsets_t &res_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    size_t size = src_offsets.size();
+    res_offsets.resize(size);
+    res_data.reserve(src_data.size());
+
+    if (nullable)
+        res_null_map->reserve(src_null_map->size());
+
+    ColumnArray::Offset_t src_prev_offset = 0;
+    ColumnArray::Offset_t res_prev_offset = 0;
+
+    for (size_t i = 0; i < size; ++i)
+    {
+        if (src_offsets[i] != src_prev_offset)
+        {
+            size_t size_to_write = src_offsets[i] - src_prev_offset;
+            res_data.insertRangeFrom(src_data, src_prev_offset, size_to_write);
 
             if (nullable)
-                res_null_map->reserve(src_null_map->size());
-
-            ColumnArray::Offset_t src_prev_offset = 0;
-            ColumnArray::Offset_t res_prev_offset = 0;
-
-            for (size_t i = 0; i < size; ++i)
             {
-                if (src_offsets[i] != src_prev_offset)
-                {
-                    size_t size_to_write = src_offsets[i] - src_prev_offset;
-                    res_data.insertRangeFrom(src_data, src_prev_offset, size_to_write);
-
-                    if (nullable)
-                    {
-                        res_null_map->resize(res_prev_offset + size_to_write);
-                        memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
-                    }
-
-                    res_prev_offset += size_to_write;
-                    res_offsets[i] = res_prev_offset;
-                }
-                else
-                {
-                    res_data.insertDefault();
-                    ++res_prev_offset;
-                    res_offsets[i] = res_prev_offset;
-
-                    if (nullable)
-                        res_null_map->push_back(1);
-                }
-
-                src_prev_offset = src_offsets[i];
+                res_null_map->resize(res_prev_offset + size_to_write);
+                memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
             }
+
+            res_prev_offset += size_to_write;
+            res_offsets[i] = res_prev_offset;
         }
-
-
-        template <bool nullable>
-        void executeDispatch(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
-            IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
+        else
         {
-            if (!( executeNumber<UInt8, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<UInt16, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<UInt32, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<UInt64, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Int8, nullable>   (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Int16, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Int32, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Int64, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Float32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Float64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeString<nullable>         (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeFixedString<nullable>    (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)))
-                executeGeneric<nullable>           (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map);
+            res_data.insertDefault();
+            ++res_prev_offset;
+            res_offsets[i] = res_prev_offset;
+
+            if (nullable)
+                res_null_map->push_back(1);
         }
+
+        src_prev_offset = src_offsets[i];
     }
 }
 
-void FunctionEmptyArrayToSingle::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+
+template<bool nullable>
+void executeDispatch(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
+        IColumn &res_data_col, ColumnArray::Offsets_t &res_array_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    if (!(executeNumber<UInt8, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                         res_null_map)
+          || executeNumber<UInt16, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                             res_null_map)
+          || executeNumber<UInt32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                             res_null_map)
+          || executeNumber<UInt64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                             res_null_map)
+          || executeNumber<Int8, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                           res_null_map)
+          || executeNumber<Int16, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                            res_null_map)
+          || executeNumber<Int32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                            res_null_map)
+          || executeNumber<Int64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                            res_null_map)
+          ||
+          executeNumber<Float32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                           res_null_map)
+          ||
+          executeNumber<Float64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                           res_null_map)
+          || executeString<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                     res_null_map)
+          || executeFixedString<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                          res_null_map)))
+        executeGeneric<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                 res_null_map);
+}
+}
+}
+
+void FunctionEmptyArrayToSingle::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     if (FunctionEmptyArrayToSingleImpl::executeConst(block, arguments, result))
         return;
 
-    const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() +
+                        " of first argument of function " + getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
 
     ColumnPtr res_ptr = array->cloneEmpty();
     block.getByPosition(result).column = res_ptr;
-    ColumnArray & res = static_cast<ColumnArray &>(*res_ptr);
+    ColumnArray &res = static_cast<ColumnArray &>(*res_ptr);
 
-    const IColumn & src_data = array->getData();
-    const ColumnArray::Offsets_t & src_offsets = array->getOffsets();
-    IColumn & res_data = res.getData();
-    ColumnArray::Offsets_t & res_offsets = res.getOffsets();
+    const IColumn &src_data = array->getData();
+    const ColumnArray::Offsets_t &src_offsets = array->getOffsets();
+    IColumn &res_data = res.getData();
+    ColumnArray::Offsets_t &res_offsets = res.getOffsets();
 
-    const NullMap * src_null_map = nullptr;
-    NullMap * res_null_map = nullptr;
+    const NullMap *src_null_map = nullptr;
+    NullMap *res_null_map = nullptr;
 
-    const IColumn * inner_col;
-    IColumn * inner_res_col;
+    const IColumn *inner_col;
+    IColumn *inner_res_col;
 
     bool nullable = src_data.isNullable();
     if (nullable)
@@ -2286,9 +2343,11 @@ void FunctionEmptyArrayToSingle::executeImpl(Block & block, const ColumnNumbers
     }
 
     if (nullable)
-        FunctionEmptyArrayToSingleImpl::executeDispatch<true>(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map);
+        FunctionEmptyArrayToSingleImpl::executeDispatch<true>(*inner_col, src_offsets, *inner_res_col, res_offsets,
+                                                              src_null_map, res_null_map);
     else
-        FunctionEmptyArrayToSingleImpl::executeDispatch<false>(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map);
+        FunctionEmptyArrayToSingleImpl::executeDispatch<false>(*inner_col, src_offsets, *inner_res_col, res_offsets,
+                                                               src_null_map, res_null_map);
 }
 
 
@@ -2299,7 +2358,7 @@ String FunctionRange::getName() const
     return name;
 }
 
-DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes &arguments) const
 {
     const auto arg = arguments.front().get();
 
@@ -2309,47 +2368,48 @@ DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes & arguments) const
         !checkDataType<DataTypeUInt64>(arg))
     {
         throw Exception{
-            "Illegal type " + arg->getName() + " of argument of function " + getName(),
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+                "Illegal type " + arg->getName() + " of argument of function " + getName(),
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
     }
 
     return std::make_shared<DataTypeArray>(arg->clone());
 }
 
-template <typename T>
-bool FunctionRange::executeInternal(Block & block, const IColumn * arg, const size_t result)
+template<typename T>
+bool FunctionRange::executeInternal(Block &block, const IColumn *arg, const size_t result)
 {
     static constexpr size_t max_elements = 100'000'000;
 
     if (const auto in = checkAndGetColumn<ColumnVector<T>>(arg))
     {
-        const auto & in_data = in->getData();
+        const auto &in_data = in->getData();
         const auto total_values = std::accumulate(std::begin(in_data), std::end(in_data), size_t{},
-            [this] (const size_t lhs, const size_t rhs)
-            {
-                const auto sum = lhs + rhs;
-                if (sum < lhs)
-                    throw Exception{
-                        "A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
-                        ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                                                  [this](const size_t lhs, const size_t rhs)
+                                                  {
+                                                      const auto sum = lhs + rhs;
+                                                      if (sum < lhs)
+                                                          throw Exception{
+                                                                  "A call to function " + getName() +
+                                                                  " overflows, investigate the values of arguments you are passing",
+                                                                  ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
-                return sum;
-            });
+                                                      return sum;
+                                                  });
 
         if (total_values > max_elements)
             throw Exception{
-                "A call to function " + getName() + " would produce " + std::to_string(total_values) +
+                    "A call to function " + getName() + " would produce " + std::to_string(total_values) +
                     " array elements, which is greater than the allowed maximum of " + std::to_string(max_elements),
-                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
         const auto out = std::make_shared<ColumnArray>(
-            data_col,
-            std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
+                data_col,
+                std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
         block.getByPosition(result).column = out;
 
-        auto & out_data = data_col->getData();
-        auto & out_offsets = out->getOffsets();
+        auto &out_data = data_col->getData();
+        auto &out_offsets = out->getOffsets();
 
         IColumn::Offset_t offset{};
         for (size_t row_idx = 0, rows = in->size(); row_idx < rows; ++row_idx)
@@ -2368,24 +2428,25 @@ bool FunctionRange::executeInternal(Block & block, const IColumn * arg, const si
         T in_data = in->template getValue<T>();
         if ((in_data != 0) && (in->size() > (std::numeric_limits<size_t>::max() / in_data)))
             throw Exception{
-                "A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
-                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                    "A call to function " + getName() +
+                    " overflows, investigate the values of arguments you are passing",
+                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const size_t total_values = in->size() * in_data;
         if (total_values > max_elements)
             throw Exception{
-                "A call to function " + getName() + " would produce " + toString(total_values) +
+                    "A call to function " + getName() + " would produce " + toString(total_values) +
                     " array elements, which is greater than the allowed maximum of " + toString(max_elements),
-                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
         const auto out = std::make_shared<ColumnArray>(
-            data_col,
-            std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
+                data_col,
+                std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
         block.getByPosition(result).column = out;
 
-        auto & out_data = data_col->getData();
-        auto & out_offsets = out->getOffsets();
+        auto &out_data = data_col->getData();
+        auto &out_offsets = out->getOffsets();
 
         IColumn::Offset_t offset{};
         for (size_t row_idx = 0, rows = in->size(); row_idx < rows; ++row_idx)
@@ -2403,7 +2464,7 @@ bool FunctionRange::executeInternal(Block & block, const IColumn * arg, const si
         return false;
 }
 
-void FunctionRange::executeImpl(Block & block, const ColumnNumbers & arguments, const size_t result)
+void FunctionRange::executeImpl(Block &block, const ColumnNumbers &arguments, const size_t result)
 {
     const auto col = block.getByPosition(arguments[0]).column.get();
 
@@ -2413,15 +2474,15 @@ void FunctionRange::executeImpl(Block & block, const ColumnNumbers & arguments,
         !executeInternal<UInt64>(block, col, result))
     {
         throw Exception{
-            "Illegal column " + col->getName() + " of argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN
+                "Illegal column " + col->getName() + " of argument of function " + getName(),
+                ErrorCodes::ILLEGAL_COLUMN
         };
     }
 }
 
 /// Implementation of FunctionArrayReverse.
 
-FunctionPtr FunctionArrayReverse::create(const Context & context)
+FunctionPtr FunctionArrayReverse::create(const Context &context)
 {
     return std::make_shared<FunctionArrayReverse>();
 }
@@ -2431,40 +2492,41 @@ String FunctionArrayReverse::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayReverse::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayReverse::getReturnTypeImpl(const DataTypes &arguments) const
 {
-    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("Argument for function " + getName() + " must be array.",
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return arguments[0]->clone();
 }
 
-void FunctionArrayReverse::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayReverse::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     if (executeConst(block, arguments, result))
         return;
 
-    const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() +
+                        " of first argument of function " + getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
 
     ColumnPtr res_ptr = array->cloneEmpty();
     block.getByPosition(result).column = res_ptr;
-    ColumnArray & res = static_cast<ColumnArray &>(*res_ptr);
+    ColumnArray &res = static_cast<ColumnArray &>(*res_ptr);
 
-    const IColumn & src_data = array->getData();
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
-    IColumn & res_data = res.getData();
+    const IColumn &src_data = array->getData();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    IColumn &res_data = res.getData();
     res.getOffsetsColumn() = array->getOffsetsColumn();
 
-    const ColumnNullable * nullable_col = nullptr;
-    ColumnNullable * nullable_res_col = nullptr;
+    const ColumnNullable *nullable_col = nullptr;
+    ColumnNullable *nullable_res_col = nullptr;
 
-    const IColumn * inner_col;
-    IColumn * inner_res_col;
+    const IColumn *inner_col;
+    IColumn *inner_res_col;
 
     if (src_data.isNullable())
     {
@@ -2480,26 +2542,27 @@ void FunctionArrayReverse::executeImpl(Block & block, const ColumnNumbers & argu
         inner_res_col = &res_data;
     }
 
-    if (!(    executeNumber<UInt8>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<UInt16>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<UInt32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<UInt64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Int8>        (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Int16>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Int32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Int64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Float32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Float64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeString            (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeFixedString        (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)))
+    if (!(executeNumber<UInt8>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<UInt16>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<UInt32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<UInt64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Int8>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Int16>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Int32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Int64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Float32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Float64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeString(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeFixedString(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)))
         throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-            + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+                        + " of first argument of function " + getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
 }
 
-bool FunctionArrayReverse::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
+bool FunctionArrayReverse::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    if (const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
+    if (const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
+            block.getByPosition(arguments[0]).column.get()))
     {
         Array arr = const_array->getValue<Array>();
 
@@ -2517,22 +2580,22 @@ bool FunctionArrayReverse::executeConst(Block & block, const ColumnNumbers & arg
         return false;
 }
 
-template <typename T>
+template<typename T>
 bool FunctionArrayReverse::executeNumber(
-    const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-    IColumn & res_data_col,
-    const ColumnNullable * nullable_col,
-    ColumnNullable * nullable_res_col)
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data_col,
+        const ColumnNullable *nullable_col,
+        ColumnNullable *nullable_res_col)
 {
-    auto do_reverse = [](const auto & src_data, const auto & src_offsets, auto & res_data)
+    auto do_reverse = [](const auto &src_data, const auto &src_offsets, auto &res_data)
     {
         size_t size = src_offsets.size();
         ColumnArray::Offset_t src_prev_offset = 0;
 
         for (size_t i = 0; i < size; ++i)
         {
-            const auto * src = &src_data[src_prev_offset];
-            const auto * src_end = &src_data[src_offsets[i]];
+            const auto *src = &src_data[src_prev_offset];
+            const auto *src_end = &src_data[src_offsets[i]];
 
             if (src == src_end)
                 continue;
@@ -2550,18 +2613,18 @@ bool FunctionArrayReverse::executeNumber(
         }
     };
 
-    if (const ColumnVector<T> * src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
+    if (const ColumnVector<T> *src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
     {
-        const PaddedPODArray<T> & src_data = src_data_concrete->getData();
-        PaddedPODArray<T> & res_data = typeid_cast<ColumnVector<T> &>(res_data_col).getData();
+        const PaddedPODArray<T> &src_data = src_data_concrete->getData();
+        PaddedPODArray<T> &res_data = typeid_cast<ColumnVector<T> &>(res_data_col).getData();
         res_data.resize(src_data.size());
         do_reverse(src_data, src_offsets, res_data);
 
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_data.size());
             do_reverse(src_null_map, src_offsets, res_null_map);
         }
@@ -2573,16 +2636,16 @@ bool FunctionArrayReverse::executeNumber(
 }
 
 bool FunctionArrayReverse::executeFixedString(
-    const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-    IColumn & res_data_col,
-    const ColumnNullable * nullable_col,
-    ColumnNullable * nullable_res_col)
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data_col,
+        const ColumnNullable *nullable_col,
+        ColumnNullable *nullable_res_col)
 {
-    if (const ColumnFixedString * src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
+    if (const ColumnFixedString *src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
     {
         const size_t n = src_data_concrete->getN();
-        const ColumnFixedString::Chars_t & src_data = src_data_concrete->getChars();
-        ColumnFixedString::Chars_t & res_data = typeid_cast<ColumnFixedString &>(res_data_col).getChars();
+        const ColumnFixedString::Chars_t &src_data = src_data_concrete->getChars();
+        ColumnFixedString::Chars_t &res_data = typeid_cast<ColumnFixedString &>(res_data_col).getChars();
         size_t size = src_offsets.size();
         res_data.resize(src_data.size());
 
@@ -2590,13 +2653,13 @@ bool FunctionArrayReverse::executeFixedString(
 
         for (size_t i = 0; i < size; ++i)
         {
-            const UInt8 * src = &src_data[src_prev_offset * n];
-            const UInt8 * src_end = &src_data[src_offsets[i] * n];
+            const UInt8 *src = &src_data[src_prev_offset * n];
+            const UInt8 *src_end = &src_data[src_offsets[i] * n];
 
             if (src == src_end)
                 continue;
 
-            UInt8 * dst = &res_data[src_offsets[i] * n - n];
+            UInt8 *dst = &res_data[src_offsets[i] * n - n];
 
             while (src < src_end)
             {
@@ -2612,21 +2675,21 @@ bool FunctionArrayReverse::executeFixedString(
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_null_map.size());
 
             ColumnArray::Offset_t src_prev_offset = 0;
 
             for (size_t i = 0; i < size; ++i)
             {
-                const UInt8 * src = &src_null_map[src_prev_offset];
-                const UInt8 * src_end = &src_null_map[src_offsets[i]];
+                const UInt8 *src = &src_null_map[src_prev_offset];
+                const UInt8 *src_end = &src_null_map[src_offsets[i]];
 
                 if (src == src_end)
                     continue;
 
-                UInt8 * dst = &res_null_map[src_offsets[i] - 1];
+                UInt8 *dst = &res_null_map[src_offsets[i] - 1];
 
                 while (src < src_end)
                 {
@@ -2646,18 +2709,18 @@ bool FunctionArrayReverse::executeFixedString(
 }
 
 bool FunctionArrayReverse::executeString(
-    const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
-    IColumn & res_data_col,
-    const ColumnNullable * nullable_col,
-    ColumnNullable * nullable_res_col)
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
+        IColumn &res_data_col,
+        const ColumnNullable *nullable_col,
+        ColumnNullable *nullable_res_col)
 {
-    if (const ColumnString * src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+    if (const ColumnString *src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
     {
-        const ColumnString::Offsets_t & src_string_offsets = src_data_concrete->getOffsets();
-        ColumnString::Offsets_t & res_string_offsets = typeid_cast<ColumnString &>(res_data_col).getOffsets();
+        const ColumnString::Offsets_t &src_string_offsets = src_data_concrete->getOffsets();
+        ColumnString::Offsets_t &res_string_offsets = typeid_cast<ColumnString &>(res_data_col).getOffsets();
 
-        const ColumnString::Chars_t & src_data = src_data_concrete->getChars();
-        ColumnString::Chars_t & res_data = typeid_cast<ColumnString &>(res_data_col).getChars();
+        const ColumnString::Chars_t &src_data = src_data_concrete->getChars();
+        ColumnString::Chars_t &res_data = typeid_cast<ColumnString &>(res_data_col).getChars();
 
         size_t size = src_array_offsets.size();
         res_string_offsets.resize(src_string_offsets.size());
@@ -2676,10 +2739,13 @@ bool FunctionArrayReverse::executeString(
                 {
                     size_t j_reversed = array_size - j - 1;
 
-                    auto src_pos = src_array_prev_offset + j_reversed == 0 ? 0 : src_string_offsets[src_array_prev_offset + j_reversed - 1];
+                    auto src_pos =
+                            src_array_prev_offset + j_reversed == 0 ? 0 : src_string_offsets[src_array_prev_offset +
+                                                                                             j_reversed - 1];
                     size_t string_size = src_string_offsets[src_array_prev_offset + j_reversed] - src_pos;
 
-                    memcpySmallAllowReadWriteOverflow15(&res_data[res_string_prev_offset], &src_data[src_pos], string_size);
+                    memcpySmallAllowReadWriteOverflow15(&res_data[res_string_prev_offset], &src_data[src_pos],
+                                                        string_size);
 
                     res_string_prev_offset += string_size;
                     res_string_offsets[src_array_prev_offset + j] = res_string_prev_offset;
@@ -2692,8 +2758,8 @@ bool FunctionArrayReverse::executeString(
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_string_offsets.size());
 
             size_t size = src_string_offsets.size();
@@ -2701,8 +2767,8 @@ bool FunctionArrayReverse::executeString(
 
             for (size_t i = 0; i < size; ++i)
             {
-                const auto * src = &src_null_map[src_prev_offset];
-                const auto * src_end = &src_null_map[src_array_offsets[i]];
+                const auto *src = &src_null_map[src_prev_offset];
+                const auto *src_end = &src_null_map[src_array_offsets[i]];
 
                 if (src == src_end)
                     continue;
@@ -2728,7 +2794,7 @@ bool FunctionArrayReverse::executeString(
 
 /// Implementation of FunctionArrayReduce.
 
-FunctionPtr FunctionArrayReduce::create(const Context & context)
+FunctionPtr FunctionArrayReduce::create(const Context &context)
 {
     return std::make_shared<FunctionArrayReduce>();
 }
@@ -2739,30 +2805,32 @@ String FunctionArrayReduce::getName() const
 }
 
 void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
-    const ColumnsWithTypeAndName & arguments,
-    DataTypePtr & out_return_type,
-    std::vector<ExpressionAction> & out_prerequisites)
+        const ColumnsWithTypeAndName &arguments,
+        DataTypePtr &out_return_type,
+        std::vector<ExpressionAction> &out_prerequisites)
 {
     /// The first argument is a constant string with the name of the aggregate function
     ///  (possibly with parameters in parentheses, for example: "quantile(0.99)").
 
     if (arguments.size() < 2)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-            + toString(arguments.size()) + ", should be at least 2.",
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                        + toString(arguments.size()) + ", should be at least 2.",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-    const ColumnConst * aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
+    const ColumnConst *aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
     if (!aggregate_function_name_column)
-        throw Exception("First argument for function " + getName() + " must be constant string: name of aggregate function.",
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception(
+                "First argument for function " + getName() + " must be constant string: name of aggregate function.",
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     DataTypes argument_types(arguments.size() - 1);
     for (size_t i = 1, size = arguments.size(); i < size; ++i)
     {
-        const DataTypeArray * arg = checkAndGetDataType<DataTypeArray>(arguments[i].type.get());
+        const DataTypeArray *arg = checkAndGetDataType<DataTypeArray>(arguments[i].type.get());
         if (!arg)
-            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
-                + arguments[i].type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            throw Exception(
+                    "Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
+                    + arguments[i].type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         argument_types[i - 1] = arg->getNestedType()->clone();
     }
@@ -2772,15 +2840,17 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
         String aggregate_function_name_with_params = aggregate_function_name_column->getValue<String>();
 
         if (aggregate_function_name_with_params.empty())
-            throw Exception("First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
-                ErrorCodes::BAD_ARGUMENTS);
+            throw Exception(
+                    "First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
+                    ErrorCodes::BAD_ARGUMENTS);
 
         String aggregate_function_name;
         Array params_row;
         getAggregateFunctionNameAndParametersArray(aggregate_function_name_with_params,
                                                    aggregate_function_name, params_row, "function " + getName());
 
-        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types, params_row);
+        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types,
+                                                                      params_row);
         if (!params_row.empty())
             aggregate_function->setParameters(params_row);
         aggregate_function->setArguments(argument_types);
@@ -2790,11 +2860,10 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
 }
 
 
-
-void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayReduce::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    IAggregateFunction & agg_func = *aggregate_function.get();
-    std::unique_ptr<char[]> place_holder { new char[agg_func.sizeOfData()] };
+    IAggregateFunction &agg_func = *aggregate_function.get();
+    std::unique_ptr<char[]> place_holder{new char[agg_func.sizeOfData()]};
     AggregateDataPtr place = place_holder.get();
 
     std::unique_ptr<Arena> arena = agg_func.allocatesMemoryInArena() ? std::make_unique<Arena>() : nullptr;
@@ -2810,30 +2879,31 @@ void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & argum
 
     for (size_t i = 0, size = arguments.size() - 1; i < size; ++i)
     {
-        const IColumn * col = block.getByPosition(arguments[i + 1]).column.get();
-        if (const ColumnArray * arr = checkAndGetColumn<ColumnArray>(col))
+        const IColumn *col = block.getByPosition(arguments[i + 1]).column.get();
+        if (const ColumnArray *arr = checkAndGetColumn<ColumnArray>(col))
         {
             aggregate_arguments_vec[i] = arr->getDataPtr().get();
             is_const = false;
         }
-        else if (const ColumnConst * arr = checkAndGetColumnConst<ColumnArray>(col))
+        else if (const ColumnConst *arr = checkAndGetColumnConst<ColumnArray>(col))
         {
             materialized_columns.emplace_back(arr->convertToFullColumn());
             aggregate_arguments_vec[i] = typeid_cast<const ColumnArray &>(*materialized_columns.back().get()).getDataPtr().get();
         }
         else
-            throw Exception("Illegal column " + col->getName() + " as argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("Illegal column " + col->getName() + " as argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_COLUMN);
 
     }
-    const IColumn ** aggregate_arguments = aggregate_arguments_vec.data();
+    const IColumn **aggregate_arguments = aggregate_arguments_vec.data();
 
-    const ColumnArray::Offsets_t & offsets = typeid_cast<const ColumnArray &>(!materialized_columns.empty()
-        ? *materialized_columns.front().get()
-        : *block.getByPosition(arguments[1]).column.get()).getOffsets();
+    const ColumnArray::Offsets_t &offsets = typeid_cast<const ColumnArray &>(!materialized_columns.empty()
+                                                                             ? *materialized_columns.front().get()
+                                                                             : *block.getByPosition(arguments[1]).column.get()).getOffsets();
 
 
     ColumnPtr result_holder = block.getByPosition(result).type->createColumn();
-    IColumn & res_col = *result_holder;
+    IColumn &res_col = *result_holder;
 
     /// AggregateFunction's states should be inserted into column using specific way
     auto res_col_aggregate_function = typeid_cast<ColumnAggregateFunction *>(&res_col);
@@ -2904,8 +2974,9 @@ DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments)
         if (auto data_type_array = checkAndGetDataType<DataTypeArray>(argument))
             nested_types.push_back(data_type_array->getNestedType());
         else
-            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
-                            + argument->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            throw Exception(
+                    "Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
+                    + argument->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     if (foundNumericType(nested_types))
@@ -2920,7 +2991,8 @@ DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments)
     {
         /// Otherwise all the arguments must have the same type up to nullability or nullity.
         if (!hasArrayIdenticalTypes(nested_types))
-            throw Exception{"Arguments for function " + getName() + " must have same type or behave as number.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Arguments for function " + getName() + " must have same type or behave as number.",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeArray>(getArrayElementType(nested_types));
     }
@@ -2928,7 +3000,6 @@ DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments)
 
 void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    std::cerr << block.dumpStructure() << std::endl;
     auto & result_column = block.getByPosition(result).column;
     const DataTypePtr & return_type = block.getByPosition(result).type;
     result_column = return_type->createColumn();
@@ -2963,18 +3034,6 @@ void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & argum
 
     auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column.get()), size);
     concat(sources, *sink);
-
-    auto array = checkAndGetColumn<ColumnArray>(result_column.get());
-    if (array)
-    {
-        auto & offsets = array->getOffsets();
-        std::cerr << offsets.size()  << " " << array->size()<< std::endl;
-        for (auto & val : offsets)
-            std::cerr << val << ' ';
-        std::cerr << std::endl;
-    }
-
-    std::cerr << block.dumpStructure() << std::endl;
 }
 
 
@@ -3003,8 +3062,9 @@ DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) c
     for (size_t i = 1; i < arguments.size(); ++i)
     {
         if (!arguments[i]->isNumeric() && !arguments[i]->isNull())
-            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be numeric but it has type "
-                            + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            throw Exception(
+                    "Argument " + toString(i) + " for function " + getName() + " must be numeric but it has type "
+                    + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return arguments[0];
@@ -3012,23 +3072,23 @@ DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) c
 
 void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    std::cerr << block.dumpStructure() << std::endl;
-
     auto & result_colum_with_name_and_type = block.getByPosition(result);
     auto & result_column = result_colum_with_name_and_type.column;
     auto & return_type = result_colum_with_name_and_type.type;
     result_column = return_type->createColumn();
 
-    if (return_type->isNull())
-        return;
+    auto array_column = block.getByPosition(arguments[0]).column;
+    auto offset_column = block.getByPosition(arguments[1]).column;
+    auto length_column = block.getByPosition(arguments[2]).column;
 
-    auto & array_column = block.getByPosition(arguments[0]).column;
-    auto & offset_column = block.getByPosition(arguments[1]).column;
-    auto & length_column = block.getByPosition(arguments[2]).column;
+    if (return_type->isNull())
+    {
+        result_column = array_column->clone();
+        return;
+    }
 
     std::unique_ptr<IArraySource> source;
 
-
     size_t size = array_column->size();
     bool is_const = false;
 
@@ -3091,9 +3151,9 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
     auto array = checkAndGetColumn<ColumnArray>(result_column.get());
     if (array)
     {
-        auto & offsets = array->getOffsets();
-        std::cerr << offsets.size()  << " " << array->size()<< std::endl;
-        for (auto & val : offsets)
+        auto &offsets = array->getOffsets();
+        std::cerr << offsets.size() << " " << array->size() << std::endl;
+        for (auto &val : offsets)
             std::cerr << val << ' ';
         std::cerr << std::endl;
     }
@@ -3101,4 +3161,176 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
     std::cerr << block.dumpStructure() << std::endl;
 }
 
+
+/// Implementation of FunctionArrayPush.
+
+DataTypePtr FunctionArrayPush::getReturnTypeImpl(const DataTypes & arguments) const
+{
+    if (arguments[0]->isNull())
+        return arguments[0];
+
+    auto array_type = typeid_cast<DataTypeArray *>(arguments[0].get());
+    if (!array_type)
+        throw Exception("First argument for function " + getName() + " must be an array but it has type "
+                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+    auto nested_type = array_type->getNestedType();
+
+    DataTypes types = {nested_type, arguments[1]};
+
+    if (foundNumericType(types))
+    {
+        /// Since we have found at least one numeric argument, we infer that all
+        /// the arguments are numeric up to nullity. Let's determine the least
+        /// common type.
+        auto enriched_result_type = Conditional::getArrayType(types);
+        return std::make_shared<DataTypeArray>(enriched_result_type);
+    }
+    else
+    {
+        /// Otherwise all the arguments must have the same type up to nullability or nullity.
+        if (!hasArrayIdenticalTypes(types))
+            throw Exception{"Arguments for function " + getName() + " must have same type or behave as number.",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+
+        return std::make_shared<DataTypeArray>(getArrayElementType(types));
+    }
+}
+
+void FunctionArrayPush::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+{
+    auto & result_colum_with_name_and_type = block.getByPosition(result);
+    auto & result_column = result_colum_with_name_and_type.column;
+    auto & return_type = result_colum_with_name_and_type.type;
+    result_column = return_type->createColumn();
+
+    auto array_column = block.getByPosition(arguments[0]).column;
+    auto appended_column = block.getByPosition(arguments[1]).column;
+
+    if (return_type->isNull())
+    {
+        result_column = array_column->clone();
+        return;
+    }
+
+    std::vector<std::unique_ptr<IArraySource>> sources;
+
+    size_t size = array_column->size();
+    bool is_const = false;
+
+    if (auto const_array_column = typeid_cast<ColumnConst *>(array_column.get()))
+    {
+        is_const = true;
+        array_column = const_array_column->getDataColumnPtr();
+    }
+
+    if (auto argument_column_array = typeid_cast<ColumnArray *>(array_column.get()))
+        sources.push_back(createArraySource(*argument_column_array, is_const, size));
+    else
+        throw Exception{"First arguments for function " + getName() + " must be array.", ErrorCodes::LOGICAL_ERROR};
+
+
+    bool is_appended_const = false;
+    if (auto const_appended_column = typeid_cast<ColumnConst *>(appended_column.get()))
+    {
+        is_appended_const = true;
+        appended_column = const_appended_column->getDataColumnPtr();
+    }
+
+    auto offsets = std::make_shared<ColumnArray::ColumnOffsets_t>(appended_column->size());
+    for (size_t i : ext::range(0, offsets->size()))
+        offsets->getElement(i) = i + 1;
+
+    ColumnArray appended_array_column(appended_column, offsets);
+    sources.push_back(createArraySource(appended_array_column, is_appended_const, size));
+
+    auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column), size);
+
+    if (push_front)
+        sources[0].swap(sources[1]);
+    concat(sources, *sink);
+}
+
+/// Implementation of FunctionArrayPushFront.
+
+FunctionPtr FunctionArrayPushFront::create(const Context & context)
+{
+    return std::make_shared<FunctionArrayPushFront>();
+}
+
+/// Implementation of FunctionArrayPushBack.
+
+FunctionPtr FunctionArrayPushBack::create(const Context & context)
+{
+    return std::make_shared<FunctionArrayPushBack>();
+}
+
+/// Implementation of FunctionArrayPop.
+
+DataTypePtr FunctionArrayPop::getReturnTypeImpl(const DataTypes & arguments) const
+{
+    if (arguments[0]->isNull())
+        return arguments[0];
+
+    auto array_type = typeid_cast<DataTypeArray *>(arguments[0].get());
+    if (!array_type)
+        throw Exception("First argument for function " + getName() + " must be an array but it has type "
+                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+    return arguments[0];
+}
+
+void FunctionArrayPop::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+{
+    auto & result_colum_with_name_and_type = block.getByPosition(result);
+    auto & result_column = result_colum_with_name_and_type.column;
+    auto & return_type = result_colum_with_name_and_type.type;
+    result_column = return_type->createColumn();
+
+    auto array_column = block.getByPosition(arguments[0]).column;
+
+    if (return_type->isNull())
+    {
+        result_column = array_column->clone();
+        return;
+    }
+
+    std::unique_ptr<IArraySource> source;
+
+    size_t size = array_column->size();
+    bool is_const = false;
+
+    if (auto const_array_column = typeid_cast<ColumnConst *>(array_column.get()))
+    {
+        is_const = true;
+        array_column = const_array_column->getDataColumnPtr();
+    }
+
+    if (auto argument_column_array = typeid_cast<ColumnArray *>(array_column.get()))
+        source = createArraySource(*argument_column_array, is_const, size);
+    else
+        throw Exception{"First arguments for function " + getName() + " must be array.", ErrorCodes::LOGICAL_ERROR};
+
+    auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column), size);
+
+    if (pop_front)
+        sliceFromLeftConstantOffsetUnbounded(*source, *sink, 1);
+    else
+        sliceFromLeftConstantOffsetBounded(*source, *sink, 0, -1);
+}
+
+/// Implementation of FunctionArrayPopFront.
+
+FunctionPtr FunctionArrayPopFront::create(const Context &context)
+{
+    return std::make_shared<FunctionArrayPopFront>();
+}
+
+/// Implementation of FunctionArrayPopBack.
+
+FunctionPtr FunctionArrayPopBack::create(const Context &context)
+{
+    return std::make_shared<FunctionArrayPopBack>();
+}
+
 }
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index f6cfd4744e3..9d3740309f0 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -1441,10 +1441,94 @@ public:
     void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
 
     bool useDefaultImplementationForConstants() const override { return true; }
-    bool useDefaultImplementationForNulls() const { return false; }
+    bool useDefaultImplementationForNulls() const override { return false; }
 };
 
 
+class FunctionArrayPush : public IFunction
+{
+public:
+    FunctionArrayPush(bool push_front, const char * name) : push_front(push_front), name(name) {}
+
+    String getName() const override { return name; }
+
+    bool isVariadic() const override { return false; }
+    size_t getNumberOfArguments() const override { return 2; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+    bool useDefaultImplementationForNulls() const override { return false; }
+
+private:
+    bool push_front;
+    const char * name;
+};
+
+class FunctionArrayPushFront : public FunctionArrayPush
+{
+public:
+    static constexpr auto name = "arrayPushFront";
+
+    static FunctionPtr create(const Context & context);
+
+    FunctionArrayPushFront() : FunctionArrayPush(true, name) {}
+};
+
+class FunctionArrayPushBack : public FunctionArrayPush
+{
+public:
+    static constexpr auto name = "arrayPushBack";
+
+    static FunctionPtr create(const Context & context);
+
+    FunctionArrayPushBack() : FunctionArrayPush(false, name) {}
+};
+
+class FunctionArrayPop : public IFunction
+{
+public:
+    FunctionArrayPop(bool pop_front, const char * name) : pop_front(pop_front), name(name) {}
+
+    String getName() const override { return name; }
+
+    bool isVariadic() const override { return false; }
+    size_t getNumberOfArguments() const override { return 1; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+    bool useDefaultImplementationForNulls() const override { return false; }
+
+private:
+    bool pop_front;
+    const char * name;
+};
+
+class FunctionArrayPopFront : public FunctionArrayPop
+{
+public:
+    static constexpr auto name = "arrayPopFront";
+
+    static FunctionPtr create(const Context & context);
+
+    FunctionArrayPopFront() : FunctionArrayPop(true, name) {}
+};
+
+class FunctionArrayPopBack : public FunctionArrayPop
+{
+public:
+    static constexpr auto name = "arrayPopBack";
+
+    static FunctionPtr create(const Context & context);
+
+    FunctionArrayPopBack() : FunctionArrayPop(false, name) {}
+};
+
 
 struct NameHas { static constexpr auto name = "has"; };
 struct NameIndexOf { static constexpr auto name = "indexOf"; };
diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
new file mode 100644
index 00000000000..a8079a96fc9
--- /dev/null
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -0,0 +1,482 @@
+#include <Functions/GatherUtils.h>
+
+namespace DB
+{
+
+/// Creates IArraySource from ColumnArray
+
+template <typename ... Types>
+struct ArraySourceCreator;
+
+template <typename Type, typename ... Types>
+struct ArraySourceCreator<Type, Types ...>
+{
+    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    {
+        if (typeid_cast<const ColumnVector<Type> *>(&col.getData()))
+        {
+            if (null_map)
+            {
+                if (is_const)
+                    return std::make_unique<ConstSource<NullableArraySource<NumericArraySource<Type>>>>(col, *null_map, total_rows);
+                return std::make_unique<NullableArraySource<NumericArraySource<Type>>>(col, *null_map);
+            }
+            if (is_const)
+                return std::make_unique<ConstSource<NumericArraySource<Type>>>(col, total_rows);
+            return std::make_unique<NumericArraySource<Type>>(col);
+        }
+
+        return ArraySourceCreator<Types...>::create(col, null_map, is_const, total_rows);
+    }
+};
+
+template <>
+struct ArraySourceCreator<>
+{
+    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    {
+        if (null_map)
+        {
+            if (is_const)
+                return std::make_unique<ConstSource<NullableArraySource<GenericArraySource>>>(col, *null_map, total_rows);
+            return std::make_unique<NullableArraySource<GenericArraySource>>(col, *null_map);
+        }
+        if (is_const)
+            return std::make_unique<ConstSource<GenericArraySource>>(col, total_rows);
+        return std::make_unique<GenericArraySource>(col);
+    }
+};
+
+std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
+{
+    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumber>::Type;
+    if (auto column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
+    {
+        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
+        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), is_const, total_rows);
+    }
+    return Creator::create(col, nullptr, is_const, total_rows);
+}
+
+
+/// Creates IArraySink from ColumnArray
+
+template <typename ... Types>
+struct ArraySinkCreator;
+
+template <typename Type, typename ... Types>
+struct ArraySinkCreator<Type, Types ...>
+{
+    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
+    {
+        if (typeid_cast<ColumnVector<Type> *>(&col.getData()))
+        {
+            if (null_map)
+                return std::make_unique<NullableArraySink<NumericArraySink<Type>>>(col, *null_map, column_size);
+            return std::make_unique<NumericArraySink<Type>>(col, column_size);
+        }
+
+        return ArraySinkCreator<Types ...>::create(col, null_map, column_size);
+    }
+};
+
+template <>
+struct ArraySinkCreator<>
+{
+    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
+    {
+        if (null_map)
+            return std::make_unique<NullableArraySink<GenericArraySink>>(col, *null_map, column_size);
+        return std::make_unique<GenericArraySink>(col, column_size);
+    }
+};
+
+std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
+{
+    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumber>::Type;
+    if (auto column_nullable = typeid_cast<ColumnNullable *>(&col.getData()))
+    {
+        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
+        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), column_size);
+    }
+    return Creator::create(col, nullptr, column_size);
+}
+
+
+/// Base classes which selects template function implementation with concrete ArraySource or ArraySink
+/// Derived classes should implement selectImpl for ArraySourceSelector and ArraySinkSelector
+///  or selectSourceSink for ArraySinkSourceSelector
+
+template <typename Base, typename ... Types>
+struct ArraySourceSelector;
+
+template <typename Base, typename Type, typename ... Types>
+struct ArraySourceSelector<Base, Type, Types ...>
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, Args & ... args)
+    {
+        if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
+            Base::selectImpl(*array, args ...);
+        else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
+            Base::selectImpl(*nullable_array, args ...);
+        else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
+            Base::selectImpl(*const_array, args ...);
+        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
+            Base::selectImpl(*const_nullable_array, args ...);
+        else
+            ArraySourceSelector<Base, Types ...>::select(source, args ...);
+    }
+};
+
+template <typename Base>
+struct ArraySourceSelector<Base>
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, Args & ... args)
+    {
+        if (auto array = typeid_cast<GenericArraySource *>(&source))
+            Base::selectImpl(*array, args ...);
+        else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
+            Base::selectImpl(*nullable_array, args ...);
+        else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
+            Base::selectImpl(*const_array, args ...);
+        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
+            Base::selectImpl(*const_nullable_array, args ...);
+        else
+            throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
+    }
+};
+
+template <typename Base>
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
+
+template <typename Base, typename ... Types>
+struct ArraySinkSelector;
+
+template <typename Base, typename Type, typename ... Types>
+struct ArraySinkSelector<Base, Type, Types ...>
+{
+    template <typename ... Args>
+    static void select(IArraySink & sink, Args & ... args)
+    {
+        if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
+            Base::selectImpl(*nullable_numeric_sink, args ...);
+        else if (auto numeric_sink = typeid_cast<NumericArraySink<Type> *>(&sink))
+            Base::selectImpl(*numeric_sink, args ...);
+        else
+            ArraySinkSelector<Base, Types ...>::select(sink, args ...);
+    }
+};
+
+template <typename Base>
+struct ArraySinkSelector<Base>
+{
+    template <typename ... Args>
+    static void select(IArraySink & sink, Args & ... args)
+    {
+        if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
+            Base::selectImpl(*nullable_generic_sink, args ...);
+        else if (auto generic_sink = typeid_cast<GenericArraySink *>(&sink))
+            Base::selectImpl(*generic_sink, args ...);
+        else
+            throw Exception(std::string("Unknown ArraySink type: ") + typeid(sink).name(), ErrorCodes::LOGICAL_ERROR);
+    }
+};
+
+template <typename Base>
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
+
+template <typename Base>
+struct ArraySinkSourceSelector
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, IArraySink & sink, Args & ... args)
+    {
+        GetArraySinkSelector<Base>::select(sink, source, args ...);
+    }
+
+    template <typename Sink, typename ... Args>
+    static void selectImpl(Sink & sink, IArraySource & source, Args & ... args)
+    {
+        GetArraySourceSelector<Base>::select(source, sink, args ...);
+    }
+
+    template <typename Source, typename Sink, typename ... Args>
+    static void selectImpl(Source & source, Sink & sink, Args & ... args)
+    {
+        Base::selectSourceSink(source, sink, args ...);
+    }
+};
+
+
+/// Algorithms.
+
+/// Appends slices from source to sink. Offsets for sink should be precalculated as start positions of result arrays.
+/// Only for NumericArraySource, because can't insert values in the middle of arbitary column.
+/// Used for array concat implementation.
+template <typename Source, typename Sink>
+static void append(Source & source, Sink & sink)
+{
+    sink.row_num = 0;
+    while (!source.isEnd())
+    {
+        sink.current_offset = sink.offsets[sink.row_num];
+        writeSlice(source.getWhole(), sink);
+        sink.next();
+        source.next();
+    }
+}
+
+struct ArrayAppend : public GetArraySourceSelector<ArrayAppend>
+{
+    template <typename Source, typename Sink>
+    static void selectImpl(Source & source, Sink & sink)
+    {
+        append<Source, Sink>(source, sink);
+    }
+};
+
+template <typename Sink>
+static void append(IArraySource & source, Sink & sink)
+{
+    ArrayAppend::select(source, sink);
+}
+
+/// Concat specialization for GenericArraySource. Because can't use append with arbitrary column type.
+
+template <typename SourceType, typename SinkType>
+struct ConcatGenericImpl
+{
+    static void concat(GenericArraySource * generic_source, SinkType & sink)
+    {
+        auto source = static_cast<SourceType *>(generic_source);
+        writeSlice(source->getWhole(), sink);
+        source->next();
+    }
+};
+
+template <typename Sink>
+static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+{
+    std::vector<GenericArraySource *> generic_sources;
+    std::vector<bool> is_nullable;
+    std::vector<bool> is_const;
+
+    generic_sources.reserve(sources.size());
+    is_nullable.assign(sources.size(), false);
+    is_const.assign(sources.size(), false);
+
+    for (auto i : ext::range(0, sources.size()))
+    {
+        const auto &source = sources[i];
+        if (auto generic_source = typeid_cast<GenericArraySource *>(source.get()))
+            generic_sources.push_back(static_cast<GenericArraySource *>(generic_source));
+        else if (auto const_generic_source = typeid_cast<ConstSource<GenericArraySource> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(const_generic_source));
+            is_const[i] = true;
+        }
+        else if (auto nullable_source = typeid_cast<NullableArraySource<GenericArraySource> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(nullable_source));
+            is_nullable[i] = true;
+        }
+        else if (auto const_nullable_source = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(const_nullable_source));
+            is_nullable[i] = is_const[i] = true;
+        }
+        else
+            throw Exception(std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
+                            ErrorCodes::LOGICAL_ERROR);
+    }
+
+    while (!sink.isEnd())
+    {
+        for (auto i : ext::range(0, sources.size()))
+        {
+            auto source = generic_sources[i];
+            if (is_const[i])
+            {
+                if (is_nullable[i])
+                    ConcatGenericImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::concat(source, sink);
+                else
+                    ConcatGenericImpl<ConstSource<GenericArraySource>, Sink>::concat(source, sink);
+            }
+            else
+            {
+                if (is_nullable[i])
+                    ConcatGenericImpl<NullableArraySource<GenericArraySource>, Sink>::concat(source, sink);
+                else
+                    ConcatGenericImpl<GenericArraySource, Sink>::concat(source, sink);
+            }
+        }
+        sink.next();
+    }
+}
+
+/// Concat for array sources. Sources must be either all numeric either all generic.
+template <typename Sink>
+void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+{
+    size_t elements_to_reserve = 0;
+    bool is_first = true;
+
+    /// Prepare offsets column. Offsets should point to starts of result arrays.
+    for (const auto & source : sources)
+    {
+        elements_to_reserve += source->getSizeForReserve();
+        const auto & offsets = source->getOffsets();
+
+        if (is_first)
+        {
+            sink.offsets.resize(source->getColumnSize());
+            memset(&sink.offsets[0], 0, sink.offsets.size() * sizeof(offsets[0]));
+            is_first = false;
+        }
+
+        if (source->isConst())
+        {
+            for (size_t i : ext::range(1, offsets.size()))
+                sink.offsets[i] += offsets[0];
+        }
+        else
+        {
+            for (size_t i : ext::range(1, offsets.size()))
+                sink.offsets[i] += offsets[i - 1] - (i > 1 ? offsets[i - 2] : 0);
+        }
+    }
+
+    for (auto i : ext::range(1, sink.offsets.size()))
+        sink.offsets[i] += sink.offsets[i - 1];
+
+    sink.reserve(elements_to_reserve);
+
+    for (const auto & source : sources)
+    {
+        append<Sink>(*source, sink);
+    }
+}
+
+struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
+{
+    using Sources = std::vector<std::unique_ptr<IArraySource>>;
+
+    template <typename Sink>
+    static void selectImpl(Sink & sink, Sources & sources)
+    {
+        concat<Sink>(sources, sink);
+    }
+
+    static void selectImpl(GenericArraySink & sink, Sources & sources)
+    {
+        concatGeneric<GenericArraySink>(sources, sink);
+    }
+
+    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
+    {
+        concatGeneric<NullableArraySink<GenericArraySink>>(sources, sink);
+    }
+};
+
+void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
+{
+    using Sources = std::vector<std::unique_ptr<IArraySource>>;
+    return ArrayConcat::select(sink, sources);
+}
+
+
+/// Slice for array sources.
+
+struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    {
+        sliceFromLeftConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+    }
+};
+
+struct SliceFromLeftConstantOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    {
+        sliceFromLeftConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+    }
+};
+
+struct SliceFromRightConstantOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    {
+        sliceFromRightConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+    }
+};
+
+struct SliceFromRightConstantOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    {
+        sliceFromRightConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+    }
+};
+
+struct SliceDynamicOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceDynamicOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
+    {
+        sliceDynamicOffsetUnbounded<Source, Sink>(source, sink, offset_column);
+    }
+};
+
+struct SliceDynamicOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceDynamicOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
+    {
+        sliceDynamicOffsetBounded<Source, Sink>(source, sink, offset_column, length_column);
+    }
+};
+
+void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
+{
+    SliceFromLeftConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
+}
+
+void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
+{
+    SliceFromLeftConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
+}
+
+void sliceFromRightConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
+{
+    SliceFromRightConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
+}
+
+void sliceFromRightConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
+{
+    SliceFromRightConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
+}
+
+void sliceDynamicOffsetUnbounded(IArraySource & src, IArraySink & sink, IColumn & offset_column)
+{
+    SliceDynamicOffsetUnboundedSelectArraySource::select(src, sink, offset_column);
+}
+
+void sliceDynamicOffsetBounded(IArraySource & src, IArraySink & sink, IColumn & offset_column, IColumn & length_column)
+{
+    SliceDynamicOffsetBoundedSelectArraySource::select(src, sink, offset_column, length_column);
+}
+
+}
diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index cfd445723f9..95602b04d0a 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -18,7 +18,6 @@
 #include <Core/TypeListNumber.h>
 
 #include <DataTypes/DataTypeTraits.h>
-#include <iostream>
 #include <typeindex>
 
 /** These methods are intended for implementation of functions, that
@@ -83,7 +82,7 @@ struct NumericArraySource : public IArraySource
     size_t row_num = 0;
     ColumnArray::Offset_t prev_offset = 0;
 
-    NumericArraySource(const ColumnArray & arr)
+    explicit NumericArraySource(const ColumnArray & arr)
         : elements(typeid_cast<const ColumnVector<T> &>(arr.getData()).getData()), offsets(arr.getOffsets())
     {
     }
@@ -104,7 +103,7 @@ struct NumericArraySource : public IArraySource
         return row_num;
     }
 
-    const typename ColumnArray::Offsets_t & getOffsets() const
+    const typename ColumnArray::Offsets_t & getOffsets() const override
     {
         return offsets;
     }
@@ -173,14 +172,13 @@ struct ConstSource : public Base
     size_t total_rows;
     size_t row_num = 0;
 
-    /// Base base;
-
-    /// template <typename ColumnType>
     explicit ConstSource(const ColumnConst & col)
         : Base(static_cast<const typename Base::Column &>(col.getDataColumn())), total_rows(col.size())
     {
     }
 
+    /// Constructors for NullableArraySource.
+
     template <typename ColumnType>
     ConstSource(const ColumnType & col, size_t total_rows) : Base(col), total_rows(total_rows)
     {
@@ -220,31 +218,6 @@ struct ConstSource : public Base
     {
         return true;
     }
-
-//    Slice getWhole() const
-//    {
-//        return base.getWhole();
-//    }
-//
-//    Slice getSliceFromLeft(size_t offset) const
-//    {
-//        return base.getSliceFromLeft(offset);
-//    }
-//
-//    Slice getSliceFromLeft(size_t offset, size_t length) const
-//    {
-//        return base.getSliceFromLeft(offset, length);
-//    }
-//
-//    Slice getSliceFromRight(size_t offset) const
-//    {
-//        return base.getSliceFromRight(offset);
-//    }
-//
-//    Slice getSliceFromRight(size_t offset, size_t length) const
-//    {
-//        return base.getSliceFromRight(offset, length);
-//    }
 };
 
 
@@ -259,7 +232,7 @@ struct StringSource
     size_t row_num = 0;
     ColumnString::Offset_t prev_offset = 0;
 
-    StringSource(const ColumnString & col)
+    explicit StringSource(const ColumnString & col)
         : elements(col.getChars()), offsets(col.getOffsets())
     {
     }
@@ -339,7 +312,7 @@ struct FixedStringSource
     size_t string_size;
     size_t row_num = 0;
 
-    FixedStringSource(const ColumnFixedString & col)
+    explicit FixedStringSource(const ColumnFixedString & col)
         : string_size(col.getN())
     {
         const auto & chars = col.getChars();
@@ -539,7 +512,7 @@ struct DynamicStringSource final : IStringSource
 {
     Impl impl;
 
-    DynamicStringSource(const IColumn & col) : impl(static_cast<const typename Impl::Column &>(col)) {}
+    explicit DynamicStringSource(const IColumn & col) : impl(static_cast<const typename Impl::Column &>(col)) {}
 
     void next() override { impl.next(); }
     bool isEnd() const override { return impl.isEnd(); }
@@ -563,7 +536,6 @@ inline std::unique_ptr<IStringSource> createDynamicStringSource(const IColumn &
 using StringSources = std::vector<std::unique_ptr<IStringSource>>;
 
 
-
 struct GenericArraySlice
 {
     const IColumn * elements;
@@ -583,7 +555,7 @@ struct GenericArraySource : public IArraySource
     size_t row_num = 0;
     ColumnArray::Offset_t prev_offset = 0;
 
-    GenericArraySource(const ColumnArray & arr)
+    explicit GenericArraySource(const ColumnArray & arr)
         : elements(arr.getData()), offsets(arr.getOffsets())
     {
     }
@@ -604,7 +576,7 @@ struct GenericArraySource : public IArraySource
         return row_num;
     }
 
-    const typename ColumnArray::Offsets_t & getOffsets() const
+    const typename ColumnArray::Offsets_t & getOffsets() const override
     {
         return offsets;
     }
@@ -702,9 +674,9 @@ struct GenericArraySink : public IArraySink
 template <typename Slice>
 struct NullableArraySlice : public Slice
 {
-    const UInt8 * null_map;
+    const UInt8 * null_map = nullptr;
 
-    NullableArraySlice() {}
+    NullableArraySlice() = default;
     NullableArraySlice(const Slice & base) : Slice(base) {}
 };
 
@@ -771,7 +743,7 @@ struct NullableArraySource : public ArraySource
         return slice;
     }
 
-    bool isNullable() const override
+    bool isNullable() const
     {
         return true;
     }
@@ -794,103 +766,9 @@ struct NullableArraySink : public ArraySink
     }
 };
 
-template <typename ... Types>
-struct ArraySourceCreator;
 
-template <typename Type, typename ... Types>
-struct ArraySourceCreator<Type, Types ...>
-{
-    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
-    {
-        std::cerr << "Numeric " << typeid(Type).name() << std::endl;
-        if (typeid_cast<const ColumnVector<Type> *>(&col.getData()))
-        {
-            std::cerr << "Created" << typeid(NumericArraySource<Type>).name() << std::endl;
-            if (null_map)
-            {
-                if (is_const)
-                    return std::make_unique<ConstSource<NullableArraySource<NumericArraySource<Type>>>>(col, *null_map, total_rows);
-                return std::make_unique<NullableArraySource<NumericArraySource<Type>>>(col, *null_map);
-            }
-            if (is_const)
-                return std::make_unique<ConstSource<NumericArraySource<Type>>>(col, total_rows);
-            return std::make_unique<NumericArraySource<Type>>(col);
-        }
-
-        return ArraySourceCreator<Types...>::create(col, null_map, is_const, total_rows);
-    }
-};
-
-template <>
-struct ArraySourceCreator<>
-{
-    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
-    {
-        std::cerr << "Generic " << typeid(GenericArraySource).name() << std::endl;
-        if (null_map)
-        {
-            if (is_const)
-                return std::make_unique<ConstSource<NullableArraySource<GenericArraySource>>>(col, *null_map, total_rows);
-            return std::make_unique<NullableArraySource<GenericArraySource>>(col, *null_map);
-        }
-        if (is_const)
-            return std::make_unique<ConstSource<GenericArraySource>>(col, total_rows);
-        return std::make_unique<GenericArraySource>(col);
-    }
-};
-
-inline std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
-{
-    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumber>::Type;
-    if (auto column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
-    {
-        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
-        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), is_const, total_rows);
-    }
-    return Creator::create(col, nullptr, is_const, total_rows);
-}
-
-
-template <typename ... Types>
-struct ArraySinkCreator;
-
-template <typename Type, typename ... Types>
-struct ArraySinkCreator<Type, Types ...>
-{
-    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
-    {
-        if (typeid_cast<ColumnVector<Type> *>(&col.getData()))
-        {
-            if (null_map)
-                return std::make_unique<NullableArraySink<NumericArraySink<Type>>>(col, *null_map, column_size);
-            return std::make_unique<NumericArraySink<Type>>(col, column_size);
-        }
-
-        return ArraySinkCreator<Types ...>::create(col, null_map, column_size);
-    }
-};
-
-template <>
-struct ArraySinkCreator<>
-{
-    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
-    {
-        if (null_map)
-            return std::make_unique<NullableArraySink<GenericArraySink>>(col, *null_map, column_size);
-        return std::make_unique<GenericArraySink>(col, column_size);
-    }
-};
-
-inline std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
-{
-    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumber>::Type;
-    if (auto column_nullable = typeid_cast<ColumnNullable *>(&col.getData()))
-    {
-        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
-        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), column_size);
-    }
-    return Creator::create(col, nullptr, column_size);
-}
+std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows);
+std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size);
 
 
 template <typename T>
@@ -906,7 +784,7 @@ struct NumericSource
     const T * pos;
     const T * end;
 
-    NumericSource(const Column & col)
+    explicit NumericSource(const Column & col)
     {
         const auto & container = col.getData();
         begin = container.data();
@@ -1013,6 +891,7 @@ inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, FixedStr
     memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size);
 }
 
+/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArraySink & sink)
 {
     if (std::type_index(typeid(slice.elements)) == std::type_index(typeid(&sink.elements)))
@@ -1054,7 +933,6 @@ inline ALWAYS_INLINE void writeSlice(const NumericArraySlice<T> & slice, Generic
     sink.current_offset += slice.size;
 }
 
-/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 template <typename ArraySlice, typename ArraySink>
 inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slice, NullableArraySink<ArraySink> & sink)
 {
@@ -1064,7 +942,6 @@ inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slic
     writeSlice(static_cast<const ArraySlice &>(slice), static_cast<ArraySink &>(sink));
 }
 
-/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 template <typename ArraySlice, typename ArraySink>
 inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink<ArraySink> & sink)
 {
@@ -1076,138 +953,6 @@ inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink
 
 /// Algorithms
 
-template <typename Source, typename Sink>
-static void append(Source & source, Sink & sink)
-{
-    sink.row_num = 0;
-    while (!source.isEnd())
-    {
-        sink.current_offset = sink.offsets[sink.row_num];
-        writeSlice(source.getWhole(), sink);
-        sink.next();
-        source.next();
-    }
-}
-
-template <typename Base, typename ... Types>
-struct ArraySourceSelector;
-
-template <typename Base, typename Type, typename ... Types>
-struct ArraySourceSelector<Base, Type, Types ...>
-{
-    template <typename ... Args>
-    static void select(IArraySource & source, Args & ... args)
-    {
-        if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
-            Base::selectImpl(*array, args ...);
-        else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
-            Base::selectImpl(*nullable_array, args ...);
-        else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
-            Base::selectImpl(*const_array, args ...);
-        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
-            Base::selectImpl(*const_nullable_array, args ...);
-        else
-            ArraySourceSelector<Base, Types ...>::select(source, args ...);
-    }
-};
-
-template <typename Base>
-struct ArraySourceSelector<Base>
-{
-    template <typename ... Args>
-    static void select(IArraySource & source, Args & ... args)
-    {
-        if (auto array = typeid_cast<GenericArraySource *>(&source))
-            Base::selectImpl(*array, args ...);
-        else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
-            Base::selectImpl(*nullable_array, args ...);
-        else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
-            Base::selectImpl(*const_array, args ...);
-        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
-            Base::selectImpl(*const_nullable_array, args ...);
-        else
-            throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
-    }
-};
-
-template <typename Base>
-using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
-
-template <typename Base, typename ... Types>
-struct ArraySinkSelector;
-
-template <typename Base, typename Type, typename ... Types>
-struct ArraySinkSelector<Base, Type, Types ...>
-{
-    template <typename ... Args>
-    static void select(IArraySink & sink, Args & ... args)
-    {
-        if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
-            Base::selectImpl(*nullable_numeric_sink, args ...);
-        else if (auto numeric_sink = typeid_cast<NumericArraySink<Type> *>(&sink))
-            Base::selectImpl(*numeric_sink, args ...);
-        else
-            ArraySinkSelector<Base, Types ...>::select(sink, args ...);
-    }
-};
-
-template <typename Base>
-struct ArraySinkSelector<Base>
-{
-    template <typename ... Args>
-    static void select(IArraySink & sink, Args & ... args)
-    {
-        if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
-            Base::selectImpl(*nullable_generic_sink, args ...);
-        else if (auto generic_sink = typeid_cast<GenericArraySink *>(&sink))
-            Base::selectImpl(*generic_sink, args ...);
-        else
-            throw Exception(std::string("Unknown ArraySink type: ") + typeid(sink).name(), ErrorCodes::LOGICAL_ERROR);
-    }
-};
-
-template <typename Base>
-using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
-
-template <typename Base>
-struct ArraySinkSourceSelector
-{
-    template <typename ... Args>
-    static void select(IArraySource & source, IArraySink & sink, Args & ... args)
-    {
-        GetArraySinkSelector<Base>::select(sink, source, args ...);
-    }
-
-    template <typename Sink, typename ... Args>
-    static void selectImpl(Sink & sink, IArraySource & source, Args & ... args)
-    {
-        GetArraySourceSelector<Base>::select(source, sink, args ...);
-    }
-
-    template <typename Source, typename Sink, typename ... Args>
-    static void selectImpl(Source & source, Sink & sink, Args & ... args)
-    {
-        Base::selectSourceSink(source, sink, args ...);
-    }
-};
-
-
-struct ArrayAppend : public GetArraySourceSelector<ArrayAppend>
-{
-    template <typename Source, typename Sink>
-    static void selectImpl(Source & source, Sink & sink)
-    {
-        append<Source, Sink>(source, sink);
-    }
-};
-
-template <typename Sink>
-static void append(IArraySource & source, Sink & sink)
-{
-    ArrayAppend::select(source, sink);
-}
-
-
 template <typename SourceA, typename SourceB, typename Sink>
 void NO_INLINE concat(SourceA & src_a, SourceB & src_b, Sink & sink)
 {
@@ -1244,157 +989,8 @@ void NO_INLINE concat(StringSources & sources, Sink && sink)
     }
 }
 
-template <typename SourceType, typename SinkType>
-struct ConcatGenericImpl
-{
-    static void concat(GenericArraySource * generic_source, SinkType & sink)
-    {
-        auto source = static_cast<SourceType *>(generic_source);
-        writeSlice(source->getWhole(), sink);
-        source->next();
-    }
-};
+void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink);
 
-template <typename Sink>
-static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
-{
-    std::vector<GenericArraySource *> generic_sources;
-    std::vector<bool> is_nullable;
-    std::vector<bool> is_const;
-
-    generic_sources.reserve(sources.size());
-    is_nullable.assign(sources.size(), false);
-    is_const.assign(sources.size(), false);
-
-    for (auto i : ext::range(0, sources.size()))
-    {
-        const auto &source = sources[i];
-        if (auto generic_source = typeid_cast<GenericArraySource *>(source.get()))
-            generic_sources.push_back(static_cast<GenericArraySource *>(generic_source));
-        else if (auto const_generic_source = typeid_cast<ConstSource<GenericArraySource> *>(source.get()))
-        {
-            generic_sources.push_back(static_cast<GenericArraySource *>(const_generic_source));
-            is_const[i] = true;
-        }
-        else if (auto nullable_source = typeid_cast<NullableArraySource<GenericArraySource> *>(source.get()))
-        {
-            generic_sources.push_back(static_cast<GenericArraySource *>(nullable_source));
-            is_nullable[i] = true;
-        }
-        else if (auto const_nullable_source = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(source.get()))
-        {
-            generic_sources.push_back(static_cast<GenericArraySource *>(const_nullable_source));
-            is_nullable[i] = is_const[i] = true;
-        }
-        else
-            throw Exception(std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
-                            ErrorCodes::LOGICAL_ERROR);
-    }
-
-    while (!sink.isEnd())
-    {
-        for (auto i : ext::range(0, sources.size()))
-        {
-            auto source = generic_sources[i];
-            if (is_const[i])
-            {
-                if (is_nullable[i])
-                    ConcatGenericImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::concat(source, sink);
-                else
-                    ConcatGenericImpl<ConstSource<GenericArraySource>, Sink>::concat(source, sink);
-            }
-            else
-            {
-                if (is_nullable[i])
-                    ConcatGenericImpl<NullableArraySource<GenericArraySource>, Sink>::concat(source, sink);
-                else
-                    ConcatGenericImpl<GenericArraySource, Sink>::concat(source, sink);
-            }
-        }
-        sink.next();
-    }
-}
-
-template <typename Sink>
-void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
-{
-    size_t elements_to_reserve = 0;
-    bool is_first = true;
-    /// Prepare offsets column. Offsets should point to starts of result arrays.
-
-    for (const auto & source : sources)
-    {
-        elements_to_reserve += source->getSizeForReserve();
-        const auto & offsets = source->getOffsets();
-
-        if (is_first)
-        {
-            sink.offsets.resize(source->getColumnSize());
-            memset(&sink.offsets[0], 0, sink.offsets.size() * sizeof(offsets[0]));
-            is_first = false;
-        }
-        std::cerr << "Offsets:";
-        for (size_t i : ext::range(1, offsets.size()))
-        {
-            std::cerr << ' ' << offsets[i];
-        }
-        std::cerr << std::endl;
-
-        if (source->isConst())
-        {
-            for (size_t i : ext::range(1, offsets.size()))
-                sink.offsets[i] += offsets[0];
-        }
-        else
-        {
-            for (size_t i : ext::range(1, offsets.size()))
-                sink.offsets[i] += offsets[i - 1] - (i > 1 ? offsets[i - 2] : 0);
-        }
-    }
-
-    std::cerr << "Sink offsets:";
-    for (size_t i : ext::range(1, sink.offsets.size()))
-    {
-        sink.offsets[i] += sink.offsets[i - 1];
-        std::cerr << ' ' << sink.offsets[i];
-    }
-    std::cerr << std::endl;
-
-    sink.reserve(elements_to_reserve);
-
-    for (const auto & source : sources)
-    {
-        append<Sink>(*source, sink);
-    }
-}
-
-struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
-{
-    using Sources = std::vector<std::unique_ptr<IArraySource>>;
-
-    template <typename Sink>
-    static void selectImpl(Sink & sink, Sources & sources)
-    {
-        concat<Sink>(sources, sink);
-    }
-
-    static void selectImpl(GenericArraySink & sink, Sources & sources)
-    {
-        concatGeneric<GenericArraySink>(sources, sink);
-    }
-
-    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
-    {
-        concatGeneric<NullableArraySink<GenericArraySink>>(sources, sink);
-    }
-};
-
-
-inline void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
-{
-    using Sources = std::vector<std::unique_ptr<IArraySource>>;
-    return ArrayConcat::select(sink, sources);
-}
 
 template <typename Source, typename Sink>
 void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
@@ -1558,95 +1154,17 @@ void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn &
     sliceDynamicOffsetBounded(src, sink, offset_column, length_column);
 }
 
-struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetUnboundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
-    {
-        sliceFromLeftConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
-    }
-};
+void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset);
 
-struct SliceFromLeftConstantOffsetBoundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetBoundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
-    {
-        sliceFromLeftConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
-    }
-};
+void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length);
 
-struct SliceFromRightConstantOffsetUnboundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetUnboundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
-    {
-        sliceFromRightConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
-    }
-};
+void sliceFromRightConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset);
 
-struct SliceFromRightConstantOffsetBoundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetBoundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
-    {
-        sliceFromRightConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
-    }
-};
+void sliceFromRightConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length);
 
-struct SliceDynamicOffsetUnboundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceDynamicOffsetUnboundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
-    {
-        sliceDynamicOffsetUnbounded<Source, Sink>(source, sink, offset_column);
-    }
-};
+void sliceDynamicOffsetUnbounded(IArraySource & src, IArraySink & sink, IColumn & offset_column);
 
-struct SliceDynamicOffsetBoundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceDynamicOffsetBoundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
-    {
-        sliceDynamicOffsetBounded<Source, Sink>(source, sink, offset_column, length_column);
-    }
-};
-
-inline void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
-{
-    SliceFromLeftConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
-}
-
-inline void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
-{
-    SliceFromLeftConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
-}
-
-inline void sliceFromRightConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
-{
-    SliceFromRightConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
-}
-
-inline void sliceFromRightConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
-{
-    SliceFromRightConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
-}
-
-inline void sliceDynamicOffsetUnbounded(IArraySource & src, IArraySink & sink, IColumn & offset_column)
-{
-    SliceDynamicOffsetUnboundedSelectArraySource::select(src, sink, offset_column);
-}
-
-inline void sliceDynamicOffsetBounded(IArraySource & src, IArraySink & sink, IColumn & offset_column, IColumn & length_column)
-{
-    SliceDynamicOffsetBoundedSelectArraySource::select(src, sink, offset_column, length_column);
-}
+void sliceDynamicOffsetBounded(IArraySource & src, IArraySink & sink, IColumn & offset_column, IColumn & length_column);
 
 template <typename SourceA, typename SourceB, typename Sink>
 void NO_INLINE conditional(SourceA && src_a, SourceB && src_b, Sink && sink, const PaddedPODArray<UInt8> & condition)

From 09a307b94f545e1e4f1df8342adb1158d46bee4f Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 18:59:35 +0300
Subject: [PATCH 05/30] removed debug stderr output [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.cpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index ca57755cec1..9637997ba19 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -3146,19 +3146,6 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
         else
             sliceDynamicOffsetBounded(*source, *sink, *offset_column, *length_column);
     }
-
-
-    auto array = checkAndGetColumn<ColumnArray>(result_column.get());
-    if (array)
-    {
-        auto &offsets = array->getOffsets();
-        std::cerr << offsets.size() << " " << array->size() << std::endl;
-        for (auto &val : offsets)
-            std::cerr << val << ' ';
-        std::cerr << std::endl;
-    }
-
-    std::cerr << block.dumpStructure() << std::endl;
 }
 
 

From d8529e1846c579a9bc26947dc2a46f29ed4434a4 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 21:16:25 +0300
Subject: [PATCH 06/30] unused type alias [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index a8079a96fc9..fc10670de00 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -382,7 +382,6 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
 
 void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
 {
-    using Sources = std::vector<std::unique_ptr<IArraySource>>;
     return ArrayConcat::select(sink, sources);
 }
 

From d213efa97429eb5d7fe253008cf5734949df4d77 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 21:59:28 +0300
Subject: [PATCH 07/30] fixed slice for nullable index [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 95602b04d0a..90ffb574f14 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -1052,14 +1052,15 @@ template <typename Source, typename Sink>
 void NO_INLINE sliceDynamicOffsetUnbounded(Source & src, Sink & sink, IColumn & offset_column)
 {
     const bool is_null = offset_column.isNull();
-    const bool is_nullable = offset_column.isNullable();
-    auto null_map = is_nullable ? &static_cast<ColumnNullable &>(offset_column).getNullMapConcreteColumn().getData() : nullptr;
+    auto * nullable = typeid_cast<ColumnNullable *>(&offset_column);
+    ColumnUInt8::Container_t * null_map = nullable ? &nullable->getNullMapConcreteColumn().getData() : nullptr;
+    IColumn * nested_column = nullable ? nullable->getNestedColumn().get() : &offset_column;
 
     while (!src.isEnd())
     {
         auto row_num = src.rowNum();
-        bool has_offset = !is_null && !(is_nullable && (*null_map)[row_num]);
-        Int64 offset = has_offset ? offset_column.getInt(row_num) : 1;
+        bool has_offset = !is_null && !(null_map && (*null_map)[row_num]);
+        Int64 offset = has_offset ? nested_column->getInt(row_num) : 1;
 
         if (offset != 0)
         {
@@ -1082,20 +1083,22 @@ template <typename Source, typename Sink>
 void NO_INLINE sliceDynamicOffsetBounded(Source & src, Sink & sink, IColumn & offset_column, IColumn & length_column)
 {
     const bool is_offset_null = offset_column.isNull();
-    const bool is_offset_nullable = offset_column.isNullable();
-    auto offset_null_map = is_offset_nullable ? &static_cast<ColumnNullable &>(offset_column).getNullMapConcreteColumn().getData() : nullptr;
+    auto * offset_nullable = typeid_cast<ColumnNullable *>(&offset_column);
+    ColumnUInt8::Container_t * offset_null_map = offset_nullable ? &offset_nullable->getNullMapConcreteColumn().getData() : nullptr;
+    IColumn * offset_nested_column = offset_nullable ? offset_nullable->getNestedColumn().get() : &offset_column;
 
     const bool is_length_null = length_column.isNull();
-    const bool is_length_nullable = length_column.isNullable();
-    auto length_null_map = is_length_nullable ? &static_cast<ColumnNullable &>(length_column).getNullMapConcreteColumn().getData() : nullptr;
+    auto * length_nullable = typeid_cast<ColumnNullable *>(&length_column);
+    ColumnUInt8::Container_t * length_null_map = length_nullable ? &length_nullable->getNullMapConcreteColumn().getData() : nullptr;
+    IColumn * length_nested_column = length_nullable ? length_nullable->getNestedColumn().get() : &length_column;
 
     while (!src.isEnd())
     {
         size_t row_num = src.rowNum();
-        bool has_offset = !is_offset_null && !(is_offset_nullable && (*offset_null_map)[row_num]);
-        bool has_length = !is_length_null && !(is_length_nullable && (*length_null_map)[row_num]);
-        Int64 offset = has_offset ? offset_column.getInt(row_num) : 1;
-        Int64 size = has_length ? length_column.getInt(row_num) : static_cast<Int64>(src.getElementSize());
+        bool has_offset = !is_offset_null && !(offset_null_map && (*offset_null_map)[row_num]);
+        bool has_length = !is_length_null && !(length_null_map && (*length_null_map)[row_num]);
+        Int64 offset = has_offset ? offset_nested_column->getInt(row_num) : 1;
+        Int64 size = has_length ? length_nested_column->getInt(row_num) : static_cast<Int64>(src.getElementSize());
 
         if (size < 0)
             size += offset > 0 ? static_cast<Int64>(src.getElementSize()) - (offset - 1) : -offset;

From f70ead25394f03ed51e099be4980afb4240ac3f5 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 22:39:30 +0300
Subject: [PATCH 08/30] added test [#CLICKHOUSE-2090]

---
 ..._functions_concat_slice_push_pop.reference | 1216 +++++++++++++++++
 ..._array_functions_concat_slice_push_pop.sql |  366 +++++
 2 files changed, 1582 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
 create mode 100644 dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql

diff --git a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
new file mode 100644
index 00000000000..e46a94775cd
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
@@ -0,0 +1,1216 @@
+const args
+concat
+[]
+[]
+[]
+[NULL]
+[NULL,1]
+[1,2,-1,-2,0.3,0.7,NULL]
+\N
+\N
+[1,2,3,4]
+[1,2,3,4]
+[]
+['abc','def','gh','qwe']
+[1,NULL,2,3,NULL,4]
+[1,NULL,2,3,4]
+slice
+\N
+[1,2,3,4,5,6]
+[2,3,4,5,6]
+[1,2,3,4]
+[1,2,3,4]
+[4,5,6]
+[2,3,4]
+[2,3,4]
+[3,4]
+[3,4]
+[]
+[]
+[]
+[]
+[]
+[2,NULL,4,5]
+['b','c','d']
+['b',NULL,'d']
+push back
+\N
+[1,1]
+[NULL,1]
+[0.5,0.7,1]
+[1,-1]
+['a','b','cd']
+[1]
+[-1]
+push front
+\N
+[1,1]
+[1,NULL]
+[1,0.5,0.7]
+[-1,1]
+['cd','a','b']
+[1]
+[-1]
+pop back
+\N
+[]
+[]
+[1,2]
+[0.1,0.2]
+['a','b']
+pop front
+\N
+[]
+[]
+[2,3]
+[0.2,0.3]
+['b','c']
+
+table
+[]	[]	1	\N	1	\N
+[]	[1]	1	\N	1	\N
+[1,2,3,4,5]	[6,7]	2	\N	1	\N
+[1,2,3,4,5,6,7]	[8]	2	2	3	3
+[1,2,3,4,5,6,7]	[]	2	\N	-3	-3
+[1,2,3,4,5,6,7]	[]	2	\N	-3	\N
+[1,2,3,4,5,6,7]	[]	-5	-5	4	4
+[1,2,3,4,5,6,7]	[]	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+[1]	[]	[1]
+[1,2,3,4,5,6,7]	[1,2,3,4,5]	[6,7]
+[1,2,3,4,5,6,7,8]	[1,2,3,4,5,6,7]	[8]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+[1]	[]	[1]
+[1,2,3,4,5,6,7,1,2,3,4,5]	[1,2,3,4,5]	[6,7]
+[1,2,3,4,5,6,7,8,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[8]
+[1,2,3,4,5,6,7,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+arraySlice(arr1, o, l)
+[]	1	1	[]
+[]	1	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,2,3,4,5,6,7]	2	3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,2,3,4,5,6,7]	-5	-3	[3,4]
+arraySlice(arr1, no, nl)
+[]	\N	\N	[]
+[]	\N	\N	[]
+[1,2,3,4,5]	\N	\N	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	2	3	[2,3,4]
+[1,2,3,4,5,6,7]	\N	-3	[1,2,3,4]
+[1,2,3,4,5,6,7]	\N	\N	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,2,3,4,5,6,7]	-5	-3	[3,4]
+arraySlice(arr1, 2, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,2,3,4,5,6,7]	2	3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+arraySlice(arr1, o, 2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+arraySlice(arr1, 2, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	\N	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+arraySlice(arr1, no, 2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+arraySlice(arr1, -4, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,2,3,4,5,6,7]	2	3	[4,5,6]
+[1,2,3,4,5,6,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,2,3,4,5,6,7]	2	-3	[4]
+arraySlice(arr1, o, -2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+arraySlice(arr1, -4, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	3	[4,5,6]
+[1,2,3,4,5,6,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	\N	[4,5,6,7]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,2,3,4,5,6,7]	2	-3	[4]
+arraySlice(arr1, no, -2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	\N	2	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	\N	2	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+arraySlice(arr1, 2, 4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+arraySlice(arr1, 2, -4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+arraySlice(arr1, -4, 2)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+arraySlice(arr1, -4, -1)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+arrayPushFront(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+arrayPushFront(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+arrayPushFront(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,1,2,3,4,5]
+[1,2,3,4,5,6,7]	[3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+arrayPushFront(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[NULL,1,2,3,4,5]
+[1,2,3,4,5,6,7]	[3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[NULL,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+arrayPushFront([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+[NULL,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushBack(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+arrayPushBack(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+arrayPushBack(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,2,3,4,5,1]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+arrayPushBack(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[1,2,3,4,5,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+arrayPushBack([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[3]
+[-3]
+[-3]
+[4]
+[-3]
+arrayPushBack([1, 2, 3], nl)
+[1,1,1,NULL]
+[NULL]
+[NULL]
+[3]
+[-3]
+[NULL]
+[4]
+[-3]
+arrayPopFront(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+arrayPopBack(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+
+table
+[]	[]	1	\N	1	\N
+[]	[1,NULL]	1	\N	1	\N
+[1,2,3,4,5]	[6,NULL]	2	\N	1	\N
+[1,NULL,3,4,NULL,6,7]	[8]	2	2	3	3
+[1,2,3,NULL,5,6,7]	[NULL,1]	2	\N	-3	-3
+[1,2,3,4,5,NULL,7]	[1,NULL]	2	\N	-3	\N
+[1,2,3,4,5,6,7]	[1,2]	-5	-5	4	4
+[1,NULL,3,NULL,5,6,7]	[]	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+[1,NULL]	[]	[1,NULL]
+[1,2,3,4,5,6,NULL]	[1,2,3,4,5]	[6,NULL]
+[1,NULL,3,4,NULL,6,7,8]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,NULL,1]	[1,2,3,NULL,5,6,7]	[NULL,1]
+[1,2,3,4,5,NULL,7,1,NULL]	[1,2,3,4,5,NULL,7]	[1,NULL]
+[1,2,3,4,5,6,7,1,2]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+[1,NULL]	[]	[1,NULL]
+[1,2,3,4,5,6,NULL,1,2,3,4,5]	[1,2,3,4,5]	[6,NULL]
+[1,NULL,3,4,NULL,6,7,8,1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,NULL,1,1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]	[NULL,1]
+[1,2,3,4,5,NULL,7,1,NULL,1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]	[1,NULL]
+[1,2,3,4,5,6,7,1,2,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7,1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+arraySlice(arr1, o, l)
+[]	1	1	[]
+[]	1	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	-5	-3	[3,NULL]
+arraySlice(arr1, no, nl)
+[]	\N	\N	[]
+[]	\N	\N	[]
+[1,2,3,4,5]	\N	\N	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	\N	-3	[1,2,3,NULL]
+[1,2,3,4,5,NULL,7]	\N	\N	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	-5	-3	[3,NULL]
+arraySlice(arr1, 2, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL,3,NULL]
+arraySlice(arr1, o, 2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3]
+[1,2,3,NULL,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,NULL,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL]
+arraySlice(arr1, 2, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	\N	[2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL,3,NULL]
+arraySlice(arr1, no, 2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3]
+[1,2,3,NULL,5,6,7]	\N	2	[1,2]
+[1,2,3,4,5,NULL,7]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL]
+arraySlice(arr1, -4, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[4,NULL,6]
+[1,2,3,NULL,5,6,7]	2	-3	[NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL]
+arraySlice(arr1, o, -2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	2	2	[2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL,5]
+arraySlice(arr1, -4, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[4,NULL,6]
+[1,2,3,NULL,5,6,7]	2	-3	[NULL]
+[1,2,3,4,5,NULL,7]	2	\N	[4,5,NULL,7]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL]
+arraySlice(arr1, no, -2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	\N	2	[1,2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	\N	2	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL,5]
+arraySlice(arr1, 2, 4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	4	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,3,NULL,5]
+arraySlice(arr1, 2, -4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,NULL,3,4,NULL,6,7]	2	4	[NULL,3]
+[1,2,3,NULL,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,NULL,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,3]
+arraySlice(arr1, -4, 2)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	4	[4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,5]
+arraySlice(arr1, -4, -1)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,NULL,3,4,NULL,6,7]	2	4	[4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,5]
+arrayPushFront(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[3,1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[-3,1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[-3,1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[-3,1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[NULL,1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[3,1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[-3,1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[NULL,1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[-3,1,NULL,3,NULL,5,6,7]
+arrayPushFront([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+[NULL,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushBack(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,1]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7,1]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7,1]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7,1]
+arrayPushBack(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,0.1]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7,0.1]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7,0.1]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7,0.1]
+arrayPushBack(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,2,3,4,5,1]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7,3]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7,-3]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7,-3]
+arrayPushBack(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[1,2,3,4,5,NULL]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7,3]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7,-3]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7,-3]
+arrayPushBack([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[3]
+[-3]
+[-3]
+[4]
+[-3]
+arrayPushBack([1, 2, 3], nl)
+[1,1,1,NULL]
+[NULL]
+[NULL]
+[3]
+[-3]
+[NULL]
+[4]
+[-3]
+arrayPopFront(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7]
+arrayPopBack(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6]
+
+table
+[]	[]	1	\N	1	\N
+[]	[1,2]	1	\N	1	\N
+[1,2,3,4,5]	[6,7]	2	\N	1	\N
+[1,NULL,3,4,NULL,6,7]	[8]	2	2	3	3
+[1,2,3,NULL,5,6,7]	[0,1]	2	\N	-3	-3
+[1,2,3,4,5,NULL,7]	[1,2]	2	\N	-3	\N
+[1,2,3,4,5,6,7]	[1,2]	-5	-5	4	4
+[1,NULL,3,NULL,5,6,7]	[]	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+[1,2]	[]	[1,2]
+[1,2,3,4,5,6,7]	[1,2,3,4,5]	[6,7]
+[1,NULL,3,4,NULL,6,7,8]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,0,1]	[1,2,3,NULL,5,6,7]	[0,1]
+[1,2,3,4,5,NULL,7,1,2]	[1,2,3,4,5,NULL,7]	[1,2]
+[1,2,3,4,5,6,7,1,2]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+[1,2]	[]	[1,2]
+[1,2,3,4,5,6,7,1,2,3,4,5]	[1,2,3,4,5]	[6,7]
+[1,NULL,3,4,NULL,6,7,8,1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,0,1,1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]	[0,1]
+[1,2,3,4,5,NULL,7,1,2,1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]	[1,2]
+[1,2,3,4,5,6,7,1,2,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7,1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+[]	[]	1	\N	1	\N
+[]	[1,2]	1	\N	1	\N
+[1,2,3,4,5]	[6,7]	2	\N	1	\N
+[1,NULL,3,4,NULL,6,7]	[8]	2	2	3	3
+[1,2,3,NULL,5,6,7]	[0,1]	2	\N	-3	-3
+[1,2,3,4,5,NULL,7]	[1,2]	2	\N	-3	\N
+[1,2,3,4,5,6,7]	[1,2]	-5	-5	4	4
+[1,NULL,3,NULL,5,6,7]	[]	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+[1,2]	[]	[1,2]
+[1,2,3,4,5,6,7]	[1,2,3,4,5]	[6,7]
+[1,NULL,3,4,NULL,6,7,8]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,0,1]	[1,2,3,NULL,5,6,7]	[0,1]
+[1,2,3,4,5,NULL,7,1,2]	[1,2,3,4,5,NULL,7]	[1,2]
+[1,2,3,4,5,6,7,1,2]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+[1,2]	[]	[1,2]
+[1,2,3,4,5,6,7,1,2,3,4,5]	[1,2,3,4,5]	[6,7]
+[1,NULL,3,4,NULL,6,7,8,1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,0,1,1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]	[0,1]
+[1,2,3,4,5,NULL,7,1,2,1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]	[1,2]
+[1,2,3,4,5,6,7,1,2,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7,1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+arraySlice(arr1, o, l)
+[]	1	1	[]
+[]	1	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	-5	-3	[3,NULL]
+arraySlice(arr1, no, nl)
+[]	\N	\N	[]
+[]	\N	\N	[]
+[1,2,3,4,5]	\N	\N	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	\N	-3	[1,2,3,NULL]
+[1,2,3,4,5,NULL,7]	\N	\N	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	-5	-3	[3,NULL]
+arraySlice(arr1, 2, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL,3,NULL]
+arraySlice(arr1, o, 2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3]
+[1,2,3,NULL,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,NULL,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL]
+arraySlice(arr1, 2, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	\N	[2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL,3,NULL]
+arraySlice(arr1, no, 2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3]
+[1,2,3,NULL,5,6,7]	\N	2	[1,2]
+[1,2,3,4,5,NULL,7]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL]
+arraySlice(arr1, -4, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[4,NULL,6]
+[1,2,3,NULL,5,6,7]	2	-3	[NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL]
+arraySlice(arr1, o, -2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	2	2	[2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL,5]
+arraySlice(arr1, -4, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[4,NULL,6]
+[1,2,3,NULL,5,6,7]	2	-3	[NULL]
+[1,2,3,4,5,NULL,7]	2	\N	[4,5,NULL,7]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL]
+arraySlice(arr1, no, -2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	\N	2	[1,2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	\N	2	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL,5]
+arraySlice(arr1, 2, 4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	4	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,3,NULL,5]
+arraySlice(arr1, 2, -4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,NULL,3,4,NULL,6,7]	2	4	[NULL,3]
+[1,2,3,NULL,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,NULL,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,3]
+arraySlice(arr1, -4, 2)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	4	[4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,5]
+arraySlice(arr1, -4, -1)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,NULL,3,4,NULL,6,7]	2	4	[4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,5]
+arrayPushFront(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[3,1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[-3,1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[-3,1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[-3,1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[NULL,1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[3,1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[-3,1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[NULL,1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[-3,1,NULL,3,NULL,5,6,7]
+arrayPushFront([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+[NULL,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushBack(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,1]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7,1]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7,1]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7,1]
+arrayPushBack(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,0.1]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7,0.1]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7,0.1]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7,0.1]
+arrayPushBack(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,2,3,4,5,1]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7,3]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7,-3]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7,-3]
+arrayPushBack(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[1,2,3,4,5,NULL]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7,3]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7,-3]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7,-3]
+arrayPushBack([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[3]
+[-3]
+[-3]
+[4]
+[-3]
+arrayPushBack([1, 2, 3], nl)
+[1,1,1,NULL]
+[NULL]
+[NULL]
+[3]
+[-3]
+[NULL]
+[4]
+[-3]
+arrayPopFront(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7]
+arrayPopBack(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6]
+
+table
+[]	[]		\N	1	\N	1	\N
+[]	['1','2']	a	b	1	\N	1	\N
+['1','2','3','4','5']	['6','7']	a	\N	2	\N	1	\N
+['1',NULL,'3','4',NULL,'6','7']	['8']	a	b	2	2	3	3
+['1','2','3',NULL,'5','6','7']	['0','1']	a	\N	2	\N	-3	-3
+['1','2','3','4','5',NULL,'7']	['1','2']	a	b	2	\N	-3	\N
+['1','2','3','4','5','6','7']	['1','2']	a	\N	-5	-5	4	4
+['1',NULL,'3',NULL,'5','6','7']	[]	a	b	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+['1','2']	[]	['1','2']
+['1','2','3','4','5','6','7']	['1','2','3','4','5']	['6','7']
+['1',NULL,'3','4',NULL,'6','7','8']	['1',NULL,'3','4',NULL,'6','7']	['8']
+['1','2','3',NULL,'5','6','7','0','1']	['1','2','3',NULL,'5','6','7']	['0','1']
+['1','2','3','4','5',NULL,'7','1','2']	['1','2','3','4','5',NULL,'7']	['1','2']
+['1','2','3','4','5','6','7','1','2']	['1','2','3','4','5','6','7']	['1','2']
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7']	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+['1','2']	[]	['1','2']
+['1','2','3','4','5','6','7','1','2','3','4','5']	['1','2','3','4','5']	['6','7']
+['1',NULL,'3','4',NULL,'6','7','8','1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6','7']	['8']
+['1','2','3',NULL,'5','6','7','0','1','1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6','7']	['0','1']
+['1','2','3','4','5',NULL,'7','1','2','1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL,'7']	['1','2']
+['1','2','3','4','5','6','7','1','2','1','2','3','4','5','6','7']	['1','2','3','4','5','6','7']	['1','2']
+['1',NULL,'3',NULL,'5','6','7','1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7']	[]
+arraySlice(arr1, o, l)
+[]	1	1	[]
+[]	1	1	[]
+['1','2','3','4','5']	2	1	['2']
+['1',NULL,'3','4',NULL,'6','7']	2	3	[NULL,'3','4']
+['1','2','3',NULL,'5','6','7']	2	-3	['2','3',NULL]
+['1','2','3','4','5',NULL,'7']	2	-3	['2','3','4']
+['1','2','3','4','5','6','7']	-5	4	['3','4','5','6']
+['1',NULL,'3',NULL,'5','6','7']	-5	-3	['3',NULL]
+arraySlice(arr1, no, nl)
+[]	\N	\N	[]
+[]	\N	\N	[]
+['1','2','3','4','5']	\N	\N	['1','2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	2	3	[NULL,'3','4']
+['1','2','3',NULL,'5','6','7']	\N	-3	['1','2','3',NULL]
+['1','2','3','4','5',NULL,'7']	\N	\N	['1','2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	-5	4	['3','4','5','6']
+['1',NULL,'3',NULL,'5','6','7']	-5	-3	['3',NULL]
+arraySlice(arr1, 2, l)
+[]	2	1	[]
+[]	2	1	[]
+['1','2','3','4','5']	2	1	['2']
+['1',NULL,'3','4',NULL,'6','7']	2	3	[NULL,'3','4']
+['1','2','3',NULL,'5','6','7']	2	-3	['2','3',NULL]
+['1','2','3','4','5',NULL,'7']	2	-3	['2','3','4']
+['1','2','3','4','5','6','7']	2	4	['2','3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	-3	[NULL,'3',NULL]
+arraySlice(arr1, o, 2)
+[]	1	2	[]
+[]	1	2	[]
+['1','2','3','4','5']	2	2	['2','3']
+['1',NULL,'3','4',NULL,'6','7']	2	2	[NULL,'3']
+['1','2','3',NULL,'5','6','7']	2	2	['2','3']
+['1','2','3','4','5',NULL,'7']	2	2	['2','3']
+['1','2','3','4','5','6','7']	-5	2	['3','4']
+['1',NULL,'3',NULL,'5','6','7']	-5	2	['3',NULL]
+arraySlice(arr1, 2, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+['1','2','3','4','5']	2	\N	['2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	2	3	[NULL,'3','4']
+['1','2','3',NULL,'5','6','7']	2	-3	['2','3',NULL]
+['1','2','3','4','5',NULL,'7']	2	\N	['2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	2	4	['2','3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	-3	[NULL,'3',NULL]
+arraySlice(arr1, no, 2)
+[]	\N	2	[]
+[]	\N	2	[]
+['1','2','3','4','5']	\N	2	['1','2']
+['1',NULL,'3','4',NULL,'6','7']	2	2	[NULL,'3']
+['1','2','3',NULL,'5','6','7']	\N	2	['1','2']
+['1','2','3','4','5',NULL,'7']	\N	2	['1','2']
+['1','2','3','4','5','6','7']	-5	2	['3','4']
+['1',NULL,'3',NULL,'5','6','7']	-5	2	['3',NULL]
+arraySlice(arr1, -4, l)
+[]	2	1	[]
+[]	2	1	[]
+['1','2','3','4','5']	2	1	['2']
+['1',NULL,'3','4',NULL,'6','7']	2	3	['4',NULL,'6']
+['1','2','3',NULL,'5','6','7']	2	-3	[NULL]
+['1','2','3','4','5',NULL,'7']	2	-3	['4']
+['1','2','3','4','5','6','7']	2	4	['4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	2	-3	[NULL]
+arraySlice(arr1, o, -2)
+[]	1	2	[]
+[]	1	2	[]
+['1','2','3','4','5']	2	2	['2','3']
+['1',NULL,'3','4',NULL,'6','7']	2	2	[NULL,'3','4',NULL]
+['1','2','3',NULL,'5','6','7']	2	2	['2','3',NULL,'5']
+['1','2','3','4','5',NULL,'7']	2	2	['2','3','4','5']
+['1','2','3','4','5','6','7']	-5	2	['3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	-5	2	['3',NULL,'5']
+arraySlice(arr1, -4, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+['1','2','3','4','5']	2	\N	['2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	2	3	['4',NULL,'6']
+['1','2','3',NULL,'5','6','7']	2	-3	[NULL]
+['1','2','3','4','5',NULL,'7']	2	\N	['4','5',NULL,'7']
+['1','2','3','4','5','6','7']	2	4	['4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	2	-3	[NULL]
+arraySlice(arr1, no, -2)
+[]	\N	2	[]
+[]	\N	2	[]
+['1','2','3','4','5']	\N	2	['1','2','3']
+['1',NULL,'3','4',NULL,'6','7']	2	2	[NULL,'3','4',NULL]
+['1','2','3',NULL,'5','6','7']	\N	2	['1','2','3',NULL,'5']
+['1','2','3','4','5',NULL,'7']	\N	2	['1','2','3','4','5']
+['1','2','3','4','5','6','7']	-5	2	['3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	-5	2	['3',NULL,'5']
+arraySlice(arr1, 2, 4)
+[]	2	4	[]
+[]	2	4	[]
+['1','2','3','4','5']	2	4	['2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	2	4	[NULL,'3','4',NULL]
+['1','2','3',NULL,'5','6','7']	2	4	['2','3',NULL,'5']
+['1','2','3','4','5',NULL,'7']	2	4	['2','3','4','5']
+['1','2','3','4','5','6','7']	2	4	['2','3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	4	[NULL,'3',NULL,'5']
+arraySlice(arr1, 2, -4)
+[]	2	4	[]
+[]	2	4	[]
+['1','2','3','4','5']	2	4	[]
+['1',NULL,'3','4',NULL,'6','7']	2	4	[NULL,'3']
+['1','2','3',NULL,'5','6','7']	2	4	['2','3']
+['1','2','3','4','5',NULL,'7']	2	4	['2','3']
+['1','2','3','4','5','6','7']	2	4	['2','3']
+['1',NULL,'3',NULL,'5','6','7']	2	4	[NULL,'3']
+arraySlice(arr1, -4, 2)
+[]	2	4	[]
+[]	2	4	[]
+['1','2','3','4','5']	2	4	['2','3']
+['1',NULL,'3','4',NULL,'6','7']	2	4	['4',NULL]
+['1','2','3',NULL,'5','6','7']	2	4	[NULL,'5']
+['1','2','3','4','5',NULL,'7']	2	4	['4','5']
+['1','2','3','4','5','6','7']	2	4	['4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	4	[NULL,'5']
+arraySlice(arr1, -4, -1)
+[]	2	4	[]
+[]	2	4	[]
+['1','2','3','4','5']	2	4	[]
+['1',NULL,'3','4',NULL,'6','7']	2	4	['4',NULL]
+['1','2','3',NULL,'5','6','7']	2	4	[NULL,'5']
+['1','2','3','4','5',NULL,'7']	2	4	['4','5']
+['1','2','3','4','5','6','7']	2	4	['4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	4	[NULL,'5']
+arrayPushFront(arr1, 1)
+[]	['1']
+[]	['1']
+['1','2','3','4','5']	['1','1','2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	['1','1',NULL,'3','4',NULL,'6','7']
+['1','2','3',NULL,'5','6','7']	['1','1','2','3',NULL,'5','6','7']
+['1','2','3','4','5',NULL,'7']	['1','1','2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	['1','1','2','3','4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	['1','1',NULL,'3',NULL,'5','6','7']
+arrayPushFront(arr1, val)
+[]	['']
+[]	['a']
+['1','2','3','4','5']	['a','1','2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	['a','1',NULL,'3','4',NULL,'6','7']
+['1','2','3',NULL,'5','6','7']	['a','1','2','3',NULL,'5','6','7']
+['1','2','3','4','5',NULL,'7']	['a','1','2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	['a','1','2','3','4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	['a','1',NULL,'3',NULL,'5','6','7']
+arrayPushFront(arr1, val2)
+[]	[NULL]
+[]	['b']
+['1','2','3','4','5']	[NULL,'1','2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	['b','1',NULL,'3','4',NULL,'6','7']
+['1','2','3',NULL,'5','6','7']	[NULL,'1','2','3',NULL,'5','6','7']
+['1','2','3','4','5',NULL,'7']	['b','1','2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	[NULL,'1','2','3','4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	['b','1',NULL,'3',NULL,'5','6','7']
+arrayPushFront([a, b, c], val)
+['','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+arrayPushFront([a, b, c], val2)
+[NULL,'a','b','c']
+['b','a','b','c']
+[NULL,'a','b','c']
+['b','a','b','c']
+[NULL,'a','b','c']
+['b','a','b','c']
+[NULL,'a','b','c']
+['b','a','b','c']
+arrayPushBack(arr1, 1)
+[]	['1']
+[]	['1']
+['1','2','3','4','5']	['1','2','3','4','5','1']
+['1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6','7','1']
+['1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6','7','1']
+['1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL,'7','1']
+['1','2','3','4','5','6','7']	['1','2','3','4','5','6','7','1']
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7','1']
+arrayPushBack(arr1, val)
+[]	['']
+[]	['a']
+['1','2','3','4','5']	['1','2','3','4','5','a']
+['1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6','7','a']
+['1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6','7','a']
+['1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL,'7','a']
+['1','2','3','4','5','6','7']	['1','2','3','4','5','6','7','a']
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7','a']
+arrayPushBack(arr1, val2)
+[]	[NULL]
+[]	['b']
+['1','2','3','4','5']	['1','2','3','4','5',NULL]
+['1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6','7','b']
+['1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6','7',NULL]
+['1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL,'7','b']
+['1','2','3','4','5','6','7']	['1','2','3','4','5','6','7',NULL]
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7','b']
+arrayPushBack([a, b, c], val)
+['a','b','c','']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+arrayPushBack([a, b, c], val2)
+['a','b','c',NULL]
+['a','b','c','b']
+['a','b','c',NULL]
+['a','b','c','b']
+['a','b','c',NULL]
+['a','b','c','b']
+['a','b','c',NULL]
+['a','b','c','b']
+arrayPopFront(arr1)
+[]	[]
+[]	[]
+['1','2','3','4','5']	['2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	[NULL,'3','4',NULL,'6','7']
+['1','2','3',NULL,'5','6','7']	['2','3',NULL,'5','6','7']
+['1','2','3','4','5',NULL,'7']	['2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	['2','3','4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	[NULL,'3',NULL,'5','6','7']
+arrayPopBack(arr1)
+[]	[]
+[]	[]
+['1','2','3','4','5']	['1','2','3','4']
+['1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6']
+['1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6']
+['1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL]
+['1','2','3','4','5','6','7']	['1','2','3','4','5','6']
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6']
diff --git a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
new file mode 100644
index 00000000000..7465fc2c731
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
@@ -0,0 +1,366 @@
+select 'const args';
+select 'concat';
+select arrayConcat(emptyArrayUInt8());
+select arrayConcat(emptyArrayUInt8(), emptyArrayUInt8());
+select arrayConcat(emptyArrayUInt8(), emptyArrayUInt8(), emptyArrayUInt8());
+select arrayConcat([Null], emptyArrayUInt8());
+select arrayConcat([Null], emptyArrayUInt8(), [1]);
+select arrayConcat([1, 2], [-1, -2], [0.3, 0.7], [Null]);
+select arrayConcat(Null, emptyArrayUInt8());
+select arrayConcat([1], [-1], Null);
+select arrayConcat([1, 2], [3, 4]);
+select arrayConcat([1], [2, 3, 4]);
+select arrayConcat(emptyArrayUInt8(), emptyArrayUInt8());
+SELECT arrayConcat(['abc'], ['def', 'gh', 'qwe']);
+SELECT arrayConcat([1, NULL, 2], [3, NULL, 4]);
+select arrayConcat([1, Null, 2], [3, 4]);
+
+select 'slice';
+select arraySlice(Null, 1, 2);
+select arraySlice([1, 2, 3, 4, 5, 6], Null, Null);
+select arraySlice([1, 2, 3, 4, 5, 6], 2, Null);
+select arraySlice([1, 2, 3, 4, 5, 6], Null, 4);
+select arraySlice([1, 2, 3, 4, 5, 6], Null, -2);
+select arraySlice([1, 2, 3, 4, 5, 6], -3, Null);
+select arraySlice([1, 2, 3, 4, 5, 6], 2, 3);
+select arraySlice([1, 2, 3, 4, 5, 6], 2, -2);
+select arraySlice([1, 2, 3, 4, 5, 6], -4, 2);
+select arraySlice([1, 2, 3, 4, 5, 6], -4, -2);
+select arraySlice([1, 2, 3, 4, 5, 6], 2, 0);
+select arraySlice([1, 2, 3, 4, 5, 6], -10, 15);
+select arraySlice([1, 2, 3, 4, 5, 6], 10, 0);
+select arraySlice([1, 2, 3, 4, 5, 6], 10, -1);
+select arraySlice([1, 2, 3, 4, 5, 6], 10, 1);
+select arraySlice([1, 2, Null, 4, 5, 6], 2, 4);
+select arraySlice(['a', 'b', 'c', 'd', 'e'], 2, 3);
+select arraySlice([Null, 'b', Null, 'd', 'e'], 2, 3);
+
+select 'push back';
+select arrayPushBack(Null, 1);
+select arrayPushBack([1], 1);
+select arrayPushBack([Null], 1);
+select arrayPushBack([0.5, 0.7], 1);
+select arrayPushBack([1], -1);
+select arrayPushBack(['a', 'b'], 'cd');
+select arrayPushBack(emptyArrayUInt8(), 1);
+select arrayPushBack(emptyArrayUInt8(), -1);
+
+select 'push front';
+select arrayPushFront(Null, 1);
+select arrayPushFront([1], 1);
+select arrayPushFront([Null], 1);
+select arrayPushFront([0.5, 0.7], 1);
+select arrayPushFront([1], -1);
+select arrayPushFront(['a', 'b'], 'cd');
+select arrayPushFront(emptyArrayUInt8(), 1);
+select arrayPushFront(emptyArrayUInt8(), -1);
+
+select 'pop back';
+select arrayPopBack(Null);
+select arrayPopBack(emptyArrayUInt8());
+select arrayPopBack([1]);
+select arrayPopBack([1, 2, 3]);
+select arrayPopBack([0.1, 0.2, 0.3]);
+select arrayPopBack(['a', 'b', 'c']);
+
+select 'pop front';
+select arrayPopFront(Null);
+select arrayPopFront(emptyArrayUInt8());
+select arrayPopFront([1]);
+select arrayPopFront([1, 2, 3]);
+select arrayPopFront([0.1, 0.2, 0.3]);
+select arrayPopFront(['a', 'b', 'c']);
+
+DROP TABLE if exists test_array_functions;
+select '';
+select 'table';
+create table test_array_functions (arr1 Array(Int8), arr2 Array(Int8), o Int8, no Nullable(Int8), l Int8, nl Nullable(Int8)) engine = TinyLog;
+insert into test_array_functions values ([], [], 1, Null, 1, Null), ([], [1], 1, Null, 1, Null), ([1, 2, 3, 4, 5], [6, 7], 2, Null, 1, Null), ([1, 2, 3, 4, 5, 6, 7], [8], 2, 2, 3, 3), ([1, 2, 3, 4, 5, 6, 7], [], 2, Null, -3, -3), ([1, 2, 3, 4, 5, 6, 7], [], 2, Null, -3, Null), ([1, 2, 3, 4, 5, 6, 7], [], -5, -5, 4, 4), ([1, 2, 3, 4, 5, 6, 7], [], -5, -5, -3, -3);
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+select 'arraySlice(arr1, o, l)';
+select arr1, o, l, arraySlice(arr1, o, l) from test_array_functions;
+select 'arraySlice(arr1, no, nl)';
+select arr1, no, nl, arraySlice(arr1, no, nl) from test_array_functions;
+select 'arraySlice(arr1, 2, l)';
+select arr1, 2, l, arraySlice(arr1, 2, l) from test_array_functions;
+select 'arraySlice(arr1, o, 2)';
+select arr1, o, 2, arraySlice(arr1, o, 2) from test_array_functions;
+select 'arraySlice(arr1, 2, nl)';
+select arr1, 2, nl, arraySlice(arr1, 2, nl) from test_array_functions;
+select 'arraySlice(arr1, no, 2)';
+select arr1, no, 2, arraySlice(arr1, no, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, l)';
+select arr1, 2, l, arraySlice(arr1, -4, l) from test_array_functions;
+select 'arraySlice(arr1, o, -2)';
+select arr1, o, 2, arraySlice(arr1, o, -2) from test_array_functions;
+select 'arraySlice(arr1, -4, nl)';
+select arr1, 2, nl, arraySlice(arr1, -4, nl) from test_array_functions;
+select 'arraySlice(arr1, no, -2)';
+select arr1, no, 2, arraySlice(arr1, no, -2) from test_array_functions;
+select 'arraySlice(arr1, 2, 4)';
+select arr1, 2, 4, arraySlice(arr1, 2, 4) from test_array_functions;
+select 'arraySlice(arr1, 2, -4)';
+select arr1, 2, 4, arraySlice(arr1, 2, -4) from test_array_functions;
+select 'arraySlice(arr1, -4, 2)';
+select arr1, 2, 4, arraySlice(arr1, -4, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, -1)';
+select arr1, 2, 4, arraySlice(arr1, -4, -1) from test_array_functions;
+
+select 'arrayPushFront(arr1, 1)';
+select arr1, arrayPushFront(arr1, 1) from test_array_functions;
+select 'arrayPushFront(arr1, 0.1)';
+select arr1, arrayPushFront(arr1, 0.1) from test_array_functions;
+select 'arrayPushFront(arr1, l)';
+select arr1, arrayPushFront(arr1, l) from test_array_functions;
+select 'arrayPushFront(arr1, nl)';
+select arr1, arrayPushFront(arr1, nl) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], l)';
+select arrayPushFront([1, 2, 3], l) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], nl)' from test_array_functions;
+select arrayPushFront([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPushBack(arr1, 1)';
+select arr1, arrayPushBack(arr1, 1) from test_array_functions;
+select 'arrayPushBack(arr1, 0.1)';
+select arr1, arrayPushBack(arr1, 0.1) from test_array_functions;
+select 'arrayPushBack(arr1, l)';
+select arr1, arrayPushBack(arr1, l) from test_array_functions;
+select 'arrayPushBack(arr1, nl)';
+select arr1, arrayPushBack(arr1, nl) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], l)';
+select arrayPushBack([1, 2, 3], l) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], nl)';
+select arrayPushBack([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPopFront(arr1)';
+select arr1, arrayPopFront(arr1) from test_array_functions;
+select 'arrayPopBack(arr1)';
+select arr1, arrayPopBack(arr1) from test_array_functions;
+
+
+DROP TABLE if exists test_array_functions;
+select '';
+select 'table';
+create table test_array_functions (arr1 Array(Nullable(Int8)), arr2 Array(Nullable(Float32)), o Int8, no Nullable(Int8), l Int8, nl Nullable(Int8)) engine = TinyLog;
+insert into test_array_functions values ([], [], 1, Null, 1, Null), ([], [1, Null], 1, Null, 1, Null), ([1, 2, 3, 4, 5], [6, Null], 2, Null, 1, Null), ([1, Null, 3, 4, Null, 6, 7], [8], 2, 2, 3, 3),([1, 2, 3, Null, 5, 6, 7], [Null, 1], 2, Null, -3, -3),([1, 2, 3, 4, 5, Null, 7], [1, Null], 2, Null, -3, Null), ([1, 2, 3, 4, 5, 6, 7], [1, 2], -5, -5, 4, 4),([1, Null, 3, Null, 5, 6, 7], [], -5, -5, -3, -3);
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+select 'arraySlice(arr1, o, l)';
+select arr1, o, l, arraySlice(arr1, o, l) from test_array_functions;
+select 'arraySlice(arr1, no, nl)';
+select arr1, no, nl, arraySlice(arr1, no, nl) from test_array_functions;
+select 'arraySlice(arr1, 2, l)';
+select arr1, 2, l, arraySlice(arr1, 2, l) from test_array_functions;
+select 'arraySlice(arr1, o, 2)';
+select arr1, o, 2, arraySlice(arr1, o, 2) from test_array_functions;
+select 'arraySlice(arr1, 2, nl)';
+select arr1, 2, nl, arraySlice(arr1, 2, nl) from test_array_functions;
+select 'arraySlice(arr1, no, 2)';
+select arr1, no, 2, arraySlice(arr1, no, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, l)';
+select arr1, 2, l, arraySlice(arr1, -4, l) from test_array_functions;
+select 'arraySlice(arr1, o, -2)';
+select arr1, o, 2, arraySlice(arr1, o, -2) from test_array_functions;
+select 'arraySlice(arr1, -4, nl)';
+select arr1, 2, nl, arraySlice(arr1, -4, nl) from test_array_functions;
+select 'arraySlice(arr1, no, -2)';
+select arr1, no, 2, arraySlice(arr1, no, -2) from test_array_functions;
+select 'arraySlice(arr1, 2, 4)';
+select arr1, 2, 4, arraySlice(arr1, 2, 4) from test_array_functions;
+select 'arraySlice(arr1, 2, -4)';
+select arr1, 2, 4, arraySlice(arr1, 2, -4) from test_array_functions;
+select 'arraySlice(arr1, -4, 2)';
+select arr1, 2, 4, arraySlice(arr1, -4, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, -1)';
+select arr1, 2, 4, arraySlice(arr1, -4, -1) from test_array_functions;
+
+select 'arrayPushFront(arr1, 1)';
+select arr1, arrayPushFront(arr1, 1) from test_array_functions;
+select 'arrayPushFront(arr1, 0.1)';
+select arr1, arrayPushFront(arr1, 0.1) from test_array_functions;
+select 'arrayPushFront(arr1, l)';
+select arr1, arrayPushFront(arr1, l) from test_array_functions;
+select 'arrayPushFront(arr1, nl)';
+select arr1, arrayPushFront(arr1, nl) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], l)';
+select arrayPushFront([1, 2, 3], l) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], nl)' from test_array_functions;
+select arrayPushFront([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPushBack(arr1, 1)';
+select arr1, arrayPushBack(arr1, 1) from test_array_functions;
+select 'arrayPushBack(arr1, 0.1)';
+select arr1, arrayPushBack(arr1, 0.1) from test_array_functions;
+select 'arrayPushBack(arr1, l)';
+select arr1, arrayPushBack(arr1, l) from test_array_functions;
+select 'arrayPushBack(arr1, nl)';
+select arr1, arrayPushBack(arr1, nl) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], l)';
+select arrayPushBack([1, 2, 3], l) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], nl)';
+select arrayPushBack([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPopFront(arr1)';
+select arr1, arrayPopFront(arr1) from test_array_functions;
+select 'arrayPopBack(arr1)';
+select arr1, arrayPopBack(arr1) from test_array_functions;
+
+
+DROP TABLE if exists test_array_functions;
+select '';
+select 'table';
+create table test_array_functions (arr1 Array(Nullable(Int8)), arr2 Array(UInt8), o Int8, no Nullable(Int8), l Int8, nl Nullable(Int8)) engine = TinyLog;
+insert into test_array_functions values ([], [], 1, Null, 1, Null), ([], [1, 2], 1, Null, 1, Null), ([1, 2, 3, 4, 5], [6, 7], 2, Null, 1, Null), ([1, Null,3,4, Null, 6, 7], [8], 2, 2, 3, 3),([1, 2, 3, Null, 5, 6, 7], [0, 1], 2, Null, -3, -3),([1, 2, 3, 4, 5, Null, 7], [1, 2], 2, Null, -3, Null),([1, 2, 3,4, 5, 6, 7], [1, 2], -5, -5, 4, 4),([1, Null, 3, Null, 5, 6, 7], [], -5, -5, -3, -3);
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+select 'arraySlice(arr1, o, l)';
+select arr1, o, l, arraySlice(arr1, o, l) from test_array_functions;
+select 'arraySlice(arr1, no, nl)';
+select arr1, no, nl, arraySlice(arr1, no, nl) from test_array_functions;
+select 'arraySlice(arr1, 2, l)';
+select arr1, 2, l, arraySlice(arr1, 2, l) from test_array_functions;
+select 'arraySlice(arr1, o, 2)';
+select arr1, o, 2, arraySlice(arr1, o, 2) from test_array_functions;
+select 'arraySlice(arr1, 2, nl)';
+select arr1, 2, nl, arraySlice(arr1, 2, nl) from test_array_functions;
+select 'arraySlice(arr1, no, 2)';
+select arr1, no, 2, arraySlice(arr1, no, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, l)';
+select arr1, 2, l, arraySlice(arr1, -4, l) from test_array_functions;
+select 'arraySlice(arr1, o, -2)';
+select arr1, o, 2, arraySlice(arr1, o, -2) from test_array_functions;
+select 'arraySlice(arr1, -4, nl)';
+select arr1, 2, nl, arraySlice(arr1, -4, nl) from test_array_functions;
+select 'arraySlice(arr1, no, -2)';
+select arr1, no, 2, arraySlice(arr1, no, -2) from test_array_functions;
+select 'arraySlice(arr1, 2, 4)';
+select arr1, 2, 4, arraySlice(arr1, 2, 4) from test_array_functions;
+select 'arraySlice(arr1, 2, -4)';
+select arr1, 2, 4, arraySlice(arr1, 2, -4) from test_array_functions;
+select 'arraySlice(arr1, -4, 2)';
+select arr1, 2, 4, arraySlice(arr1, -4, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, -1)';
+select arr1, 2, 4, arraySlice(arr1, -4, -1) from test_array_functions;
+
+select 'arrayPushFront(arr1, 1)';
+select arr1, arrayPushFront(arr1, 1) from test_array_functions;
+select 'arrayPushFront(arr1, 0.1)';
+select arr1, arrayPushFront(arr1, 0.1) from test_array_functions;
+select 'arrayPushFront(arr1, l)';
+select arr1, arrayPushFront(arr1, l) from test_array_functions;
+select 'arrayPushFront(arr1, nl)';
+select arr1, arrayPushFront(arr1, nl) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], l)';
+select arrayPushFront([1, 2, 3], l) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], nl)' from test_array_functions;
+select arrayPushFront([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPushBack(arr1, 1)';
+select arr1, arrayPushBack(arr1, 1) from test_array_functions;
+select 'arrayPushBack(arr1, 0.1)';
+select arr1, arrayPushBack(arr1, 0.1) from test_array_functions;
+select 'arrayPushBack(arr1, l)';
+select arr1, arrayPushBack(arr1, l) from test_array_functions;
+select 'arrayPushBack(arr1, nl)';
+select arr1, arrayPushBack(arr1, nl) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], l)';
+select arrayPushBack([1, 2, 3], l) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], nl)';
+select arrayPushBack([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPopFront(arr1)';
+select arr1, arrayPopFront(arr1) from test_array_functions;
+select 'arrayPopBack(arr1)';
+select arr1, arrayPopBack(arr1) from test_array_functions;
+
+DROP TABLE if exists test_array_functions;
+select '';
+select 'table';
+create table test_array_functions (arr1 Array(Nullable(String)), arr2 Array(String), val String, val2 Nullable(String), o Int8, no Nullable(Int8), l Int8, nl Nullable(Int8)) engine = TinyLog;
+insert into test_array_functions values ([], [], '', Null, 1, Null, 1, Null), ([], ['1', '2'], 'a', 'b', 1, Null, 1, Null), (['1', '2', '3', '4', '5'], ['6','7'], 'a', Null, 2, Null, 1, Null), (['1', Null, '3', '4', Null, '6', '7'], ['8'], 'a', 'b', 2, 2, 3, 3),(['1', '2', '3', Null, '5', '6', '7'], ['0','1'], 'a', Null, 2, Null, -3, -3),(['1', '2', '3', '4', '5', Null, '7'], ['1', '2'], 'a', 'b', 2, Null, -3, Null),(['1', '2', '3', '4', '5', '6', '7'],['1', '2'], 'a', Null, -5, -5, 4, 4),(['1', Null, '3', Null, '5', '6', '7'], [], 'a', 'b', -5, -5, -3, -3);
+
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+select 'arraySlice(arr1, o, l)';
+select arr1, o, l, arraySlice(arr1, o, l) from test_array_functions;
+select 'arraySlice(arr1, no, nl)';
+select arr1, no, nl, arraySlice(arr1, no, nl) from test_array_functions;
+select 'arraySlice(arr1, 2, l)';
+select arr1, 2, l, arraySlice(arr1, 2, l) from test_array_functions;
+select 'arraySlice(arr1, o, 2)';
+select arr1, o, 2, arraySlice(arr1, o, 2) from test_array_functions;
+select 'arraySlice(arr1, 2, nl)';
+select arr1, 2, nl, arraySlice(arr1, 2, nl) from test_array_functions;
+select 'arraySlice(arr1, no, 2)';
+select arr1, no, 2, arraySlice(arr1, no, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, l)';
+select arr1, 2, l, arraySlice(arr1, -4, l) from test_array_functions;
+select 'arraySlice(arr1, o, -2)';
+select arr1, o, 2, arraySlice(arr1, o, -2) from test_array_functions;
+select 'arraySlice(arr1, -4, nl)';
+select arr1, 2, nl, arraySlice(arr1, -4, nl) from test_array_functions;
+select 'arraySlice(arr1, no, -2)';
+select arr1, no, 2, arraySlice(arr1, no, -2) from test_array_functions;
+select 'arraySlice(arr1, 2, 4)';
+select arr1, 2, 4, arraySlice(arr1, 2, 4) from test_array_functions;
+select 'arraySlice(arr1, 2, -4)';
+select arr1, 2, 4, arraySlice(arr1, 2, -4) from test_array_functions;
+select 'arraySlice(arr1, -4, 2)';
+select arr1, 2, 4, arraySlice(arr1, -4, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, -1)';
+select arr1, 2, 4, arraySlice(arr1, -4, -1) from test_array_functions;
+
+select 'arrayPushFront(arr1, 1)';
+select arr1, arrayPushFront(arr1, '1') from test_array_functions;
+select 'arrayPushFront(arr1, val)';
+select arr1, arrayPushFront(arr1, val) from test_array_functions;
+select 'arrayPushFront(arr1, val2)';
+select arr1, arrayPushFront(arr1, val2) from test_array_functions;
+select 'arrayPushFront([a, b, c], val)';
+select arrayPushFront(['a', 'b', 'c'], val) from test_array_functions;
+select 'arrayPushFront([a, b, c], val2)';
+select arrayPushFront(['a', 'b', 'c'], val2) from test_array_functions;
+
+select 'arrayPushBack(arr1, 1)';
+select arr1, arrayPushBack(arr1, '1') from test_array_functions;
+select 'arrayPushBack(arr1, val)';
+select arr1, arrayPushBack(arr1, val) from test_array_functions;
+select 'arrayPushBack(arr1, val2)';
+select arr1, arrayPushBack(arr1, val2) from test_array_functions;
+select 'arrayPushBack([a, b, c], val)';
+select arrayPushBack(['a', 'b', 'c'], val) from test_array_functions;
+select 'arrayPushBack([a, b, c], val2)';
+select arrayPushBack(['a', 'b', 'c'], val2) from test_array_functions;
+
+select 'arrayPopFront(arr1)';
+select arr1, arrayPopFront(arr1) from test_array_functions;
+select 'arrayPopBack(arr1)';
+select arr1, arrayPopBack(arr1) from test_array_functions;

From 0f4e7f1833c653173db848803bd3a7fd93ec9e7d Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 25 Aug 2017 14:19:54 +0300
Subject: [PATCH 09/30] fixed array slice with offset <= -(array length)
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 90ffb574f14..93f755ce4e0 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -149,7 +149,7 @@ struct NumericArraySource : public IArraySource
     {
         size_t elem_size = offsets[row_num] - prev_offset;
         if (offset >= elem_size)
-            return {&elements[prev_offset], 0};
+            return {&elements[prev_offset], elem_size};
         return {&elements[offsets[row_num] - offset], offset};
     }
 
@@ -157,7 +157,7 @@ struct NumericArraySource : public IArraySource
     {
         size_t elem_size = offsets[row_num] - prev_offset;
         if (offset >= elem_size)
-            return {&elements[prev_offset], 0};
+            return {&elements[prev_offset], length + elem_size > offset ? std::min(elem_size, length + elem_size - offset) : 0};
         return {&elements[offsets[row_num] - offset], std::min(length, offset)};
     }
 };
@@ -621,7 +621,7 @@ struct GenericArraySource : public IArraySource
     {
         size_t elem_size = offsets[row_num] - prev_offset;
         if (offset >= elem_size)
-            return {&elements, prev_offset, 0};
+            return {&elements, prev_offset, elem_size};
         return {&elements, offsets[row_num] - offset, offset};
     }
 
@@ -629,7 +629,7 @@ struct GenericArraySource : public IArraySource
     {
         size_t elem_size = offsets[row_num] - prev_offset;
         if (offset >= elem_size)
-            return {&elements, prev_offset, 0};
+            return {&elements, prev_offset, length + elem_size > offset ? std::min(elem_size, length + elem_size - offset) : 0};
         return {&elements, offsets[row_num] - offset, std::min(length, offset)};
     }
 };
@@ -706,40 +706,40 @@ struct NullableArraySource : public ArraySource
     Slice getSliceFromLeft(size_t offset) const
     {
         Slice slice = ArraySource::getSliceFromLeft(offset);
-        if (!slice.size)
-            slice.null_map = &null_map[prev_offset];
-        else
+        if (offsets[row_num] > prev_offset + offset)
             slice.null_map = &null_map[prev_offset + offset];
+        else
+            slice.null_map = &null_map[prev_offset];
         return slice;
     }
 
     Slice getSliceFromLeft(size_t offset, size_t length) const
     {
         Slice slice = ArraySource::getSliceFromLeft(offset, length);
-        if (!slice.size)
-            slice.null_map = &null_map[prev_offset];
-        else
+        if (offsets[row_num] > prev_offset + offset)
             slice.null_map = &null_map[prev_offset + offset];
+        else
+            slice.null_map = &null_map[prev_offset];
         return slice;
     }
 
     Slice getSliceFromRight(size_t offset) const
     {
         Slice slice = ArraySource::getSliceFromRight(offset);
-        if (!slice.size)
-            slice.null_map = &null_map[prev_offset];
-        else
+        if (offsets[row_num] > prev_offset + offset)
             slice.null_map = &null_map[offsets[row_num] - offset];
+        else
+            slice.null_map = &null_map[prev_offset];
         return slice;
     }
 
     Slice getSliceFromRight(size_t offset, size_t length) const
     {
         Slice slice = ArraySource::getSliceFromRight(offset, length);
-        if (!slice.size)
-            slice.null_map = &null_map[prev_offset];
-        else
+        if (offsets[row_num] > prev_offset + offset)
             slice.null_map = &null_map[offsets[row_num] - offset];
+        else
+            slice.null_map = &null_map[prev_offset];
         return slice;
     }
 

From e223d070311d6a775c08a1a2ccd4a5030e6d6396 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 25 Aug 2017 14:58:33 +0300
Subject: [PATCH 10/30] fixed test [#CLICKHOUSE-2090]

---
 .../00498_array_functions_concat_slice_push_pop.reference       | 2 ++
 .../0_stateless/00498_array_functions_concat_slice_push_pop.sql | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
index e46a94775cd..319518f5efb 100644
--- a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
+++ b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
@@ -26,6 +26,8 @@ slice
 [3,4]
 [3,4]
 []
+[1,2,3,4,5,6]
+[1]
 []
 []
 []
diff --git a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
index 7465fc2c731..2540d2b3fe4 100644
--- a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
+++ b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
@@ -28,6 +28,8 @@ select arraySlice([1, 2, 3, 4, 5, 6], -4, 2);
 select arraySlice([1, 2, 3, 4, 5, 6], -4, -2);
 select arraySlice([1, 2, 3, 4, 5, 6], 2, 0);
 select arraySlice([1, 2, 3, 4, 5, 6], -10, 15);
+select arraySlice([1, 2, 3, 4, 5, 6], -15, 10);
+select arraySlice([1, 2, 3, 4, 5, 6], -15, 9);
 select arraySlice([1, 2, 3, 4, 5, 6], 10, 0);
 select arraySlice([1, 2, 3, 4, 5, 6], 10, -1);
 select arraySlice([1, 2, 3, 4, 5, 6], 10, 1);

From 1ec04d1024b71df543dcb7202eca60a9487a14d4 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 25 Aug 2017 16:05:26 +0300
Subject: [PATCH 11/30] supported || for arrayConcat [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsString.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/dbms/src/Functions/FunctionsString.cpp b/dbms/src/Functions/FunctionsString.cpp
index e1cdc8dc6a1..de1d3686fc0 100644
--- a/dbms/src/Functions/FunctionsString.cpp
+++ b/dbms/src/Functions/FunctionsString.cpp
@@ -683,6 +683,9 @@ public:
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
+        if (!is_injective && !arguments.empty() && checkDataType<DataTypeArray>(arguments[0].get()))
+            return FunctionArrayConcat().getReturnTypeImpl(arguments);
+
         if (arguments.size() < 2)
             throw Exception("Number of arguments for function " + getName() + " doesn't match: passed " + toString(arguments.size())
                 + ", should be at least 2.",
@@ -702,6 +705,9 @@ public:
 
     void executeImpl(Block & block, const ColumnNumbers & arguments, const size_t result) override
     {
+        if (!is_injective && !arguments.empty() && checkDataType<DataTypeArray>(block.getByPosition(0).type.get()))
+            return FunctionArrayConcat().executeImpl(block, arguments, result);
+
         if (arguments.size() == 2)
             executeBinary(block, arguments, result);
         else

From 24e135fbe6c2d2d2d73fcd6a3fdeccf51b843d66 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 25 Aug 2017 16:54:08 +0300
Subject: [PATCH 12/30] supported arraySlice with 2 arguments, added comments
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.cpp | 17 ++++++++++++-----
 dbms/src/Functions/FunctionsArray.h   | 20 ++++++++++++++++++--
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 9637997ba19..47cbb030a39 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -3051,6 +3051,13 @@ String FunctionArraySlice::getName() const
 
 DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) const
 {
+    size_t number_of_arguments = arguments.size();
+
+    if (number_of_arguments < 2 || number_of_arguments > 3)
+        throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
+                        + toString(number_of_arguments) + ", should be 2 or 3",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
     if (arguments[0]->isNull())
         return arguments[0];
 
@@ -3059,7 +3066,7 @@ DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) c
         throw Exception("First argument for function " + getName() + " must be an array but it has type "
                         + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
-    for (size_t i = 1; i < arguments.size(); ++i)
+    for (size_t i = 1; i < number_of_arguments; ++i)
     {
         if (!arguments[i]->isNumeric() && !arguments[i]->isNull())
             throw Exception(
@@ -3079,7 +3086,7 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
 
     auto array_column = block.getByPosition(arguments[0]).column;
     auto offset_column = block.getByPosition(arguments[1]).column;
-    auto length_column = block.getByPosition(arguments[2]).column;
+    auto length_column = arguments.size() > 2 ? block.getByPosition(arguments[2]).column : nullptr;
 
     if (return_type->isNull())
     {
@@ -3107,7 +3114,7 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
 
     if (offset_column->isNull())
     {
-        if (length_column->isNull())
+        if (!length_column || length_column->isNull())
             result_column = array_column->clone();
         else if (length_column->isConst())
             sliceFromLeftConstantOffsetBounded(*source, *sink, 0, length_column->getInt(0));
@@ -3121,7 +3128,7 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
     {
         ssize_t offset = offset_column->getUInt(0);
 
-        if (length_column->isNull())
+        if (!length_column || length_column->isNull())
         {
             if (offset > 0)
                 sliceFromLeftConstantOffsetUnbounded(*source, *sink, static_cast<size_t>(offset - 1));
@@ -3141,7 +3148,7 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
     }
     else
     {
-        if (length_column->isNull())
+        if (!length_column || length_column->isNull())
             sliceDynamicOffsetUnbounded(*source, *sink, *offset_column);
         else
             sliceDynamicOffsetBounded(*source, *sink, *offset_column, *length_column);
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index 9d3740309f0..af2f04adff2 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -61,6 +61,22 @@ namespace ErrorCodes
   *
   * arrayReduce('agg', arr1, ...) - apply the aggregate function `agg` to arrays `arr1...`
   *  If multiple arrays passed, then elements on corresponding positions are passed as multiple arguments to the aggregate function.
+  *
+  *  arrayConcat(arr1, ...) - concatenate arrays.
+  *
+  *  arraySlice(arr, offset, length) - make slice of array. Offsets and length may be < 0 or Null
+  *   - if offset <= 0, indexation from right element
+  *   - if length < 0, length = len(array) - (positive_index(offset) - 1) + length
+  *   indexation:
+  *     [ 1,  2,  3,  4,  5,  6]
+  *     [-5, -4, -3, -2, -1,  0]
+  *   examples:
+  *     arraySlice([1, 2, 3, 4, 5, 6], -4, 2) -> [2, 3]
+  *     arraySlice([1, 2, 3, 4, 5, 6], 2, -1) -> [2, 3, 4, 5] (6 - (2 - 1) + (-1) = 4)
+  *     arraySlice([1, 2, 3, 4, 5, 6], -4, -1) = arraySlice([1, 2, 3, 4, 5, 6], -4, -1) -> [2, 3, 4, 5]
+  *
+  *  arrayPushBack(arr, x), arrayPushFront(arr, x)
+  *  arrayPopBack(arr), arrayPopFront(arr)
   */
 
 
@@ -1433,8 +1449,8 @@ public:
 
     String getName() const override;
 
-    bool isVariadic() const override { return false; }
-    size_t getNumberOfArguments() const override { return 3; }
+    bool isVariadic() const override { return true; }
+    size_t getNumberOfArguments() const override { return 0; }
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
 

From c6f87d95430913695d71721ce05bd1b3a17f9590 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Thu, 31 Aug 2017 19:24:46 +0300
Subject: [PATCH 13/30] Update GatherUtils.h

---
 dbms/src/Functions/GatherUtils.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index c554b7e468a..1886f412a92 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -894,7 +894,7 @@ inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, FixedStr
 /// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArraySink & sink)
 {
-    if (std::type_index(typeid(slice.elements)) == std::type_index(typeid(&sink.elements)))
+    if (typeid(slice.elements) == typeid(&sink.elements))
         sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
     else
     {

From 1b8100ae8694a148a594907ec256e51c75dfd9db Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Thu, 31 Aug 2017 20:00:51 +0300
Subject: [PATCH 14/30] Update FunctionsArray.cpp

---
 dbms/src/Functions/FunctionsArray.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 47cbb030a39..4d65860f11d 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -19,7 +19,6 @@
 #include <Columns/ColumnAggregateFunction.h>
 #include <tuple>
 #include <array>
-#include <iostream>
 
 
 namespace DB

From c0b05f2ca97864ea82387ba550e78483cc2d8342 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 14:02:26 +0300
Subject: [PATCH 15/30] hanged & to && in GatherUtils [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 56 ++++----------------------------
 1 file changed, 7 insertions(+), 49 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 1886f412a92..59d0b9427aa 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -954,7 +954,7 @@ inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink
 /// Algorithms
 
 template <typename SourceA, typename SourceB, typename Sink>
-void NO_INLINE concat(SourceA & src_a, SourceB & src_b, Sink & sink)
+void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
 {
     sink.reserve(src_a.getSizeForReserve() + src_b.getSizeForReserve());
 
@@ -969,12 +969,6 @@ void NO_INLINE concat(SourceA & src_a, SourceB & src_b, Sink & sink)
     }
 }
 
-template <typename SourceA, typename SourceB, typename Sink>
-void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
-{
-    concat(src_a, src_b, sink);
-}
-
 template <typename Sink>
 void NO_INLINE concat(StringSources & sources, Sink && sink)
 {
@@ -993,7 +987,7 @@ void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & s
 
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
+void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
 {
     while (!src.isEnd())
     {
@@ -1004,7 +998,7 @@ void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source & src, Sink & sink, s
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetBounded(Source & src, Sink & sink, size_t offset, ssize_t length)
+void NO_INLINE sliceFromLeftConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
 {
     while (!src.isEnd())
     {
@@ -1021,7 +1015,7 @@ void NO_INLINE sliceFromLeftConstantOffsetBounded(Source & src, Sink & sink, siz
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
+void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
 {
     while (!src.isEnd())
     {
@@ -1032,7 +1026,7 @@ void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source & src, Sink & sink,
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetBounded(Source & src, Sink & sink, size_t offset, ssize_t length)
+void NO_INLINE sliceFromRightConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
 {
     while (!src.isEnd())
     {
@@ -1049,7 +1043,7 @@ void NO_INLINE sliceFromRightConstantOffsetBounded(Source & src, Sink & sink, si
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetUnbounded(Source & src, Sink & sink, IColumn & offset_column)
+void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn & offset_column)
 {
     const bool is_null = offset_column.isNull();
     auto * nullable = typeid_cast<ColumnNullable *>(&offset_column);
@@ -1080,7 +1074,7 @@ void NO_INLINE sliceDynamicOffsetUnbounded(Source & src, Sink & sink, IColumn &
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetBounded(Source & src, Sink & sink, IColumn & offset_column, IColumn & length_column)
+void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn & offset_column, IColumn & length_column)
 {
     const bool is_offset_null = offset_column.isNull();
     auto * offset_nullable = typeid_cast<ColumnNullable *>(&offset_column);
@@ -1121,42 +1115,6 @@ void NO_INLINE sliceDynamicOffsetBounded(Source & src, Sink & sink, IColumn & of
 }
 
 
-template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
-{
-    sliceFromLeftConstantOffsetUnbounded(src, sink, offset);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
-{
-    sliceFromLeftConstantOffsetBounded(src, sink, offset, length);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
-{
-    sliceFromRightConstantOffsetUnbounded(src, sink, offset);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
-{
-    sliceFromRightConstantOffsetBounded(src, sink, offset, length);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn & offset_column)
-{
-    sliceDynamicOffsetUnbounded(src, sink, offset_column);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn & offset_column, IColumn & length_column)
-{
-    sliceDynamicOffsetBounded(src, sink, offset_column, length_column);
-}
-
 void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset);
 
 void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length);

From c695f10c6642fc5fcdac62b6533d5311a3357d5b Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 14:32:31 +0300
Subject: [PATCH 16/30] hanged & to && in GatherUtils [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index fc10670de00..e86b0e9e482 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -394,7 +394,7 @@ struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
     {
-        sliceFromLeftConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+        sliceFromLeftConstantOffsetUnbounded(source, sink, offset);
     }
 };
 
@@ -404,7 +404,7 @@ struct SliceFromLeftConstantOffsetBoundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
     {
-        sliceFromLeftConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+        sliceFromLeftConstantOffsetBounded(source, sink, offset, length);
     }
 };
 
@@ -414,7 +414,7 @@ struct SliceFromRightConstantOffsetUnboundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
     {
-        sliceFromRightConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+        sliceFromRightConstantOffsetUnbounded(source, sink, offset);
     }
 };
 
@@ -424,7 +424,7 @@ struct SliceFromRightConstantOffsetBoundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
     {
-        sliceFromRightConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+        sliceFromRightConstantOffsetBounded(source, sink, offset, length);
     }
 };
 
@@ -434,7 +434,7 @@ struct SliceDynamicOffsetUnboundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
     {
-        sliceDynamicOffsetUnbounded<Source, Sink>(source, sink, offset_column);
+        sliceDynamicOffsetUnbounded(source, sink, offset_column);
     }
 };
 
@@ -444,7 +444,7 @@ struct SliceDynamicOffsetBoundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
     {
-        sliceDynamicOffsetBounded<Source, Sink>(source, sink, offset_column, length_column);
+        sliceDynamicOffsetBounded(source, sink, offset_column, length_column);
     }
 };
 

From 78915965795c7d2f7b5ffc61e5b84033363ac14e Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 15:05:19 +0300
Subject: [PATCH 17/30] unified TypeList [#CLICKHOUSE-2090]

---
 dbms/src/Common/TypeList.h                    | 49 +++++++++++++------
 dbms/src/Functions/GatherUtils.cpp            |  4 +-
 dbms/src/Interpreters/SpecializedAggregator.h | 38 +-------------
 3 files changed, 37 insertions(+), 54 deletions(-)

diff --git a/dbms/src/Common/TypeList.h b/dbms/src/Common/TypeList.h
index 607f81720c0..8a683de74d8 100644
--- a/dbms/src/Common/TypeList.h
+++ b/dbms/src/Common/TypeList.h
@@ -3,34 +3,53 @@
 namespace DB
 {
 
-template <typename ... Types>
-struct TypeList;
-
-template <typename Type, typename ... Types>
-struct TypeList<Type, Types...>
+template <typename... TTail>
+struct TypeList
 {
-    using Head = Type;
-    using Tail = TypeList<Types ...>;
+    static constexpr size_t size = 0;
+
+    template <size_t I>
+    using At = std::nullptr_t;
+
+    template <typename Func, size_t index = 0>
+    static void forEach(Func && func)
+    {
+    }
 };
 
-template<>
-struct TypeList<>
+
+template <typename THead, typename... TTail>
+struct TypeList<THead, TTail...>
 {
+    using Head = THead;
+    using Tail = TypeList<TTail...>;
+
+    static constexpr size_t size = 1 + sizeof...(TTail);
+
+    template <size_t I>
+    using At = typename std::template conditional<I == 0, Head, typename Tail::template At<I - 1>>::type;
+
+    template <typename Func, size_t index = 0>
+    static void ALWAYS_INLINE forEach(Func && func)
+    {
+        func.template operator()<Head, index>();
+        Tail::template forEach<Func, index + 1>(std::forward<Func>(func));
+    }
 };
 
 /// Append Type to TypeList
 /// Usage:
 ///     using TypeListWithType = typename AppendToTypeList<Type, ConcreteTypeList>::Type;
-template <typename TypeToAppend, typename List, typename ... Types>
-struct AppendToTypeList
+template <typename TypeToPrepend, typename List, typename ... Types>
+struct PrependToTypeList
 {
-    using Type = typename AppendToTypeList<TypeToAppend, typename List::Tail, Types ..., typename List::Head>::Type;
+    using Type = typename PrependToTypeList<TypeToPrepend, typename List::Tail, Types ..., typename List::Head>::Type;
 };
 
-template <typename TypeToAppend, typename ... Types>
-struct AppendToTypeList<TypeToAppend, TypeList<>, Types ...>
+template <typename TypeToPrepend, typename ... Types>
+struct PrependToTypeList<TypeToPrepend, TypeList<>, Types ...>
 {
-    using Type = TypeList<TypeToAppend, Types ...>;
+    using Type = TypeList<TypeToPrepend, Types ...>;
 };
 
 /// Apply TypeList as variadic template argument of Class.
diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index e86b0e9e482..861f549b498 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -149,7 +149,7 @@ struct ArraySourceSelector<Base>
 };
 
 template <typename Base>
-using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename PrependToTypeList<Base, TypeListNumber>::Type>::Type;
 
 template <typename Base, typename ... Types>
 struct ArraySinkSelector;
@@ -185,7 +185,7 @@ struct ArraySinkSelector<Base>
 };
 
 template <typename Base>
-using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename PrependToTypeList<Base, TypeListNumber>::Type>::Type;
 
 template <typename Base>
 struct ArraySinkSourceSelector
diff --git a/dbms/src/Interpreters/SpecializedAggregator.h b/dbms/src/Interpreters/SpecializedAggregator.h
index c582e72b4fe..56a1d803a90 100644
--- a/dbms/src/Interpreters/SpecializedAggregator.h
+++ b/dbms/src/Interpreters/SpecializedAggregator.h
@@ -1,3 +1,4 @@
+#include <Common/TypeList.h>
 #include <Interpreters/Aggregator.h>
 
 #include <AggregateFunctions/AggregateFunctionArgMinMax.h>
@@ -40,43 +41,6 @@ namespace DB
   */
 
 
-/** List of types - for convenient listing of aggregate functions.
-  */
-template <typename... TTail>
-struct TypeList
-{
-    static constexpr size_t size = 0;
-
-    template <size_t I>
-    using At = std::nullptr_t;
-
-    template <typename Func, size_t index = 0>
-    static void forEach(Func && func)
-    {
-    }
-};
-
-
-template <typename THead, typename... TTail>
-struct TypeList<THead, TTail...>
-{
-    using Head = THead;
-    using Tail = TypeList<TTail...>;
-
-    static constexpr size_t size = 1 + sizeof...(TTail);
-
-    template <size_t I>
-    using At = typename std::template conditional<I == 0, Head, typename Tail::template At<I - 1>>::type;
-
-    template <typename Func, size_t index = 0>
-    static void ALWAYS_INLINE forEach(Func && func)
-    {
-        func.template operator()<Head, index>();
-        Tail::template forEach<Func, index + 1>(std::forward<Func>(func));
-    }
-};
-
-
 struct AggregateFunctionsUpdater
 {
     AggregateFunctionsUpdater(

From 7885c5c0324ee847ae31a2531a1a4b79c9e2403d Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 15:09:08 +0300
Subject: [PATCH 18/30] renamed TypeListNumber to TypeListNumbers
 [#CLICKHOUSE-2090]

---
 dbms/src/Core/TypeListNumber.h     | 2 +-
 dbms/src/Functions/GatherUtils.cpp | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/dbms/src/Core/TypeListNumber.h b/dbms/src/Core/TypeListNumber.h
index db7dcc2e5d0..d9e6f82a7a6 100644
--- a/dbms/src/Core/TypeListNumber.h
+++ b/dbms/src/Core/TypeListNumber.h
@@ -5,6 +5,6 @@
 namespace DB
 {
 
-using TypeListNumber = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
+using TypeListNumbers = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
 
 }
diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index 861f549b498..0b8419ab421 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -49,7 +49,7 @@ struct ArraySourceCreator<>
 
 std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
 {
-    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumber>::Type;
+    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumbers>::Type;
     if (auto column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
     {
         ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
@@ -93,7 +93,7 @@ struct ArraySinkCreator<>
 
 std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
 {
-    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumber>::Type;
+    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumbers>::Type;
     if (auto column_nullable = typeid_cast<ColumnNullable *>(&col.getData()))
     {
         ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
@@ -149,7 +149,7 @@ struct ArraySourceSelector<Base>
 };
 
 template <typename Base>
-using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename PrependToTypeList<Base, TypeListNumber>::Type>::Type;
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
 
 template <typename Base, typename ... Types>
 struct ArraySinkSelector;
@@ -185,7 +185,7 @@ struct ArraySinkSelector<Base>
 };
 
 template <typename Base>
-using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename PrependToTypeList<Base, TypeListNumber>::Type>::Type;
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
 
 template <typename Base>
 struct ArraySinkSourceSelector

From 1da43b683c4c3f4efaab1b090e2fdcdef487df4b Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 15:23:06 +0300
Subject: [PATCH 19/30] fixed comment [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index af2f04adff2..243f41a7251 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -65,15 +65,15 @@ namespace ErrorCodes
   *  arrayConcat(arr1, ...) - concatenate arrays.
   *
   *  arraySlice(arr, offset, length) - make slice of array. Offsets and length may be < 0 or Null
-  *   - if offset <= 0, indexation from right element
+  *   - if offset < 0, indexation from right element
   *   - if length < 0, length = len(array) - (positive_index(offset) - 1) + length
   *   indexation:
   *     [ 1,  2,  3,  4,  5,  6]
-  *     [-5, -4, -3, -2, -1,  0]
+  *     [-6, -5, -4, -3, -2, -1]
   *   examples:
-  *     arraySlice([1, 2, 3, 4, 5, 6], -4, 2) -> [2, 3]
+  *     arraySlice([1, 2, 3, 4, 5, 6], -4, 2) -> [3, 4]
   *     arraySlice([1, 2, 3, 4, 5, 6], 2, -1) -> [2, 3, 4, 5] (6 - (2 - 1) + (-1) = 4)
-  *     arraySlice([1, 2, 3, 4, 5, 6], -4, -1) = arraySlice([1, 2, 3, 4, 5, 6], -4, -1) -> [2, 3, 4, 5]
+  *     arraySlice([1, 2, 3, 4, 5, 6], -5, -1) = arraySlice([1, 2, 3, 4, 5, 6], 2, -1) -> [2, 3, 4, 5]
   *
   *  arrayPushBack(arr, x), arrayPushFront(arr, x)
   *  arrayPopBack(arr), arrayPopFront(arr)

From 6956e1277063f11edf079d4e7f9b83c21b6cb214 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 16:03:54 +0300
Subject: [PATCH 20/30] added comments to writeSlice functions
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 59d0b9427aa..2b1bccf06c0 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -860,8 +860,11 @@ struct NumericSink
 template <typename T>
 void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<T> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.elements.size() < sink.current_offset + slice.size)
         sink.elements.resize(sink.current_offset + slice.size);
+    /// Can't use memcpySmallAllowReadWriteOverflow15 when need to write slice into the middle of numeric column.
+    /// TODO: Implement more efficient memcpy without overflow.
     memcpy(&sink.elements[sink.current_offset], slice.data, slice.size * sizeof(T));
     sink.current_offset += slice.size;
 }
@@ -869,6 +872,7 @@ void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<T> & sink)
 template <typename T, typename U>
 void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.elements.size() < sink.current_offset + slice.size)
         sink.elements.resize(sink.current_offset + slice.size);
     for (size_t i = 0; i < slice.size; ++i)
@@ -880,8 +884,7 @@ void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 
 inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, StringSink & sink)
 {
-    if (sink.elements.size() < sink.current_offset + slice.size)
-        sink.elements.resize(sink.current_offset + slice.size);
+    sink.elements.resize(sink.current_offset + slice.size);
     memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size);
     sink.current_offset += slice.size;
 }
@@ -911,6 +914,7 @@ inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArr
 template <typename T>
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, NumericArraySink<T> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.elements.size() < sink.current_offset + slice.size)
         sink.elements.resize(sink.current_offset + slice.size);
     for (size_t i = 0; i < slice.size; ++i)
@@ -936,8 +940,11 @@ inline ALWAYS_INLINE void writeSlice(const NumericArraySlice<T> & slice, Generic
 template <typename ArraySlice, typename ArraySink>
 inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slice, NullableArraySink<ArraySink> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.null_map.size() < sink.current_offset + slice.size)
         sink.null_map.resize(sink.current_offset + slice.size);
+    /// Can't use memcpySmallAllowReadWriteOverflow15 when need to write slice into the middle of numeric column.
+    /// TODO: Implement more efficient memcpy without overflow.
     memcpy(&sink.null_map[sink.current_offset], slice.null_map, slice.size * sizeof(UInt8));
     writeSlice(static_cast<const ArraySlice &>(slice), static_cast<ArraySink &>(sink));
 }
@@ -945,8 +952,11 @@ inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slic
 template <typename ArraySlice, typename ArraySink>
 inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink<ArraySink> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.null_map.size() < sink.current_offset + slice.size)
         sink.null_map.resize(sink.current_offset + slice.size);
+    /// Can't use memcpySmallAllowReadWriteOverflow15 when need to write slice into the middle of numeric column.
+    /// TODO: Implement more efficient memcpy without overflow.
     memset(&sink.null_map[sink.current_offset], 0, slice.size * sizeof(UInt8));
     writeSlice(slice, static_cast<ArraySink &>(sink));
 }

From f1c01118b59fbb6ee90793a52c01144dc44dc47f Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 16:55:05 +0300
Subject: [PATCH 21/30] fixed writeSlice for const GenericArraySlice and
 NumericArraySink [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 2b1bccf06c0..6543e2bbeab 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -16,9 +16,9 @@
 #include <Common/memcpySmall.h>
 #include <ext/range.h>
 #include <Core/TypeListNumber.h>
+#include <Core/FieldVisitors.h
 
 #include <DataTypes/DataTypeTraits.h>
-#include <typeindex>
 
 /** These methods are intended for implementation of functions, that
   *  copy ranges from one or more columns to another column.
@@ -921,7 +921,7 @@ inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, NumericArr
     {
         Field field;
         slice.elements->get(slice.begin + i, field);
-        sink.elements.push_back(field.get<T>());
+        sink.elements.push_back(applyVisitor(FieldVisitorConvertToNumber<T>(), field));
     }
     sink.current_offset += slice.size;
 }

From 5b4759acd97a80a2d162ec5df7385ac783a205eb Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:32:12 +0300
Subject: [PATCH 22/30] changed sibstring behaviour for offset < -string_lenght
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 6543e2bbeab..4865583907c 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -296,7 +296,7 @@ struct StringSource
     {
         size_t elem_size = offsets[row_num] - prev_offset - 1;
         if (offset > elem_size)
-            return {&elements[prev_offset], elem_size};
+            return {&elements[prev_offset], length + elem_size > offset ? std::min(elem_size, length + elem_size - offset) : 0};
         return {&elements[prev_offset + elem_size - offset], std::min(length, offset)};
     }
 };
@@ -375,7 +375,7 @@ struct FixedStringSource
     Slice getSliceFromRight(size_t offset, size_t length) const
     {
         if (offset > string_size)
-            return {pos, string_size};
+            return {pos, length + string_size > offset ? std::min(string_size, length + string_size - offset) : 0};
         return {pos + string_size - offset, std::min(length, offset)};
     }
 };

From b392788e861b109618dca9d4456dd041fb7dd9f8 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:35:37 +0300
Subject: [PATCH 23/30] fix build [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 4865583907c..1c011a747a7 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -16,7 +16,7 @@
 #include <Common/memcpySmall.h>
 #include <ext/range.h>
 #include <Core/TypeListNumber.h>
-#include <Core/FieldVisitors.h
+#include <Core/FieldVisitors.h>
 
 #include <DataTypes/DataTypeTraits.h>
 

From 862460f293ac4b98cded31feea7f549ac1260d42 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:47:42 +0300
Subject: [PATCH 24/30] changed & to && in GatherUtils.cpp [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 62 +++++++++++++++++-------------
 1 file changed, 36 insertions(+), 26 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index 0b8419ab421..20b5c392f39 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -114,7 +114,7 @@ template <typename Base, typename Type, typename ... Types>
 struct ArraySourceSelector<Base, Type, Types ...>
 {
     template <typename ... Args>
-    static void select(IArraySource & source, Args & ... args)
+    static void select(IArraySource & source, Args && ... args)
     {
         if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
             Base::selectImpl(*array, args ...);
@@ -133,7 +133,7 @@ template <typename Base>
 struct ArraySourceSelector<Base>
 {
     template <typename ... Args>
-    static void select(IArraySource & source, Args & ... args)
+    static void select(IArraySource & source, Args && ... args)
     {
         if (auto array = typeid_cast<GenericArraySource *>(&source))
             Base::selectImpl(*array, args ...);
@@ -158,7 +158,7 @@ template <typename Base, typename Type, typename ... Types>
 struct ArraySinkSelector<Base, Type, Types ...>
 {
     template <typename ... Args>
-    static void select(IArraySink & sink, Args & ... args)
+    static void select(IArraySink & sink, Args && ... args)
     {
         if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
             Base::selectImpl(*nullable_numeric_sink, args ...);
@@ -173,7 +173,7 @@ template <typename Base>
 struct ArraySinkSelector<Base>
 {
     template <typename ... Args>
-    static void select(IArraySink & sink, Args & ... args)
+    static void select(IArraySink & sink, Args && ... args)
     {
         if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
             Base::selectImpl(*nullable_generic_sink, args ...);
@@ -191,19 +191,19 @@ template <typename Base>
 struct ArraySinkSourceSelector
 {
     template <typename ... Args>
-    static void select(IArraySource & source, IArraySink & sink, Args & ... args)
+    static void select(IArraySource & source, IArraySink & sink, Args && ... args)
     {
         GetArraySinkSelector<Base>::select(sink, source, args ...);
     }
 
     template <typename Sink, typename ... Args>
-    static void selectImpl(Sink & sink, IArraySource & source, Args & ... args)
+    static void selectImpl(Sink && sink, IArraySource & source, Args && ... args)
     {
         GetArraySourceSelector<Base>::select(source, sink, args ...);
     }
 
     template <typename Source, typename Sink, typename ... Args>
-    static void selectImpl(Source & source, Sink & sink, Args & ... args)
+    static void selectImpl(Source && source, Sink && sink, Args && ... args)
     {
         Base::selectSourceSink(source, sink, args ...);
     }
@@ -216,7 +216,7 @@ struct ArraySinkSourceSelector
 /// Only for NumericArraySource, because can't insert values in the middle of arbitary column.
 /// Used for array concat implementation.
 template <typename Source, typename Sink>
-static void append(Source & source, Sink & sink)
+static void append(Source && source, Sink && sink)
 {
     sink.row_num = 0;
     while (!source.isEnd())
@@ -231,14 +231,14 @@ static void append(Source & source, Sink & sink)
 struct ArrayAppend : public GetArraySourceSelector<ArrayAppend>
 {
     template <typename Source, typename Sink>
-    static void selectImpl(Source & source, Sink & sink)
+    static void selectImpl(Source && source, Sink && sink)
     {
-        append<Source, Sink>(source, sink);
+        append(source, sink);
     }
 };
 
 template <typename Sink>
-static void append(IArraySource & source, Sink & sink)
+static void append(IArraySource & source, Sink && sink)
 {
     ArrayAppend::select(source, sink);
 }
@@ -248,7 +248,7 @@ static void append(IArraySource & source, Sink & sink)
 template <typename SourceType, typename SinkType>
 struct ConcatGenericImpl
 {
-    static void concat(GenericArraySource * generic_source, SinkType & sink)
+    static void concat(GenericArraySource * generic_source, SinkType && sink)
     {
         auto source = static_cast<SourceType *>(generic_source);
         writeSlice(source->getWhole(), sink);
@@ -257,7 +257,7 @@ struct ConcatGenericImpl
 };
 
 template <typename Sink>
-static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink && sink)
 {
     std::vector<GenericArraySource *> generic_sources;
     std::vector<bool> is_nullable;
@@ -318,7 +318,7 @@ static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySour
 
 /// Concat for array sources. Sources must be either all numeric either all generic.
 template <typename Sink>
-void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink && sink)
 {
     size_t elements_to_reserve = 0;
     bool is_first = true;
@@ -355,7 +355,7 @@ void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources
 
     for (const auto & source : sources)
     {
-        append<Sink>(*source, sink);
+        append(*source, sink);
     }
 }
 
@@ -364,19 +364,29 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
     using Sources = std::vector<std::unique_ptr<IArraySource>>;
 
     template <typename Sink>
-    static void selectImpl(Sink & sink, Sources & sources)
+    static void selectImpl(Sink && sink, Sources && sources)
     {
         concat<Sink>(sources, sink);
     }
 
-    static void selectImpl(GenericArraySink & sink, Sources & sources)
+    static void selectImpl(GenericArraySink & sink, Sources && sources)
     {
-        concatGeneric<GenericArraySink>(sources, sink);
+        concatGeneric(sources, sink);
     }
 
-    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
+    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources && sources)
     {
-        concatGeneric<NullableArraySink<GenericArraySink>>(sources, sink);
+        concatGeneric(sources, sink);
+    }
+
+    static void selectImpl(GenericArraySink && sink, Sources && sources)
+    {
+        concatGeneric(sources, sink);
+    }
+
+    static void selectImpl(NullableArraySink<GenericArraySink> && sink, Sources && sources)
+    {
+        concatGeneric(sources, sink);
     }
 };
 
@@ -392,7 +402,7 @@ struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
         : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetUnboundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    static void selectSourceSink(Source && source, Sink && sink, size_t & offset)
     {
         sliceFromLeftConstantOffsetUnbounded(source, sink, offset);
     }
@@ -402,7 +412,7 @@ struct SliceFromLeftConstantOffsetBoundedSelectArraySource
         : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetBoundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    static void selectSourceSink(Source && source, Sink && sink, size_t & offset, ssize_t & length)
     {
         sliceFromLeftConstantOffsetBounded(source, sink, offset, length);
     }
@@ -412,7 +422,7 @@ struct SliceFromRightConstantOffsetUnboundedSelectArraySource
         : public ArraySinkSourceSelector<SliceFromRightConstantOffsetUnboundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    static void selectSourceSink(Source && source, Sink && sink, size_t & offset)
     {
         sliceFromRightConstantOffsetUnbounded(source, sink, offset);
     }
@@ -422,7 +432,7 @@ struct SliceFromRightConstantOffsetBoundedSelectArraySource
         : public ArraySinkSourceSelector<SliceFromRightConstantOffsetBoundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    static void selectSourceSink(Source && source, Sink && sink, size_t & offset, ssize_t & length)
     {
         sliceFromRightConstantOffsetBounded(source, sink, offset, length);
     }
@@ -432,7 +442,7 @@ struct SliceDynamicOffsetUnboundedSelectArraySource
         : public ArraySinkSourceSelector<SliceDynamicOffsetUnboundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
+    static void selectSourceSink(Source && source, Sink && sink, IColumn & offset_column)
     {
         sliceDynamicOffsetUnbounded(source, sink, offset_column);
     }
@@ -442,7 +452,7 @@ struct SliceDynamicOffsetBoundedSelectArraySource
         : public ArraySinkSourceSelector<SliceDynamicOffsetBoundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
+    static void selectSourceSink(Source && source, Sink && sink, IColumn & offset_column, IColumn & length_column)
     {
         sliceDynamicOffsetBounded(source, sink, offset_column, length_column);
     }

From 3370ba270f2ee27c2152acfbbca10d4d32d5366c Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:55:43 +0300
Subject: [PATCH 25/30] fix build [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index 20b5c392f39..e7783ad91be 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -364,17 +364,17 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
     using Sources = std::vector<std::unique_ptr<IArraySource>>;
 
     template <typename Sink>
-    static void selectImpl(Sink && sink, Sources && sources)
+    static void selectImpl(Sink && sink, Sources & sources)
     {
         concat<Sink>(sources, sink);
     }
 
-    static void selectImpl(GenericArraySink & sink, Sources && sources)
+    static void selectImpl(GenericArraySink & sink, Sources & sources)
     {
         concatGeneric(sources, sink);
     }
 
-    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources && sources)
+    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
     {
         concatGeneric(sources, sink);
     }
@@ -384,7 +384,7 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
         concatGeneric(sources, sink);
     }
 
-    static void selectImpl(NullableArraySink<GenericArraySink> && sink, Sources && sources)
+    static void selectImpl(NullableArraySink<GenericArraySink> && sink, Sources & sources)
     {
         concatGeneric(sources, sink);
     }

From a46780e4a5f5eedf86e653f9049320f0d131a32c Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 19:45:05 +0300
Subject: [PATCH 26/30] renamed concatGeneric to concatGenericArray
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index e7783ad91be..636fb8ad049 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -246,9 +246,9 @@ static void append(IArraySource & source, Sink && sink)
 /// Concat specialization for GenericArraySource. Because can't use append with arbitrary column type.
 
 template <typename SourceType, typename SinkType>
-struct ConcatGenericImpl
+struct ConcatGenericArrayWriteWholeImpl
 {
-    static void concat(GenericArraySource * generic_source, SinkType && sink)
+    static void writeWhole(GenericArraySource * generic_source, SinkType && sink)
     {
         auto source = static_cast<SourceType *>(generic_source);
         writeSlice(source->getWhole(), sink);
@@ -257,7 +257,7 @@ struct ConcatGenericImpl
 };
 
 template <typename Sink>
-static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink && sink)
+static void NO_INLINE concatGenericArray(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink && sink)
 {
     std::vector<GenericArraySource *> generic_sources;
     std::vector<bool> is_nullable;
@@ -300,16 +300,16 @@ static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySour
             if (is_const[i])
             {
                 if (is_nullable[i])
-                    ConcatGenericImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::concat(source, sink);
+                    ConcatGenericArrayWriteWholeImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::writeWhole(source, sink);
                 else
-                    ConcatGenericImpl<ConstSource<GenericArraySource>, Sink>::concat(source, sink);
+                    ConcatGenericArrayWriteWholeImpl<ConstSource<GenericArraySource>, Sink>::writeWhole(source, sink);
             }
             else
             {
                 if (is_nullable[i])
-                    ConcatGenericImpl<NullableArraySource<GenericArraySource>, Sink>::concat(source, sink);
+                    ConcatGenericArrayWriteWholeImpl<NullableArraySource<GenericArraySource>, Sink>::writeWhole(source, sink);
                 else
-                    ConcatGenericImpl<GenericArraySource, Sink>::concat(source, sink);
+                    ConcatGenericArrayWriteWholeImpl<GenericArraySource, Sink>::writeWhole(source, sink);
             }
         }
         sink.next();
@@ -371,22 +371,22 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
 
     static void selectImpl(GenericArraySink & sink, Sources & sources)
     {
-        concatGeneric(sources, sink);
+        concatGenericArray(sources, sink);
     }
 
     static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
     {
-        concatGeneric(sources, sink);
+        concatGenericArray(sources, sink);
     }
 
     static void selectImpl(GenericArraySink && sink, Sources && sources)
     {
-        concatGeneric(sources, sink);
+        concatGenericArray(sources, sink);
     }
 
     static void selectImpl(NullableArraySink<GenericArraySink> && sink, Sources & sources)
     {
-        concatGeneric(sources, sink);
+        concatGenericArray(sources, sink);
     }
 };
 

From b4f7e0e15c8100e3ccd8de1eaeb84c1e495f620c Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 19:57:01 +0300
Subject: [PATCH 27/30] restored identation in FunctionsArray.cpp
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.cpp | 1717 ++++++++++++-------------
 1 file changed, 823 insertions(+), 894 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 4d65860f11d..d8682a9d5b0 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -7,7 +7,6 @@
 #include <Functions/FunctionsConversion.h>
 #include <Functions/Conditional/getArrayType.h>
 #include <Functions/Conditional/CondException.h>
-#include <Functions/GatherUtils.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/HashTable/ClearableHashMap.h>
 #include <Parsers/ExpressionListParsers.h>
@@ -32,13 +31,13 @@ String FunctionArray::getName() const
     return name;
 }
 
-FunctionPtr FunctionArray::create(const Context &context)
+FunctionPtr FunctionArray::create(const Context & context)
 {
     return std::make_shared<FunctionArray>(context);
 }
 
-FunctionArray::FunctionArray(const Context &context)
-        : context(context)
+FunctionArray::FunctionArray(const Context & context)
+    : context(context)
 {
 }
 
@@ -47,7 +46,7 @@ namespace
 {
 
 /// Is there at least one numeric argument among the specified ones?
-bool foundNumericType(const DataTypes &args)
+bool foundNumericType(const DataTypes & args)
 {
     for (size_t i = 0; i < args.size(); ++i)
     {
@@ -62,7 +61,7 @@ bool foundNumericType(const DataTypes &args)
 
 
 /// Check if the specified arguments have the same type up to nullability or nullity.
-bool hasArrayIdenticalTypes(const DataTypes &args)
+bool hasArrayIdenticalTypes(const DataTypes & args)
 {
     std::string first_type_name;
 
@@ -70,8 +69,8 @@ bool hasArrayIdenticalTypes(const DataTypes &args)
     {
         if (!args[i]->isNull())
         {
-            const IDataType *observed_type = DataTypeTraits::removeNullable(args[i]).get();
-            const std::string &name = observed_type->getName();
+            const IDataType * observed_type = DataTypeTraits::removeNullable(args[i]).get();
+            const std::string & name = observed_type->getName();
 
             if (first_type_name.empty())
                 first_type_name = name;
@@ -87,16 +86,16 @@ bool hasArrayIdenticalTypes(const DataTypes &args)
 /// function hasArrayIdenticalTypes(), deduce the element type of an array that
 /// would be constructed from a set of values V, such that, for each i, the
 /// type of V[i] is args[i].
-DataTypePtr getArrayElementType(const DataTypes &args)
+DataTypePtr getArrayElementType(const DataTypes & args)
 {
     bool found_null = false;
     bool found_nullable = false;
 
-    const DataTypePtr *ret = nullptr;
+    const DataTypePtr * ret = nullptr;
 
     for (size_t i = 0; i < args.size(); ++i)
     {
-        const auto &type = args[i];
+        const auto & type = args[i];
 
         if (type->isNull())
             found_null = true;
@@ -128,8 +127,8 @@ DataTypePtr getArrayElementType(const DataTypes &args)
     }
 }
 
-template<typename T0, typename T1>
-bool tryAddField(DataTypePtr type_res, const Field &f, Array &arr)
+template <typename T0, typename T1>
+bool tryAddField(DataTypePtr type_res, const Field & f, Array & arr)
 {
     if (typeid_cast<const T0 *>(type_res.get()))
     {
@@ -144,28 +143,28 @@ bool tryAddField(DataTypePtr type_res, const Field &f, Array &arr)
 
 }
 
-bool FunctionArray::addField(DataTypePtr type_res, const Field &f, Array &arr) const
+bool FunctionArray::addField(DataTypePtr type_res, const Field & f, Array & arr) const
 {
     /// Otherwise, it is necessary
-    if (tryAddField<DataTypeUInt8, DataTypeUInt64>(type_res, f, arr)
-        || tryAddField<DataTypeUInt16, DataTypeUInt64>(type_res, f, arr)
-        || tryAddField<DataTypeUInt32, DataTypeUInt64>(type_res, f, arr)
-        || tryAddField<DataTypeUInt64, DataTypeUInt64>(type_res, f, arr)
-        || tryAddField<DataTypeInt8, DataTypeInt64>(type_res, f, arr)
-        || tryAddField<DataTypeInt16, DataTypeInt64>(type_res, f, arr)
-        || tryAddField<DataTypeInt32, DataTypeInt64>(type_res, f, arr)
-        || tryAddField<DataTypeInt64, DataTypeInt64>(type_res, f, arr)
-        || tryAddField<DataTypeFloat32, DataTypeFloat64>(type_res, f, arr)
-        || tryAddField<DataTypeFloat64, DataTypeFloat64>(type_res, f, arr))
+    if (    tryAddField<DataTypeUInt8, DataTypeUInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeUInt16, DataTypeUInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeUInt32, DataTypeUInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeUInt64, DataTypeUInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeInt8, DataTypeInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeInt16, DataTypeInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeInt32, DataTypeInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeInt64, DataTypeInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeFloat32, DataTypeFloat64>(type_res, f, arr)
+        ||    tryAddField<DataTypeFloat64, DataTypeFloat64>(type_res, f, arr) )
         return true;
     else
     {
         throw Exception{"Illegal result type " + type_res->getName() + " of function " + getName(),
-                        ErrorCodes::LOGICAL_ERROR};
+            ErrorCodes::LOGICAL_ERROR};
     }
 }
 
-const DataTypePtr &FunctionArray::getScalarType(const DataTypePtr &type)
+const DataTypePtr & FunctionArray::getScalarType(const DataTypePtr & type)
 {
     const auto array = checkAndGetDataType<DataTypeArray>(type.get());
 
@@ -175,7 +174,7 @@ const DataTypePtr &FunctionArray::getScalarType(const DataTypePtr &type)
     return getScalarType(array->getNestedType());
 }
 
-DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const DataTypes &arguments) const
+DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const DataTypes & arguments) const
 {
     DataTypeTraits::EnrichedDataTypePtr result_type;
 
@@ -183,26 +182,26 @@ DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const Data
     {
         result_type = Conditional::getArrayType(arguments);
     }
-    catch (const Conditional::CondException &ex)
+    catch (const Conditional::CondException & ex)
     {
         /// Translate a context-free error into a contextual error.
         if (ex.getCode() == Conditional::CondErrorCodes::TYPE_DEDUCER_ILLEGAL_COLUMN_TYPE)
             throw Exception{"Illegal type of column " + ex.getMsg1() +
-                            " in array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+                " in array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         else if (ex.getCode() == Conditional::CondErrorCodes::TYPE_DEDUCER_UPSCALING_ERROR)
             throw Exception("Arguments of function " + getName() + " are not upscalable "
-                                    "to a common type without loss of precision.",
-                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                "to a common type without loss of precision.",
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
         else
             throw Exception{"An unexpected error has occurred in function " + getName(),
-                            ErrorCodes::LOGICAL_ERROR};
+                ErrorCodes::LOGICAL_ERROR};
     }
 
     return result_type;
 }
 
 
-DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes & arguments) const
 {
     if (arguments.empty())
         throw Exception{"Function array requires at least one argument.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
@@ -219,14 +218,13 @@ DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes &arguments) const
     {
         /// Otherwise all the arguments must have the same type up to nullability or nullity.
         if (!hasArrayIdenticalTypes(arguments))
-            throw Exception{"Arguments for function array must have same type or behave as number.",
-                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Arguments for function array must have same type or behave as number.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeArray>(getArrayElementType(arguments));
     }
 }
 
-void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     size_t num_elements = arguments.size();
     bool is_const = true;
@@ -240,17 +238,17 @@ void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, si
         }
     }
 
-    const DataTypePtr &return_type = block.getByPosition(result).type;
-    const DataTypePtr &elem_type = static_cast<const DataTypeArray &>(*return_type).getNestedType();
+    const DataTypePtr & return_type = block.getByPosition(result).type;
+    const DataTypePtr & elem_type = static_cast<const DataTypeArray &>(*return_type).getNestedType();
 
     if (is_const)
     {
-        const DataTypePtr &observed_type = DataTypeTraits::removeNullable(elem_type);
+        const DataTypePtr & observed_type = DataTypeTraits::removeNullable(elem_type);
 
         Array arr;
         for (const auto arg_num : arguments)
         {
-            const auto &elem = block.getByPosition(arg_num);
+            const auto & elem = block.getByPosition(arg_num);
 
             if (DataTypeTraits::removeNullable(elem.type)->equals(*observed_type))
             {
@@ -280,11 +278,11 @@ void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, si
           */
 
         Columns columns_holder(num_elements);
-        const IColumn *columns[num_elements];
+        const IColumn * columns[num_elements];
 
         for (size_t i = 0; i < num_elements; ++i)
         {
-            const auto &arg = block.getByPosition(arguments[i]);
+            const auto & arg = block.getByPosition(arguments[i]);
 
             String elem_type_name = elem_type->getName();
             ColumnPtr preprocessed_column = arg.column;
@@ -292,30 +290,29 @@ void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, si
             if (arg.type->getName() != elem_type_name)
             {
                 Block temporary_block
-                        {
-                                {
-                                        arg.column,
-                                        arg.type,
-                                        arg.name
-                                },
-                                {
-                                        DataTypeString().createConstColumn(block_size, elem_type_name),
-                                        std::make_shared<DataTypeString>(),
-                                        ""
-                                },
-                                {
-                                        nullptr,
-                                        elem_type,
-                                        ""
-                                }
-                        };
+                {
+                    {
+                        arg.column,
+                        arg.type,
+                        arg.name
+                    },
+                    {
+                        DataTypeString().createConstColumn(block_size, elem_type_name),
+                        std::make_shared<DataTypeString>(),
+                        ""
+                    },
+                    {
+                        nullptr,
+                        elem_type,
+                        ""
+                    }
+                };
 
                 FunctionCast func_cast(context);
 
                 {
                     DataTypePtr unused_return_type;
-                    ColumnsWithTypeAndName arguments{temporary_block.getByPosition(0),
-                                                     temporary_block.getByPosition(1)};
+                    ColumnsWithTypeAndName arguments{ temporary_block.getByPosition(0), temporary_block.getByPosition(1) };
                     std::vector<ExpressionAction> unused_prerequisites;
 
                     /// Prepares function to execution. TODO It is not obvious.
@@ -337,8 +334,8 @@ void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, si
           */
 
         auto out = std::make_shared<ColumnArray>(elem_type->createColumn());
-        IColumn &out_data = out->getData();
-        IColumn::Offsets_t &out_offsets = out->getOffsets();
+        IColumn & out_data = out->getData();
+        IColumn::Offsets_t & out_offsets = out->getOffsets();
 
         out_data.reserve(block_size * num_elements);
         out_offsets.resize(block_size);
@@ -365,18 +362,15 @@ namespace ArrayImpl
 class NullMapBuilder
 {
 public:
-    operator bool() const
-    { return src_nullable_col || src_array; }
+    operator bool() const { return src_nullable_col || src_array; }
+    bool operator!() const { return !src_nullable_col && !src_array; }
 
-    bool operator!() const
-    { return !src_nullable_col && !src_array; }
-
-    void initSource(const ColumnNullable &src_nullable_col_)
+    void initSource(const ColumnNullable & src_nullable_col_)
     {
         src_nullable_col = &src_nullable_col_;
     }
 
-    void initSource(const Array &src_array_)
+    void initSource(const Array & src_array_)
     {
         src_array = &src_array_;
     }
@@ -390,8 +384,7 @@ public:
     void update(size_t from)
     {
         if (index >= size)
-            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.",
-                            ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.", ErrorCodes::LOGICAL_ERROR};
 
         bool is_null;
         if (src_nullable_col)
@@ -399,7 +392,7 @@ public:
         else
             is_null = from < src_array->size() ? (*src_array)[from].isNull() : true;
 
-        auto &null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
+        auto & null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
         null_map_data[index] = is_null ? 1 : 0;
 
         ++index;
@@ -408,20 +401,18 @@ public:
     void update()
     {
         if (index >= size)
-            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.",
-                            ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.", ErrorCodes::LOGICAL_ERROR};
 
-        auto &null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
+        auto & null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
         null_map_data[index] = 0;
         ++index;
     }
 
-    ColumnPtr getNullMap() const
-    { return sink_null_map; }
+    ColumnPtr getNullMap() const { return sink_null_map; }
 
 private:
-    const ColumnNullable *src_nullable_col = nullptr;
-    const Array *src_array = nullptr;
+    const ColumnNullable * src_nullable_col = nullptr;
+    const Array * src_array = nullptr;
     ColumnPtr sink_null_map;
     size_t size = 0;
     size_t index = 0;
@@ -432,18 +423,18 @@ private:
 namespace
 {
 
-template<typename T>
+template <typename T>
 struct ArrayElementNumImpl
 {
     /** Implementation for constant index.
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template<bool negative>
+    template <bool negative>
     static void vectorConst(
-            const PaddedPODArray<T> &data, const ColumnArray::Offsets_t &offsets,
-            const ColumnArray::Offset_t index,
-            PaddedPODArray<T> &result, ArrayImpl::NullMapBuilder &builder)
+        const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
+        const ColumnArray::Offset_t index,
+        PaddedPODArray<T> & result, ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result.resize(size);
@@ -474,11 +465,11 @@ struct ArrayElementNumImpl
 
     /** Implementation for non-constant index.
       */
-    template<typename TIndex>
+    template <typename TIndex>
     static void vector(
-            const PaddedPODArray<T> &data, const ColumnArray::Offsets_t &offsets,
-            const PaddedPODArray<TIndex> &indices,
-            PaddedPODArray<T> &result, ArrayImpl::NullMapBuilder &builder)
+        const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
+        const PaddedPODArray<TIndex> & indices,
+        PaddedPODArray<T> & result, ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result.resize(size);
@@ -524,13 +515,12 @@ struct ArrayElementStringImpl
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template<bool negative>
+    template <bool negative>
     static void vectorConst(
-            const ColumnString::Chars_t &data, const ColumnArray::Offsets_t &offsets,
-            const ColumnString::Offsets_t &string_offsets,
-            const ColumnArray::Offset_t index,
-            ColumnString::Chars_t &result_data, ColumnArray::Offsets_t &result_offsets,
-            ArrayImpl::NullMapBuilder &builder)
+        const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
+        const ColumnArray::Offset_t index,
+        ColumnString::Chars_t & result_data, ColumnArray::Offsets_t & result_offsets,
+        ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result_offsets.resize(size);
@@ -546,19 +536,18 @@ struct ArrayElementStringImpl
             {
                 size_t adjusted_index = !negative ? index : (array_size - index - 1);
 
-                size_t j = (current_offset == 0 && adjusted_index == 0) ? 0 : current_offset + adjusted_index;
+                size_t j =  (current_offset == 0 && adjusted_index == 0) ? 0 : current_offset + adjusted_index;
                 if (builder)
                     builder.update(j);
 
                 ColumnArray::Offset_t string_pos = current_offset == 0 && adjusted_index == 0
-                                                   ? 0
-                                                   : string_offsets[current_offset + adjusted_index - 1];
+                    ? 0
+                    : string_offsets[current_offset + adjusted_index - 1];
 
                 ColumnArray::Offset_t string_size = string_offsets[current_offset + adjusted_index] - string_pos;
 
                 result_data.resize(current_result_offset + string_size);
-                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos],
-                                                    string_size);
+                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos], string_size);
                 current_result_offset += string_size;
                 result_offsets[i] = current_result_offset;
             }
@@ -580,13 +569,12 @@ struct ArrayElementStringImpl
 
     /** Implementation for non-constant index.
       */
-    template<typename TIndex>
+    template <typename TIndex>
     static void vector(
-            const ColumnString::Chars_t &data, const ColumnArray::Offsets_t &offsets,
-            const ColumnString::Offsets_t &string_offsets,
-            const PaddedPODArray<TIndex> &indices,
-            ColumnString::Chars_t &result_data, ColumnArray::Offsets_t &result_offsets,
-            ArrayImpl::NullMapBuilder &builder)
+        const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
+        const PaddedPODArray<TIndex> & indices,
+        ColumnString::Chars_t & result_data, ColumnArray::Offsets_t & result_offsets,
+        ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result_offsets.resize(size);
@@ -614,14 +602,13 @@ struct ArrayElementStringImpl
                     builder.update(j);
 
                 ColumnArray::Offset_t string_pos = current_offset == 0 && adjusted_index == 0
-                                                   ? 0
-                                                   : string_offsets[current_offset + adjusted_index - 1];
+                    ? 0
+                    : string_offsets[current_offset + adjusted_index - 1];
 
                 ColumnArray::Offset_t string_size = string_offsets[current_offset + adjusted_index] - string_pos;
 
                 result_data.resize(current_result_offset + string_size);
-                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos],
-                                                    string_size);
+                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos], string_size);
                 current_result_offset += string_size;
                 result_offsets[i] = current_result_offset;
             }
@@ -649,11 +636,11 @@ struct ArrayElementGenericImpl
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template<bool negative>
+    template <bool negative>
     static void vectorConst(
-            const IColumn &data, const ColumnArray::Offsets_t &offsets,
-            const ColumnArray::Offset_t index,
-            IColumn &result, ArrayImpl::NullMapBuilder &builder)
+        const IColumn & data, const ColumnArray::Offsets_t & offsets,
+        const ColumnArray::Offset_t index,
+        IColumn & result, ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result.reserve(size);
@@ -683,11 +670,11 @@ struct ArrayElementGenericImpl
 
     /** Implementation for non-constant index.
       */
-    template<typename TIndex>
+    template <typename TIndex>
     static void vector(
-            const IColumn &data, const ColumnArray::Offsets_t &offsets,
-            const PaddedPODArray<TIndex> &indices,
-            IColumn &result, ArrayImpl::NullMapBuilder &builder)
+        const IColumn & data, const ColumnArray::Offsets_t & offsets,
+        const PaddedPODArray<TIndex> & indices,
+        IColumn & result, ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result.reserve(size);
@@ -727,23 +714,22 @@ struct ArrayElementGenericImpl
 }
 
 
-FunctionPtr FunctionArrayElement::create(const Context &context)
+FunctionPtr FunctionArrayElement::create(const Context & context)
 {
     return std::make_shared<FunctionArrayElement>();
 }
 
 
-template<typename DataType>
-bool FunctionArrayElement::executeNumberConst(Block &block, const ColumnNumbers &arguments, size_t result,
-                                              const Field &index,
-                                              ArrayImpl::NullMapBuilder &builder)
+template <typename DataType>
+bool FunctionArrayElement::executeNumberConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnVector<DataType> *col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
+    const ColumnVector<DataType> * col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -753,29 +739,26 @@ bool FunctionArrayElement::executeNumberConst(Block &block, const ColumnNumbers
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementNumImpl<DataType>::template vectorConst<false>(
-                col_nested->getData(), col_array->getOffsets(), safeGet<UInt64>(index) - 1, col_res->getData(),
-                builder);
+            col_nested->getData(), col_array->getOffsets(), safeGet<UInt64>(index) - 1, col_res->getData(), builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementNumImpl<DataType>::template vectorConst<true>(
-                col_nested->getData(), col_array->getOffsets(), -safeGet<Int64>(index) - 1, col_res->getData(),
-                builder);
+            col_nested->getData(), col_array->getOffsets(), -safeGet<Int64>(index) - 1, col_res->getData(), builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template<typename IndexType, typename DataType>
-bool FunctionArrayElement::executeNumber(Block &block, const ColumnNumbers &arguments, size_t result,
-                                         const PaddedPODArray<IndexType> &indices,
-                                         ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType, typename DataType>
+bool FunctionArrayElement::executeNumber(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnVector<DataType> *col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
+    const ColumnVector<DataType> * col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -784,21 +767,20 @@ bool FunctionArrayElement::executeNumber(Block &block, const ColumnNumbers &argu
     block.getByPosition(result).column = col_res;
 
     ArrayElementNumImpl<DataType>::template vector<IndexType>(
-            col_nested->getData(), col_array->getOffsets(), indices, col_res->getData(), builder);
+        col_nested->getData(), col_array->getOffsets(), indices, col_res->getData(), builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeStringConst(Block &block, const ColumnNumbers &arguments, size_t result,
-                                              const Field &index,
-                                              ArrayImpl::NullMapBuilder &builder)
+bool FunctionArrayElement::executeStringConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnString *col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
+    const ColumnString * col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -808,39 +790,38 @@ bool FunctionArrayElement::executeStringConst(Block &block, const ColumnNumbers
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementStringImpl::vectorConst<false>(
-                col_nested->getChars(),
-                col_array->getOffsets(),
-                col_nested->getOffsets(),
-                safeGet<UInt64>(index) - 1,
-                col_res->getChars(),
-                col_res->getOffsets(),
-                builder);
+            col_nested->getChars(),
+            col_array->getOffsets(),
+            col_nested->getOffsets(),
+            safeGet<UInt64>(index) - 1,
+            col_res->getChars(),
+            col_res->getOffsets(),
+            builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementStringImpl::vectorConst<true>(
-                col_nested->getChars(),
-                col_array->getOffsets(),
-                col_nested->getOffsets(),
-                -safeGet<Int64>(index) - 1,
-                col_res->getChars(),
-                col_res->getOffsets(),
-                builder);
+            col_nested->getChars(),
+            col_array->getOffsets(),
+            col_nested->getOffsets(),
+            -safeGet<Int64>(index) - 1,
+            col_res->getChars(),
+            col_res->getOffsets(),
+            builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template<typename IndexType>
-bool FunctionArrayElement::executeString(Block &block, const ColumnNumbers &arguments, size_t result,
-                                         const PaddedPODArray<IndexType> &indices,
-                                         ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType>
+bool FunctionArrayElement::executeString(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnString *col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
+    const ColumnString * col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -849,67 +830,64 @@ bool FunctionArrayElement::executeString(Block &block, const ColumnNumbers &argu
     block.getByPosition(result).column = col_res;
 
     ArrayElementStringImpl::vector<IndexType>(
-            col_nested->getChars(),
-            col_array->getOffsets(),
-            col_nested->getOffsets(),
-            indices,
-            col_res->getChars(),
-            col_res->getOffsets(),
-            builder);
+        col_nested->getChars(),
+        col_array->getOffsets(),
+        col_nested->getOffsets(),
+        indices,
+        col_res->getChars(),
+        col_res->getOffsets(),
+        builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeGenericConst(Block &block, const ColumnNumbers &arguments, size_t result,
-                                               const Field &index,
-                                               ArrayImpl::NullMapBuilder &builder)
+bool FunctionArrayElement::executeGenericConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const auto &col_nested = col_array->getData();
+    const auto & col_nested = col_array->getData();
     auto col_res = col_nested.cloneEmpty();
     block.getByPosition(result).column = col_res;
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementGenericImpl::vectorConst<false>(
-                col_nested, col_array->getOffsets(), safeGet<UInt64>(index) - 1, *col_res, builder);
+            col_nested, col_array->getOffsets(), safeGet<UInt64>(index) - 1, *col_res, builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementGenericImpl::vectorConst<true>(
-                col_nested, col_array->getOffsets(), -safeGet<Int64>(index) - 1, *col_res, builder);
+            col_nested, col_array->getOffsets(), -safeGet<Int64>(index) - 1, *col_res, builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template<typename IndexType>
-bool FunctionArrayElement::executeGeneric(Block &block, const ColumnNumbers &arguments, size_t result,
-                                          const PaddedPODArray<IndexType> &indices,
-                                          ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType>
+bool FunctionArrayElement::executeGeneric(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const auto &col_nested = col_array->getData();
+    const auto & col_nested = col_array->getData();
     auto col_res = col_nested.cloneEmpty();
     block.getByPosition(result).column = col_res;
 
     ArrayElementGenericImpl::vector<IndexType>(
-            col_nested, col_array->getOffsets(), indices, *col_res, builder);
+        col_nested, col_array->getOffsets(), indices, *col_res, builder);
 
     return true;
 }
 
-bool
-FunctionArrayElement::executeConstConst(Block &block, const ColumnNumbers &arguments, size_t result, const Field &index,
-                                        ArrayImpl::NullMapBuilder &builder)
+bool FunctionArrayElement::executeConstConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnConst *col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst * col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
@@ -933,8 +911,8 @@ FunctionArrayElement::executeConstConst(Block &block, const ColumnNumbers &argum
         value = block.getByPosition(result).type->getDefault();
 
     block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
-            block.rows(),
-            value);
+        block.rows(),
+        value);
 
     if (builder)
         builder.update(real_index);
@@ -942,12 +920,11 @@ FunctionArrayElement::executeConstConst(Block &block, const ColumnNumbers &argum
     return true;
 }
 
-template<typename IndexType>
-bool FunctionArrayElement::executeConst(Block &block, const ColumnNumbers &arguments, size_t result,
-                                        const PaddedPODArray<IndexType> &indices,
-                                        ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType>
+bool FunctionArrayElement::executeConst(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnConst *col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst * col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
@@ -985,52 +962,52 @@ bool FunctionArrayElement::executeConst(Block &block, const ColumnNumbers &argum
     return true;
 }
 
-template<typename IndexType>
-bool FunctionArrayElement::executeArgument(Block &block, const ColumnNumbers &arguments, size_t result,
-                                           ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType>
+bool FunctionArrayElement::executeArgument(Block & block, const ColumnNumbers & arguments, size_t result,
+    ArrayImpl::NullMapBuilder & builder)
 {
     auto index = checkAndGetColumn<ColumnVector<IndexType>>(block.getByPosition(arguments[1]).column.get());
 
     if (!index)
         return false;
 
-    const auto &index_data = index->getData();
+    const auto & index_data = index->getData();
 
     if (builder)
         builder.initSink(index_data.size());
 
-    if (!(executeNumber<IndexType, UInt8>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, UInt16>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, UInt32>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, UInt64>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Int8>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Int16>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Int32>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Int64>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Float32>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Float64>(block, arguments, result, index_data, builder)
-          || executeConst<IndexType>(block, arguments, result, index_data, builder)
-          || executeString<IndexType>(block, arguments, result, index_data, builder)
-          || executeGeneric<IndexType>(block, arguments, result, index_data, builder)))
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                        + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+    if (!(    executeNumber<IndexType, UInt8>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, UInt16>    (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, UInt32>    (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, UInt64>    (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Int8>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Int16>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Int32>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Int64>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Float32>    (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Float64>    (block, arguments, result, index_data, builder)
+        ||    executeConst <IndexType>            (block, arguments, result, index_data, builder)
+        ||    executeString<IndexType>            (block, arguments, result, index_data, builder)
+        ||    executeGeneric<IndexType>            (block, arguments, result, index_data, builder)))
+    throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
+                + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
 
     return true;
 }
 
-bool FunctionArrayElement::executeTuple(Block &block, const ColumnNumbers &arguments, size_t result)
+bool FunctionArrayElement::executeTuple(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    ColumnArray *col_array = typeid_cast<ColumnArray *>(block.getByPosition(arguments[0]).column.get());
+    ColumnArray * col_array = typeid_cast<ColumnArray *>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    ColumnTuple *col_nested = typeid_cast<ColumnTuple *>(&col_array->getData());
+    ColumnTuple * col_nested = typeid_cast<ColumnTuple *>(&col_array->getData());
 
     if (!col_nested)
         return false;
 
-    Block &tuple_block = col_nested->getData();
+    Block & tuple_block = col_nested->getData();
     size_t tuple_size = tuple_block.columns();
 
     /** We will calculate the function for the tuple of the internals of the array.
@@ -1053,9 +1030,9 @@ bool FunctionArrayElement::executeTuple(Block &block, const ColumnNumbers &argum
     {
         ColumnWithTypeAndName array_of_tuple_section;
         array_of_tuple_section.column = std::make_shared<ColumnArray>(
-                tuple_block.getByPosition(i).column, col_array->getOffsetsColumn());
+            tuple_block.getByPosition(i).column, col_array->getOffsetsColumn());
         array_of_tuple_section.type = std::make_shared<DataTypeArray>(
-                tuple_block.getByPosition(i).type);
+            tuple_block.getByPosition(i).type);
         block_of_temporary_results.insert(array_of_tuple_section);
 
         ColumnWithTypeAndName array_elements_of_tuple_section;
@@ -1077,28 +1054,26 @@ String FunctionArrayElement::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
-        throw Exception("First argument for function " + getName() + " must be array.",
-                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("First argument for function " + getName() + " must be array.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     if (!arguments[1]->isNumeric()
         || (!startsWith(arguments[1]->getName(), "UInt") && !startsWith(arguments[1]->getName(), "Int")))
-        throw Exception("Second argument for function " + getName() + " must have UInt or Int type.",
-                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("Second argument for function " + getName() + " must have UInt or Int type.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return array_type->getNestedType();
 }
 
-void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     /// Check nullability.
     bool is_nullable;
 
-    const ColumnArray *col_array = nullptr;
-    const ColumnConst *col_const_array = nullptr;
+    const ColumnArray * col_array = nullptr;
+    const ColumnConst * col_const_array = nullptr;
 
     col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (col_array)
@@ -1109,12 +1084,11 @@ void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &argume
         if (col_const_array)
         {
             Array arr = col_const_array->getValue<Array>();
-            is_nullable = std::any_of(arr.begin(), arr.end(), [](const Field &f)
-            { return f.isNull(); });
+            is_nullable = std::any_of(arr.begin(), arr.end(), [](const Field & f){ return f.isNull(); });
         }
         else
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                            + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+            + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
     }
 
     if (!is_nullable)
@@ -1128,32 +1102,30 @@ void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &argume
         ArrayImpl::NullMapBuilder builder;
         Block source_block;
 
-        const auto &input_type = static_cast<const DataTypeNullable &>(*block.getByPosition(
-                arguments[0]).type).getNestedType();
-        const auto &tmp_ret_type = static_cast<const DataTypeNullable &>(*block.getByPosition(
-                result).type).getNestedType();
+        const auto & input_type = static_cast<const DataTypeNullable &>(*block.getByPosition(arguments[0]).type).getNestedType();
+        const auto & tmp_ret_type = static_cast<const DataTypeNullable &>(*block.getByPosition(result).type).getNestedType();
 
         Array const_array;
         if (col_array)
         {
-            const auto &nullable_col = static_cast<const ColumnNullable &>(col_array->getData());
-            const auto &nested_col = nullable_col.getNestedColumn();
+            const auto & nullable_col = static_cast<const ColumnNullable &>(col_array->getData());
+            const auto & nested_col = nullable_col.getNestedColumn();
 
             /// Put nested_col inside a ColumnArray.
             source_block =
-                    {
-                            {
-                                    std::make_shared<ColumnArray>(nested_col, col_array->getOffsetsColumn()),
-                                    std::make_shared<DataTypeArray>(input_type),
-                                    ""
-                            },
-                            block.getByPosition(arguments[1]),
-                            {
-                                    nullptr,
-                                    tmp_ret_type,
-                                    ""
-                            }
-                    };
+            {
+                {
+                    std::make_shared<ColumnArray>(nested_col, col_array->getOffsetsColumn()),
+                    std::make_shared<DataTypeArray>(input_type),
+                    ""
+                },
+                block.getByPosition(arguments[1]),
+                {
+                    nullptr,
+                    tmp_ret_type,
+                    ""
+                }
+            };
 
             builder.initSource(nullable_col);
         }
@@ -1161,15 +1133,15 @@ void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &argume
         {
             /// Almost a copy of block.
             source_block =
-                    {
-                            block.getByPosition(arguments[0]),
-                            block.getByPosition(arguments[1]),
-                            {
-                                    nullptr,
-                                    tmp_ret_type,
-                                    ""
-                            }
-                    };
+            {
+                block.getByPosition(arguments[0]),
+                block.getByPosition(arguments[1]),
+                {
+                    nullptr,
+                    tmp_ret_type,
+                    ""
+                }
+            };
 
             const_array = col_const_array->getValue<Array>();
             builder.initSource(const_array);
@@ -1178,30 +1150,30 @@ void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &argume
         perform(source_block, {0, 1}, 2, builder);
 
         /// Store the result.
-        const ColumnWithTypeAndName &source_col = source_block.getByPosition(2);
-        ColumnWithTypeAndName &dest_col = block.getByPosition(result);
+        const ColumnWithTypeAndName & source_col = source_block.getByPosition(2);
+        ColumnWithTypeAndName & dest_col = block.getByPosition(result);
         dest_col.column = std::make_shared<ColumnNullable>(source_col.column, builder.getNullMap());
     }
 }
 
-void FunctionArrayElement::perform(Block &block, const ColumnNumbers &arguments, size_t result,
-                                   ArrayImpl::NullMapBuilder &builder)
+void FunctionArrayElement::perform(Block & block, const ColumnNumbers & arguments, size_t result,
+    ArrayImpl::NullMapBuilder & builder)
 {
     if (executeTuple(block, arguments, result))
     {
     }
     else if (!block.getByPosition(arguments[1]).column->isConst())
     {
-        if (!(executeArgument<UInt8>(block, arguments, result, builder)
-              || executeArgument<UInt16>(block, arguments, result, builder)
-              || executeArgument<UInt32>(block, arguments, result, builder)
-              || executeArgument<UInt64>(block, arguments, result, builder)
-              || executeArgument<Int8>(block, arguments, result, builder)
-              || executeArgument<Int16>(block, arguments, result, builder)
-              || executeArgument<Int32>(block, arguments, result, builder)
-              || executeArgument<Int64>(block, arguments, result, builder)))
-            throw Exception("Second argument for function " + getName() + " must must have UInt or Int type.",
-                            ErrorCodes::ILLEGAL_COLUMN);
+        if (!(    executeArgument<UInt8>   (block, arguments, result, builder)
+            ||    executeArgument<UInt16>  (block, arguments, result, builder)
+            ||    executeArgument<UInt32>  (block, arguments, result, builder)
+            ||    executeArgument<UInt64>  (block, arguments, result, builder)
+            ||    executeArgument<Int8>    (block, arguments, result, builder)
+            ||    executeArgument<Int16>   (block, arguments, result, builder)
+            ||    executeArgument<Int32>   (block, arguments, result, builder)
+            ||    executeArgument<Int64>   (block, arguments, result, builder)))
+        throw Exception("Second argument for function " + getName() + " must must have UInt or Int type.",
+                        ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1213,28 +1185,28 @@ void FunctionArrayElement::perform(Block &block, const ColumnNumbers &arguments,
         if (index == UInt64(0))
             throw Exception("Array indices is 1-based", ErrorCodes::ZERO_ARRAY_OR_TUPLE_INDEX);
 
-        if (!(executeNumberConst<UInt8>(block, arguments, result, index, builder)
-              || executeNumberConst<UInt16>(block, arguments, result, index, builder)
-              || executeNumberConst<UInt32>(block, arguments, result, index, builder)
-              || executeNumberConst<UInt64>(block, arguments, result, index, builder)
-              || executeNumberConst<Int8>(block, arguments, result, index, builder)
-              || executeNumberConst<Int16>(block, arguments, result, index, builder)
-              || executeNumberConst<Int32>(block, arguments, result, index, builder)
-              || executeNumberConst<Int64>(block, arguments, result, index, builder)
-              || executeNumberConst<Float32>(block, arguments, result, index, builder)
-              || executeNumberConst<Float64>(block, arguments, result, index, builder)
-              || executeConstConst(block, arguments, result, index, builder)
-              || executeStringConst(block, arguments, result, index, builder)
-              || executeGenericConst(block, arguments, result, index, builder)))
-            throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                            + " of first argument of function " + getName(),
-                            ErrorCodes::ILLEGAL_COLUMN);
+        if (!(    executeNumberConst<UInt8>   (block, arguments, result, index, builder)
+            ||    executeNumberConst<UInt16>  (block, arguments, result, index, builder)
+            ||    executeNumberConst<UInt32>  (block, arguments, result, index, builder)
+            ||    executeNumberConst<UInt64>  (block, arguments, result, index, builder)
+            ||    executeNumberConst<Int8>    (block, arguments, result, index, builder)
+            ||    executeNumberConst<Int16>   (block, arguments, result, index, builder)
+            ||    executeNumberConst<Int32>   (block, arguments, result, index, builder)
+            ||    executeNumberConst<Int64>   (block, arguments, result, index, builder)
+            ||    executeNumberConst<Float32> (block, arguments, result, index, builder)
+            ||    executeNumberConst<Float64> (block, arguments, result, index, builder)
+            ||    executeConstConst           (block, arguments, result, index, builder)
+            ||    executeStringConst          (block, arguments, result, index, builder)
+            ||    executeGenericConst         (block, arguments, result, index, builder)))
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
+            + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
     }
 }
 
 /// Implementation of FunctionArrayEnumerate.
 
-FunctionPtr FunctionArrayEnumerate::create(const Context &context)
+FunctionPtr FunctionArrayEnumerate::create(const Context & context)
 {
     return std::make_shared<FunctionArrayEnumerate>();
 }
@@ -1244,27 +1216,27 @@ String FunctionArrayEnumerate::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayEnumerate::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayEnumerate::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("First argument for function " + getName() + " must be an array but it has type "
-                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt32>());
 }
 
-void FunctionArrayEnumerate::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    if (const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
+    if (const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
     {
-        const ColumnArray::Offsets_t &offsets = array->getOffsets();
+        const ColumnArray::Offsets_t & offsets = array->getOffsets();
 
         auto res_nested = std::make_shared<ColumnUInt32>();
         auto res_array = std::make_shared<ColumnArray>(res_nested, array->getOffsetsColumn());
         block.getByPosition(result).column = res_array;
 
-        ColumnUInt32::Container_t &res_values = res_nested->getData();
+        ColumnUInt32::Container_t & res_values = res_nested->getData();
         res_values.resize(array->getData().size());
         size_t prev_off = 0;
         for (size_t i = 0; i < offsets.size(); ++i)
@@ -1277,8 +1249,7 @@ void FunctionArrayEnumerate::executeImpl(Block &block, const ColumnNumbers &argu
             prev_off = off;
         }
     }
-    else if (const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(
-            block.getByPosition(arguments[0]).column.get()))
+    else if (const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
     {
         Array values = array->getValue<Array>();
 
@@ -1288,53 +1259,50 @@ void FunctionArrayEnumerate::executeImpl(Block &block, const ColumnNumbers &argu
             res_values[i] = i + 1;
         }
 
-        block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(),
-                                                                                                 res_values);
+        block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(), res_values);
     }
     else
     {
         throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                        + " of first argument of function " + getName(),
-                        ErrorCodes::ILLEGAL_COLUMN);
+                + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
     }
 }
 
 /// Implementation of FunctionArrayUniq.
 
-FunctionPtr FunctionArrayUniq::create(const Context &context)
-{ return std::make_shared<FunctionArrayUniq>(); }
+FunctionPtr FunctionArrayUniq::create(const Context & context) { return std::make_shared<FunctionArrayUniq>(); }
 
 String FunctionArrayUniq::getName() const
 {
     return name;
 }
 
-DataTypePtr FunctionArrayUniq::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayUniq::getReturnTypeImpl(const DataTypes & arguments) const
 {
     if (arguments.size() == 0)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-                        + toString(arguments.size()) + ", should be at least 1.",
-                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+            + toString(arguments.size()) + ", should be at least 1.",
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     for (size_t i = 0; i < arguments.size(); ++i)
     {
-        const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
+        const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
         if (!array_type)
             throw Exception("All arguments for function " + getName() + " must be arrays but argument " +
-                            toString(i + 1) + " has type " + arguments[i]->getName() + ".",
-                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                toString(i + 1) + " has type " + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return std::make_shared<DataTypeUInt32>();
 }
 
-void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     if (arguments.size() == 1 && executeConst(block, arguments, result))
         return;
 
     Columns array_columns(arguments.size());
-    const ColumnArray::Offsets_t *offsets = nullptr;
+    const ColumnArray::Offsets_t * offsets = nullptr;
     ConstColumnPlainPtrs data_columns(arguments.size());
     ConstColumnPlainPtrs original_data_columns(arguments.size());
     ConstColumnPlainPtrs null_maps(arguments.size());
@@ -1344,28 +1312,27 @@ void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments
     for (size_t i = 0; i < arguments.size(); ++i)
     {
         ColumnPtr array_ptr = block.getByPosition(arguments[i]).column;
-        const ColumnArray *array = checkAndGetColumn<ColumnArray>(array_ptr.get());
+        const ColumnArray * array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         if (!array)
         {
-            const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
-                    block.getByPosition(arguments[i]).column.get());
+            const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(
+                block.getByPosition(arguments[i]).column.get());
             if (!const_array)
                 throw Exception("Illegal column " + block.getByPosition(arguments[i]).column->getName()
-                                + " of " + toString(i + 1) + getOrdinalSuffix(i + 1) + " argument of function " +
-                                getName(),
-                                ErrorCodes::ILLEGAL_COLUMN);
+                    + " of " + toString(i + 1) + getOrdinalSuffix(i + 1) + " argument of function " + getName(),
+                    ErrorCodes::ILLEGAL_COLUMN);
             array_ptr = const_array->convertToFullColumn();
             array = static_cast<const ColumnArray *>(array_ptr.get());
         }
 
         array_columns[i] = array_ptr;
 
-        const ColumnArray::Offsets_t &offsets_i = array->getOffsets();
+        const ColumnArray::Offsets_t & offsets_i = array->getOffsets();
         if (i == 0)
             offsets = &offsets_i;
         else if (offsets_i != *offsets)
             throw Exception("Lengths of all arrays passsed to " + getName() + " must be equal.",
-                            ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
+                ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
 
         data_columns[i] = &array->getData();
         original_data_columns[i] = data_columns[i];
@@ -1373,7 +1340,7 @@ void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments
         if (data_columns[i]->isNullable())
         {
             has_nullable_columns = true;
-            const auto &nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
+            const auto & nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
             data_columns[i] = nullable_col.getNestedColumn().get();
             null_maps[i] = nullable_col.getNullMapColumn().get();
         }
@@ -1381,30 +1348,30 @@ void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments
             null_maps[i] = nullptr;
     }
 
-    const ColumnArray *first_array = static_cast<const ColumnArray *>(array_columns[0].get());
-    const IColumn *first_null_map = null_maps[0];
+    const ColumnArray * first_array = static_cast<const ColumnArray *>(array_columns[0].get());
+    const IColumn * first_null_map = null_maps[0];
     auto res = std::make_shared<ColumnUInt32>();
     block.getByPosition(result).column = res;
 
-    ColumnUInt32::Container_t &res_values = res->getData();
+    ColumnUInt32::Container_t & res_values = res->getData();
     res_values.resize(offsets->size());
 
     if (arguments.size() == 1)
     {
-        if (!(executeNumber<UInt8>(first_array, first_null_map, res_values)
-              || executeNumber<UInt16>(first_array, first_null_map, res_values)
-              || executeNumber<UInt32>(first_array, first_null_map, res_values)
-              || executeNumber<UInt64>(first_array, first_null_map, res_values)
-              || executeNumber<Int8>(first_array, first_null_map, res_values)
-              || executeNumber<Int16>(first_array, first_null_map, res_values)
-              || executeNumber<Int32>(first_array, first_null_map, res_values)
-              || executeNumber<Int64>(first_array, first_null_map, res_values)
-              || executeNumber<Float32>(first_array, first_null_map, res_values)
-              || executeNumber<Float64>(first_array, first_null_map, res_values)
-              || executeString(first_array, first_null_map, res_values)))
+        if (!(    executeNumber<UInt8>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt16>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt64>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int8>        (first_array, first_null_map, res_values)
+            ||    executeNumber<Int16>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int64>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Float32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Float64>    (first_array, first_null_map, res_values)
+            ||    executeString            (first_array, first_null_map, res_values)))
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                            + " of first argument of function " + getName(),
-                            ErrorCodes::ILLEGAL_COLUMN);
+                    + " of first argument of function " + getName(),
+                ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1413,31 +1380,30 @@ void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments
     }
 }
 
-template<typename T>
-bool FunctionArrayUniq::executeNumber(const ColumnArray *array, const IColumn *null_map,
-                                      ColumnUInt32::Container_t &res_values)
+template <typename T>
+bool FunctionArrayUniq::executeNumber(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
 {
-    const IColumn *inner_col;
+    const IColumn * inner_col;
 
-    const auto &array_data = array->getData();
+    const auto & array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnVector<T> *nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
+    const ColumnVector<T> * nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
-    const typename ColumnVector<T>::Container_t &values = nested->getData();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    const typename ColumnVector<T>::Container_t & values = nested->getData();
 
     using Set = ClearableHashSet<T, DefaultHash<T>, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
 
-    const PaddedPODArray<UInt8> *null_map_data = nullptr;
+    const PaddedPODArray<UInt8> * null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1462,29 +1428,28 @@ bool FunctionArrayUniq::executeNumber(const ColumnArray *array, const IColumn *n
     return true;
 }
 
-bool FunctionArrayUniq::executeString(const ColumnArray *array, const IColumn *null_map,
-                                      ColumnUInt32::Container_t &res_values)
+bool FunctionArrayUniq::executeString(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
 {
-    const IColumn *inner_col;
+    const IColumn * inner_col;
 
-    const auto &array_data = array->getData();
+    const auto & array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnString *nested = checkAndGetColumn<ColumnString>(inner_col);
+    const ColumnString * nested = checkAndGetColumn<ColumnString>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
 
     using Set = ClearableHashSet<StringRef, StringRefHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
 
-    const PaddedPODArray<UInt8> *null_map_data = nullptr;
+    const PaddedPODArray<UInt8> * null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1509,9 +1474,9 @@ bool FunctionArrayUniq::executeString(const ColumnArray *array, const IColumn *n
     return true;
 }
 
-bool FunctionArrayUniq::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
+bool FunctionArrayUniq::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
         return false;
     Array values = array->getValue<Array>();
@@ -1525,11 +1490,11 @@ bool FunctionArrayUniq::executeConst(Block &block, const ColumnNumbers &argument
 }
 
 bool FunctionArrayUniq::execute128bit(
-        const ColumnArray::Offsets_t &offsets,
-        const ConstColumnPlainPtrs &columns,
-        const ConstColumnPlainPtrs &null_maps,
-        ColumnUInt32::Container_t &res_values,
-        bool has_nullable_columns)
+    const ColumnArray::Offsets_t & offsets,
+    const ConstColumnPlainPtrs & columns,
+    const ConstColumnPlainPtrs & null_maps,
+    ColumnUInt32::Container_t & res_values,
+    bool has_nullable_columns)
 {
     size_t count = columns.size();
     size_t keys_bytes = 0;
@@ -1549,7 +1514,7 @@ bool FunctionArrayUniq::execute128bit(
         return false;
 
     using Set = ClearableHashSet<UInt128, UInt128HashCRC32, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     /// Suppose that, for a given row, each of the N columns has an array whose length is M.
     /// Denote arr_i each of these arrays (1 <= i <= N). Then the following is performed:
@@ -1580,7 +1545,7 @@ bool FunctionArrayUniq::execute128bit(
                 {
                     if (null_maps[i])
                     {
-                        const auto &null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
+                        const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
                         if (null_map[j] == 1)
                         {
                             size_t bucket = i / 8;
@@ -1603,14 +1568,14 @@ bool FunctionArrayUniq::execute128bit(
 }
 
 void FunctionArrayUniq::executeHashed(
-        const ColumnArray::Offsets_t &offsets,
-        const ConstColumnPlainPtrs &columns,
-        ColumnUInt32::Container_t &res_values)
+    const ColumnArray::Offsets_t & offsets,
+    const ConstColumnPlainPtrs & columns,
+    ColumnUInt32::Container_t & res_values)
 {
     size_t count = columns.size();
 
     using Set = ClearableHashSet<UInt128, UInt128TrivialHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     Set set;
     size_t prev_off = 0;
@@ -1628,7 +1593,7 @@ void FunctionArrayUniq::executeHashed(
 
 /// Implementation of FunctionArrayEnumerateUniq.
 
-FunctionPtr FunctionArrayEnumerateUniq::create(const Context &context)
+FunctionPtr FunctionArrayEnumerateUniq::create(const Context & context)
 {
     return std::make_shared<FunctionArrayEnumerateUniq>();
 }
@@ -1638,32 +1603,31 @@ String FunctionArrayEnumerateUniq::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayEnumerateUniq::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayEnumerateUniq::getReturnTypeImpl(const DataTypes & arguments) const
 {
     if (arguments.size() == 0)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-                        + toString(arguments.size()) + ", should be at least 1.",
-                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+            + toString(arguments.size()) + ", should be at least 1.",
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     for (size_t i = 0; i < arguments.size(); ++i)
     {
-        const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
+        const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
         if (!array_type)
             throw Exception("All arguments for function " + getName() + " must be arrays but argument " +
-                            toString(i + 1) + " has type " + arguments[i]->getName() + ".",
-                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                toString(i + 1) + " has type " + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt32>());
 }
 
-void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     if (arguments.size() == 1 && executeConst(block, arguments, result))
         return;
 
     Columns array_columns(arguments.size());
-    const ColumnArray::Offsets_t *offsets = nullptr;
+    const ColumnArray::Offsets_t * offsets = nullptr;
     ConstColumnPlainPtrs data_columns(arguments.size());
     ConstColumnPlainPtrs original_data_columns(arguments.size());
     ConstColumnPlainPtrs null_maps(arguments.size());
@@ -1673,25 +1637,25 @@ void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &
     for (size_t i = 0; i < arguments.size(); ++i)
     {
         ColumnPtr array_ptr = block.getByPosition(arguments[i]).column;
-        const ColumnArray *array = checkAndGetColumn<ColumnArray>(array_ptr.get());
+        const ColumnArray * array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         if (!array)
         {
-            const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
-                    block.getByPosition(arguments[i]).column.get());
+            const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(
+                block.getByPosition(arguments[i]).column.get());
             if (!const_array)
                 throw Exception("Illegal column " + block.getByPosition(arguments[i]).column->getName()
-                                + " of " + toString(i + 1) + "-th argument of function " + getName(),
-                                ErrorCodes::ILLEGAL_COLUMN);
+                    + " of " + toString(i + 1) + "-th argument of function " + getName(),
+                    ErrorCodes::ILLEGAL_COLUMN);
             array_ptr = const_array->convertToFullColumn();
             array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         }
         array_columns[i] = array_ptr;
-        const ColumnArray::Offsets_t &offsets_i = array->getOffsets();
+        const ColumnArray::Offsets_t & offsets_i = array->getOffsets();
         if (i == 0)
             offsets = &offsets_i;
         else if (offsets_i != *offsets)
             throw Exception("Lengths of all arrays passsed to " + getName() + " must be equal.",
-                            ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
+                ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
 
         data_columns[i] = &array->getData();
         original_data_columns[i] = data_columns[i];
@@ -1699,7 +1663,7 @@ void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &
         if (data_columns[i]->isNullable())
         {
             has_nullable_columns = true;
-            const auto &nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
+            const auto & nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
             data_columns[i] = nullable_col.getNestedColumn().get();
             null_maps[i] = nullable_col.getNullMapColumn().get();
         }
@@ -1707,32 +1671,32 @@ void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &
             null_maps[i] = nullptr;
     }
 
-    const ColumnArray *first_array = checkAndGetColumn<ColumnArray>(array_columns[0].get());
-    const IColumn *first_null_map = null_maps[0];
+    const ColumnArray * first_array = checkAndGetColumn<ColumnArray>(array_columns[0].get());
+    const IColumn * first_null_map = null_maps[0];
     auto res_nested = std::make_shared<ColumnUInt32>();
     auto res_array = std::make_shared<ColumnArray>(res_nested, first_array->getOffsetsColumn());
     block.getByPosition(result).column = res_array;
 
-    ColumnUInt32::Container_t &res_values = res_nested->getData();
+    ColumnUInt32::Container_t & res_values = res_nested->getData();
     if (!offsets->empty())
         res_values.resize(offsets->back());
 
     if (arguments.size() == 1)
     {
-        if (!(executeNumber<UInt8>(first_array, first_null_map, res_values)
-              || executeNumber<UInt16>(first_array, first_null_map, res_values)
-              || executeNumber<UInt32>(first_array, first_null_map, res_values)
-              || executeNumber<UInt64>(first_array, first_null_map, res_values)
-              || executeNumber<Int8>(first_array, first_null_map, res_values)
-              || executeNumber<Int16>(first_array, first_null_map, res_values)
-              || executeNumber<Int32>(first_array, first_null_map, res_values)
-              || executeNumber<Int64>(first_array, first_null_map, res_values)
-              || executeNumber<Float32>(first_array, first_null_map, res_values)
-              || executeNumber<Float64>(first_array, first_null_map, res_values)
-              || executeString(first_array, first_null_map, res_values)))
+        if (!(    executeNumber<UInt8>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt16>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt64>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int8>        (first_array, first_null_map, res_values)
+            ||    executeNumber<Int16>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int64>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Float32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Float64>    (first_array, first_null_map, res_values)
+            ||    executeString            (first_array, first_null_map, res_values)))
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                            + " of first argument of function " + getName(),
-                            ErrorCodes::ILLEGAL_COLUMN);
+                    + " of first argument of function " + getName(),
+                ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1742,31 +1706,30 @@ void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &
 }
 
 
-template<typename T>
-bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray *array, const IColumn *null_map,
-                                               ColumnUInt32::Container_t &res_values)
+template <typename T>
+bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
 {
-    const IColumn *inner_col;
+    const IColumn * inner_col;
 
-    const auto &array_data = array->getData();
+    const auto & array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnVector<T> *nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
+    const ColumnVector<T> * nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
-    const typename ColumnVector<T>::Container_t &values = nested->getData();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    const typename ColumnVector<T>::Container_t & values = nested->getData();
 
     using ValuesToIndices = ClearableHashMap<T, UInt32, DefaultHash<T>, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
 
-    const PaddedPODArray<UInt8> *null_map_data = nullptr;
+    const PaddedPODArray<UInt8> * null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1789,30 +1752,29 @@ bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray *array, const I
     return true;
 }
 
-bool FunctionArrayEnumerateUniq::executeString(const ColumnArray *array, const IColumn *null_map,
-                                               ColumnUInt32::Container_t &res_values)
+bool FunctionArrayEnumerateUniq::executeString(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
 {
-    const IColumn *inner_col;
+    const IColumn * inner_col;
 
-    const auto &array_data = array->getData();
+    const auto & array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnString *nested = checkAndGetColumn<ColumnString>(inner_col);
+    const ColumnString * nested = checkAndGetColumn<ColumnString>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
 
     size_t prev_off = 0;
     using ValuesToIndices = ClearableHashMap<StringRef, UInt32, StringRefHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
 
-    const PaddedPODArray<UInt8> *null_map_data = nullptr;
+    const PaddedPODArray<UInt8> * null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1834,9 +1796,9 @@ bool FunctionArrayEnumerateUniq::executeString(const ColumnArray *array, const I
     return true;
 }
 
-bool FunctionArrayEnumerateUniq::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
+bool FunctionArrayEnumerateUniq::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
         return false;
     Array values = array->getValue<Array>();
@@ -1854,11 +1816,11 @@ bool FunctionArrayEnumerateUniq::executeConst(Block &block, const ColumnNumbers
 }
 
 bool FunctionArrayEnumerateUniq::execute128bit(
-        const ColumnArray::Offsets_t &offsets,
-        const ConstColumnPlainPtrs &columns,
-        const ConstColumnPlainPtrs &null_maps,
-        ColumnUInt32::Container_t &res_values,
-        bool has_nullable_columns)
+    const ColumnArray::Offsets_t & offsets,
+    const ConstColumnPlainPtrs & columns,
+    const ConstColumnPlainPtrs & null_maps,
+    ColumnUInt32::Container_t & res_values,
+    bool has_nullable_columns)
 {
     size_t count = columns.size();
     size_t keys_bytes = 0;
@@ -1878,7 +1840,7 @@ bool FunctionArrayEnumerateUniq::execute128bit(
         return false;
 
     using ValuesToIndices = ClearableHashMap<UInt128, UInt32, UInt128HashCRC32, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     ValuesToIndices indices;
     size_t prev_off = 0;
@@ -1896,7 +1858,7 @@ bool FunctionArrayEnumerateUniq::execute128bit(
                 {
                     if (null_maps[i])
                     {
-                        const auto &null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
+                        const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
                         if (null_map[j] == 1)
                         {
                             size_t bucket = i / 8;
@@ -1917,14 +1879,14 @@ bool FunctionArrayEnumerateUniq::execute128bit(
 }
 
 void FunctionArrayEnumerateUniq::executeHashed(
-        const ColumnArray::Offsets_t &offsets,
-        const ConstColumnPlainPtrs &columns,
-        ColumnUInt32::Container_t &res_values)
+    const ColumnArray::Offsets_t & offsets,
+    const ConstColumnPlainPtrs & columns,
+    ColumnUInt32::Container_t & res_values)
 {
     size_t count = columns.size();
 
     using ValuesToIndices = ClearableHashMap<UInt128, UInt32, UInt128TrivialHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     ValuesToIndices indices;
     size_t prev_off = 0;
@@ -1942,20 +1904,19 @@ void FunctionArrayEnumerateUniq::executeHashed(
 
 /// Implementation of FunctionEmptyArrayToSingle.
 
-FunctionPtr FunctionEmptyArrayToSingle::create(const Context &context)
-{ return std::make_shared<FunctionEmptyArrayToSingle>(); }
+FunctionPtr FunctionEmptyArrayToSingle::create(const Context & context) { return std::make_shared<FunctionEmptyArrayToSingle>(); }
 
 String FunctionEmptyArrayToSingle::getName() const
 {
     return name;
 }
 
-DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("Argument for function " + getName() + " must be array.",
-                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return arguments[0]->clone();
 }
@@ -1963,366 +1924,347 @@ DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes &argum
 
 namespace
 {
-namespace FunctionEmptyArrayToSingleImpl
-{
-bool executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
-{
-    if (const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
-            block.getByPosition(arguments[0]).column.get()))
+    namespace FunctionEmptyArrayToSingleImpl
     {
-        if (const_array->getValue<Array>().empty())
+        bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
         {
-            auto nested_type = typeid_cast<const DataTypeArray &>(
-                    *block.getByPosition(arguments[0]).type).getNestedType();
-
-            block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
-                    block.rows(),
-                    Array{nested_type->getDefault()});
-        }
-        else
-            block.getByPosition(result).column = block.getByPosition(arguments[0]).column;
-
-        return true;
-    }
-    else
-        return false;
-}
-
-template<typename T, bool nullable>
-bool executeNumber(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data_col, ColumnArray::Offsets_t &res_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    if (const ColumnVector<T> *src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
-    {
-        const PaddedPODArray<T> &src_data = src_data_concrete->getData();
-        PaddedPODArray<T> &res_data = static_cast<ColumnVector<T> &>(res_data_col).getData();
-
-        size_t size = src_offsets.size();
-        res_offsets.resize(size);
-        res_data.reserve(src_data.size());
-
-        if (nullable)
-            res_null_map->reserve(src_null_map->size());
-
-        ColumnArray::Offset_t src_prev_offset = 0;
-        ColumnArray::Offset_t res_prev_offset = 0;
-
-        for (size_t i = 0; i < size; ++i)
-        {
-            if (src_offsets[i] != src_prev_offset)
+            if (const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
             {
-                size_t size_to_write = src_offsets[i] - src_prev_offset;
-                res_data.resize(res_prev_offset + size_to_write);
-                memcpy(&res_data[res_prev_offset], &src_data[src_prev_offset], size_to_write * sizeof(T));
-
-                if (nullable)
+                if (const_array->getValue<Array>().empty())
                 {
-                    res_null_map->resize(res_prev_offset + size_to_write);
-                    memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
-                }
+                    auto nested_type = typeid_cast<const DataTypeArray &>(*block.getByPosition(arguments[0]).type).getNestedType();
 
-                res_prev_offset += size_to_write;
-                res_offsets[i] = res_prev_offset;
+                    block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
+                        block.rows(),
+                        Array{nested_type->getDefault()});
+                }
+                else
+                    block.getByPosition(result).column = block.getByPosition(arguments[0]).column;
+
+                return true;
             }
             else
-            {
-                res_data.push_back(T());
-                ++res_prev_offset;
-                res_offsets[i] = res_prev_offset;
-
-                if (nullable)
-                    res_null_map->push_back(1); /// Push NULL.
-            }
-
-            src_prev_offset = src_offsets[i];
+                return false;
         }
 
-        return true;
-    }
-    else
-        return false;
-}
-
-
-template<bool nullable>
-bool executeFixedString(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data_col, ColumnArray::Offsets_t &res_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    if (const ColumnFixedString *src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
-    {
-        const size_t n = src_data_concrete->getN();
-        const ColumnFixedString::Chars_t &src_data = src_data_concrete->getChars();
-
-        auto concrete_res_data = typeid_cast<ColumnFixedString *>(&res_data_col);
-        if (!concrete_res_data)
-            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-
-        ColumnFixedString::Chars_t &res_data = concrete_res_data->getChars();
-        size_t size = src_offsets.size();
-        res_offsets.resize(size);
-        res_data.reserve(src_data.size());
-
-        if (nullable)
-            res_null_map->reserve(src_null_map->size());
-
-        ColumnArray::Offset_t src_prev_offset = 0;
-        ColumnArray::Offset_t res_prev_offset = 0;
-
-        for (size_t i = 0; i < size; ++i)
+        template <typename T, bool nullable>
+        bool executeNumber(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+            IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
         {
-            if (src_offsets[i] != src_prev_offset)
+            if (const ColumnVector<T> * src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
             {
-                size_t size_to_write = src_offsets[i] - src_prev_offset;
-                size_t prev_res_data_size = res_data.size();
-                res_data.resize(prev_res_data_size + size_to_write * n);
-                memcpy(&res_data[prev_res_data_size], &src_data[src_prev_offset * n], size_to_write * n);
+                const PaddedPODArray<T> & src_data = src_data_concrete->getData();
+                PaddedPODArray<T> & res_data = static_cast<ColumnVector<T> &>(res_data_col).getData();
+
+                size_t size = src_offsets.size();
+                res_offsets.resize(size);
+                res_data.reserve(src_data.size());
 
                 if (nullable)
+                    res_null_map->reserve(src_null_map->size());
+
+                ColumnArray::Offset_t src_prev_offset = 0;
+                ColumnArray::Offset_t res_prev_offset = 0;
+
+                for (size_t i = 0; i < size; ++i)
                 {
-                    res_null_map->resize(res_prev_offset + size_to_write);
-                    memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                    if (src_offsets[i] != src_prev_offset)
+                    {
+                        size_t size_to_write = src_offsets[i] - src_prev_offset;
+                        res_data.resize(res_prev_offset + size_to_write);
+                        memcpy(&res_data[res_prev_offset], &src_data[src_prev_offset], size_to_write * sizeof(T));
+
+                        if (nullable)
+                        {
+                            res_null_map->resize(res_prev_offset + size_to_write);
+                            memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                        }
+
+                        res_prev_offset += size_to_write;
+                        res_offsets[i] = res_prev_offset;
+                    }
+                    else
+                    {
+                        res_data.push_back(T());
+                        ++res_prev_offset;
+                        res_offsets[i] = res_prev_offset;
+
+                        if (nullable)
+                            res_null_map->push_back(1); /// Push NULL.
+                    }
+
+                    src_prev_offset = src_offsets[i];
                 }
 
-                res_prev_offset += size_to_write;
-                res_offsets[i] = res_prev_offset;
+                return true;
             }
             else
-            {
-                size_t prev_res_data_size = res_data.size();
-                res_data.resize(prev_res_data_size + n);
-                memset(&res_data[prev_res_data_size], 0, n);
-                ++res_prev_offset;
-                res_offsets[i] = res_prev_offset;
-
-                if (nullable)
-                    res_null_map->push_back(1);
-            }
-
-            src_prev_offset = src_offsets[i];
+                return false;
         }
 
-        return true;
-    }
-    else
-        return false;
-}
 
-
-template<bool nullable>
-bool executeString(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
-        IColumn &res_data_col, ColumnArray::Offsets_t &res_array_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    if (const ColumnString *src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
-    {
-        const ColumnString::Offsets_t &src_string_offsets = src_data_concrete->getOffsets();
-
-        auto concrete_res_string_offsets = typeid_cast<ColumnString *>(&res_data_col);
-        if (!concrete_res_string_offsets)
-            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-        ColumnString::Offsets_t &res_string_offsets = concrete_res_string_offsets->getOffsets();
-
-        const ColumnString::Chars_t &src_data = src_data_concrete->getChars();
-
-        auto concrete_res_data = typeid_cast<ColumnString *>(&res_data_col);
-        if (!concrete_res_data)
-            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-        ColumnString::Chars_t &res_data = concrete_res_data->getChars();
-
-        size_t size = src_array_offsets.size();
-        res_array_offsets.resize(size);
-        res_string_offsets.reserve(src_string_offsets.size());
-        res_data.reserve(src_data.size());
-
-        if (nullable)
-            res_null_map->reserve(src_null_map->size());
-
-        ColumnArray::Offset_t src_array_prev_offset = 0;
-        ColumnArray::Offset_t res_array_prev_offset = 0;
-
-        ColumnString::Offset_t src_string_prev_offset = 0;
-        ColumnString::Offset_t res_string_prev_offset = 0;
-
-        for (size_t i = 0; i < size; ++i)
+        template <bool nullable>
+        bool executeFixedString(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+            IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
         {
-            if (src_array_offsets[i] != src_array_prev_offset)
+            if (const ColumnFixedString * src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
             {
-                size_t array_size = src_array_offsets[i] - src_array_prev_offset;
+                const size_t n = src_data_concrete->getN();
+                const ColumnFixedString::Chars_t & src_data = src_data_concrete->getChars();
 
-                size_t bytes_to_copy = 0;
-                size_t from_string_prev_offset_local = src_string_prev_offset;
-                for (size_t j = 0; j < array_size; ++j)
-                {
-                    size_t string_size = src_string_offsets[src_array_prev_offset + j] - from_string_prev_offset_local;
+                auto concrete_res_data = typeid_cast<ColumnFixedString *>(&res_data_col);
+                if (!concrete_res_data)
+                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
 
-                    res_string_prev_offset += string_size;
-                    res_string_offsets.push_back(res_string_prev_offset);
-
-                    from_string_prev_offset_local += string_size;
-                    bytes_to_copy += string_size;
-                }
-
-                size_t res_data_old_size = res_data.size();
-                res_data.resize(res_data_old_size + bytes_to_copy);
-                memcpy(&res_data[res_data_old_size], &src_data[src_string_prev_offset], bytes_to_copy);
+                ColumnFixedString::Chars_t & res_data = concrete_res_data->getChars();
+                size_t size = src_offsets.size();
+                res_offsets.resize(size);
+                res_data.reserve(src_data.size());
 
                 if (nullable)
+                    res_null_map->reserve(src_null_map->size());
+
+                ColumnArray::Offset_t src_prev_offset = 0;
+                ColumnArray::Offset_t res_prev_offset = 0;
+
+                for (size_t i = 0; i < size; ++i)
                 {
-                    res_null_map->resize(res_array_prev_offset + array_size);
-                    memcpy(&(*res_null_map)[res_array_prev_offset], &(*src_null_map)[src_array_prev_offset],
-                           array_size);
+                    if (src_offsets[i] != src_prev_offset)
+                    {
+                        size_t size_to_write = src_offsets[i] - src_prev_offset;
+                        size_t prev_res_data_size = res_data.size();
+                        res_data.resize(prev_res_data_size + size_to_write * n);
+                        memcpy(&res_data[prev_res_data_size], &src_data[src_prev_offset * n], size_to_write * n);
+
+                        if (nullable)
+                        {
+                            res_null_map->resize(res_prev_offset + size_to_write);
+                            memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                        }
+
+                        res_prev_offset += size_to_write;
+                        res_offsets[i] = res_prev_offset;
+                    }
+                    else
+                    {
+                        size_t prev_res_data_size = res_data.size();
+                        res_data.resize(prev_res_data_size + n);
+                        memset(&res_data[prev_res_data_size], 0, n);
+                        ++res_prev_offset;
+                        res_offsets[i] = res_prev_offset;
+
+                        if (nullable)
+                            res_null_map->push_back(1);
+                    }
+
+                    src_prev_offset = src_offsets[i];
                 }
 
-                res_array_prev_offset += array_size;
-                res_array_offsets[i] = res_array_prev_offset;
+                return true;
             }
             else
-            {
-                res_data.push_back(0);  /// An empty string, including zero at the end.
-
-                if (nullable)
-                    res_null_map->push_back(1);
-
-                ++res_string_prev_offset;
-                res_string_offsets.push_back(res_string_prev_offset);
-
-                ++res_array_prev_offset;
-                res_array_offsets[i] = res_array_prev_offset;
-            }
-
-            src_array_prev_offset = src_array_offsets[i];
-
-            if (src_array_prev_offset)
-                src_string_prev_offset = src_string_offsets[src_array_prev_offset - 1];
+                return false;
         }
 
-        return true;
-    }
-    else
-        return false;
-}
 
-
-template<bool nullable>
-void executeGeneric(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data, ColumnArray::Offsets_t &res_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    size_t size = src_offsets.size();
-    res_offsets.resize(size);
-    res_data.reserve(src_data.size());
-
-    if (nullable)
-        res_null_map->reserve(src_null_map->size());
-
-    ColumnArray::Offset_t src_prev_offset = 0;
-    ColumnArray::Offset_t res_prev_offset = 0;
-
-    for (size_t i = 0; i < size; ++i)
-    {
-        if (src_offsets[i] != src_prev_offset)
+        template <bool nullable>
+        bool executeString(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
+            IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
         {
-            size_t size_to_write = src_offsets[i] - src_prev_offset;
-            res_data.insertRangeFrom(src_data, src_prev_offset, size_to_write);
+            if (const ColumnString * src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+            {
+                const ColumnString::Offsets_t & src_string_offsets = src_data_concrete->getOffsets();
+
+                auto concrete_res_string_offsets = typeid_cast<ColumnString *>(&res_data_col);
+                if (!concrete_res_string_offsets)
+                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+                ColumnString::Offsets_t & res_string_offsets = concrete_res_string_offsets->getOffsets();
+
+                const ColumnString::Chars_t & src_data = src_data_concrete->getChars();
+
+                auto concrete_res_data = typeid_cast<ColumnString *>(&res_data_col);
+                if (!concrete_res_data)
+                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+                ColumnString::Chars_t & res_data = concrete_res_data->getChars();
+
+                size_t size = src_array_offsets.size();
+                res_array_offsets.resize(size);
+                res_string_offsets.reserve(src_string_offsets.size());
+                res_data.reserve(src_data.size());
+
+                if (nullable)
+                    res_null_map->reserve(src_null_map->size());
+
+                ColumnArray::Offset_t src_array_prev_offset = 0;
+                ColumnArray::Offset_t res_array_prev_offset = 0;
+
+                ColumnString::Offset_t src_string_prev_offset = 0;
+                ColumnString::Offset_t res_string_prev_offset = 0;
+
+                for (size_t i = 0; i < size; ++i)
+                {
+                    if (src_array_offsets[i] != src_array_prev_offset)
+                    {
+                        size_t array_size = src_array_offsets[i] - src_array_prev_offset;
+
+                        size_t bytes_to_copy = 0;
+                        size_t from_string_prev_offset_local = src_string_prev_offset;
+                        for (size_t j = 0; j < array_size; ++j)
+                        {
+                            size_t string_size = src_string_offsets[src_array_prev_offset + j] - from_string_prev_offset_local;
+
+                            res_string_prev_offset += string_size;
+                            res_string_offsets.push_back(res_string_prev_offset);
+
+                            from_string_prev_offset_local += string_size;
+                            bytes_to_copy += string_size;
+                        }
+
+                        size_t res_data_old_size = res_data.size();
+                        res_data.resize(res_data_old_size + bytes_to_copy);
+                        memcpy(&res_data[res_data_old_size], &src_data[src_string_prev_offset], bytes_to_copy);
+
+                        if (nullable)
+                        {
+                            res_null_map->resize(res_array_prev_offset + array_size);
+                            memcpy(&(*res_null_map)[res_array_prev_offset], &(*src_null_map)[src_array_prev_offset], array_size);
+                        }
+
+                        res_array_prev_offset += array_size;
+                        res_array_offsets[i] = res_array_prev_offset;
+                    }
+                    else
+                    {
+                        res_data.push_back(0);  /// An empty string, including zero at the end.
+
+                        if (nullable)
+                            res_null_map->push_back(1);
+
+                        ++res_string_prev_offset;
+                        res_string_offsets.push_back(res_string_prev_offset);
+
+                        ++res_array_prev_offset;
+                        res_array_offsets[i] = res_array_prev_offset;
+                    }
+
+                    src_array_prev_offset = src_array_offsets[i];
+
+                    if (src_array_prev_offset)
+                        src_string_prev_offset = src_string_offsets[src_array_prev_offset - 1];
+                }
+
+                return true;
+            }
+            else
+                return false;
+        }
+
+
+        template <bool nullable>
+        void executeGeneric(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+            IColumn & res_data, ColumnArray::Offsets_t & res_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
+        {
+            size_t size = src_offsets.size();
+            res_offsets.resize(size);
+            res_data.reserve(src_data.size());
 
             if (nullable)
+                res_null_map->reserve(src_null_map->size());
+
+            ColumnArray::Offset_t src_prev_offset = 0;
+            ColumnArray::Offset_t res_prev_offset = 0;
+
+            for (size_t i = 0; i < size; ++i)
             {
-                res_null_map->resize(res_prev_offset + size_to_write);
-                memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                if (src_offsets[i] != src_prev_offset)
+                {
+                    size_t size_to_write = src_offsets[i] - src_prev_offset;
+                    res_data.insertRangeFrom(src_data, src_prev_offset, size_to_write);
+
+                    if (nullable)
+                    {
+                        res_null_map->resize(res_prev_offset + size_to_write);
+                        memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                    }
+
+                    res_prev_offset += size_to_write;
+                    res_offsets[i] = res_prev_offset;
+                }
+                else
+                {
+                    res_data.insertDefault();
+                    ++res_prev_offset;
+                    res_offsets[i] = res_prev_offset;
+
+                    if (nullable)
+                        res_null_map->push_back(1);
+                }
+
+                src_prev_offset = src_offsets[i];
             }
-
-            res_prev_offset += size_to_write;
-            res_offsets[i] = res_prev_offset;
         }
-        else
+
+
+        template <bool nullable>
+        void executeDispatch(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
+            IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
         {
-            res_data.insertDefault();
-            ++res_prev_offset;
-            res_offsets[i] = res_prev_offset;
-
-            if (nullable)
-                res_null_map->push_back(1);
+            if (!( executeNumber<UInt8, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<UInt16, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<UInt32, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<UInt64, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Int8, nullable>   (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Int16, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Int32, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Int64, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Float32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Float64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeString<nullable>         (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeFixedString<nullable>    (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)))
+                executeGeneric<nullable>           (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map);
         }
-
-        src_prev_offset = src_offsets[i];
     }
 }
 
-
-template<bool nullable>
-void executeDispatch(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
-        IColumn &res_data_col, ColumnArray::Offsets_t &res_array_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    if (!(executeNumber<UInt8, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                         res_null_map)
-          || executeNumber<UInt16, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                             res_null_map)
-          || executeNumber<UInt32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                             res_null_map)
-          || executeNumber<UInt64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                             res_null_map)
-          || executeNumber<Int8, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                           res_null_map)
-          || executeNumber<Int16, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                            res_null_map)
-          || executeNumber<Int32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                            res_null_map)
-          || executeNumber<Int64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                            res_null_map)
-          ||
-          executeNumber<Float32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                           res_null_map)
-          ||
-          executeNumber<Float64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                           res_null_map)
-          || executeString<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                     res_null_map)
-          || executeFixedString<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                          res_null_map)))
-        executeGeneric<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                 res_null_map);
-}
-}
-}
-
-void FunctionEmptyArrayToSingle::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionEmptyArrayToSingle::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     if (FunctionEmptyArrayToSingleImpl::executeConst(block, arguments, result))
         return;
 
-    const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() +
-                        " of first argument of function " + getName(),
-                        ErrorCodes::ILLEGAL_COLUMN);
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
 
     ColumnPtr res_ptr = array->cloneEmpty();
     block.getByPosition(result).column = res_ptr;
-    ColumnArray &res = static_cast<ColumnArray &>(*res_ptr);
+    ColumnArray & res = static_cast<ColumnArray &>(*res_ptr);
 
-    const IColumn &src_data = array->getData();
-    const ColumnArray::Offsets_t &src_offsets = array->getOffsets();
-    IColumn &res_data = res.getData();
-    ColumnArray::Offsets_t &res_offsets = res.getOffsets();
+    const IColumn & src_data = array->getData();
+    const ColumnArray::Offsets_t & src_offsets = array->getOffsets();
+    IColumn & res_data = res.getData();
+    ColumnArray::Offsets_t & res_offsets = res.getOffsets();
 
-    const NullMap *src_null_map = nullptr;
-    NullMap *res_null_map = nullptr;
+    const NullMap * src_null_map = nullptr;
+    NullMap * res_null_map = nullptr;
 
-    const IColumn *inner_col;
-    IColumn *inner_res_col;
+    const IColumn * inner_col;
+    IColumn * inner_res_col;
 
     bool nullable = src_data.isNullable();
     if (nullable)
@@ -2342,11 +2284,9 @@ void FunctionEmptyArrayToSingle::executeImpl(Block &block, const ColumnNumbers &
     }
 
     if (nullable)
-        FunctionEmptyArrayToSingleImpl::executeDispatch<true>(*inner_col, src_offsets, *inner_res_col, res_offsets,
-                                                              src_null_map, res_null_map);
+        FunctionEmptyArrayToSingleImpl::executeDispatch<true>(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map);
     else
-        FunctionEmptyArrayToSingleImpl::executeDispatch<false>(*inner_col, src_offsets, *inner_res_col, res_offsets,
-                                                               src_null_map, res_null_map);
+        FunctionEmptyArrayToSingleImpl::executeDispatch<false>(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map);
 }
 
 
@@ -2357,7 +2297,7 @@ String FunctionRange::getName() const
     return name;
 }
 
-DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes & arguments) const
 {
     const auto arg = arguments.front().get();
 
@@ -2367,48 +2307,47 @@ DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes &arguments) const
         !checkDataType<DataTypeUInt64>(arg))
     {
         throw Exception{
-                "Illegal type " + arg->getName() + " of argument of function " + getName(),
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            "Illegal type " + arg->getName() + " of argument of function " + getName(),
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
     }
 
     return std::make_shared<DataTypeArray>(arg->clone());
 }
 
-template<typename T>
-bool FunctionRange::executeInternal(Block &block, const IColumn *arg, const size_t result)
+template <typename T>
+bool FunctionRange::executeInternal(Block & block, const IColumn * arg, const size_t result)
 {
     static constexpr size_t max_elements = 100'000'000;
 
     if (const auto in = checkAndGetColumn<ColumnVector<T>>(arg))
     {
-        const auto &in_data = in->getData();
+        const auto & in_data = in->getData();
         const auto total_values = std::accumulate(std::begin(in_data), std::end(in_data), size_t{},
-                                                  [this](const size_t lhs, const size_t rhs)
-                                                  {
-                                                      const auto sum = lhs + rhs;
-                                                      if (sum < lhs)
-                                                          throw Exception{
-                                                                  "A call to function " + getName() +
-                                                                  " overflows, investigate the values of arguments you are passing",
-                                                                  ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+            [this] (const size_t lhs, const size_t rhs)
+            {
+                const auto sum = lhs + rhs;
+                if (sum < lhs)
+                    throw Exception{
+                        "A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
+                        ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
-                                                      return sum;
-                                                  });
+                return sum;
+            });
 
         if (total_values > max_elements)
             throw Exception{
-                    "A call to function " + getName() + " would produce " + std::to_string(total_values) +
+                "A call to function " + getName() + " would produce " + std::to_string(total_values) +
                     " array elements, which is greater than the allowed maximum of " + std::to_string(max_elements),
-                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
         const auto out = std::make_shared<ColumnArray>(
-                data_col,
-                std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
+            data_col,
+            std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
         block.getByPosition(result).column = out;
 
-        auto &out_data = data_col->getData();
-        auto &out_offsets = out->getOffsets();
+        auto & out_data = data_col->getData();
+        auto & out_offsets = out->getOffsets();
 
         IColumn::Offset_t offset{};
         for (size_t row_idx = 0, rows = in->size(); row_idx < rows; ++row_idx)
@@ -2427,25 +2366,24 @@ bool FunctionRange::executeInternal(Block &block, const IColumn *arg, const size
         T in_data = in->template getValue<T>();
         if ((in_data != 0) && (in->size() > (std::numeric_limits<size_t>::max() / in_data)))
             throw Exception{
-                    "A call to function " + getName() +
-                    " overflows, investigate the values of arguments you are passing",
-                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                "A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
+                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const size_t total_values = in->size() * in_data;
         if (total_values > max_elements)
             throw Exception{
-                    "A call to function " + getName() + " would produce " + toString(total_values) +
+                "A call to function " + getName() + " would produce " + toString(total_values) +
                     " array elements, which is greater than the allowed maximum of " + toString(max_elements),
-                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
         const auto out = std::make_shared<ColumnArray>(
-                data_col,
-                std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
+            data_col,
+            std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
         block.getByPosition(result).column = out;
 
-        auto &out_data = data_col->getData();
-        auto &out_offsets = out->getOffsets();
+        auto & out_data = data_col->getData();
+        auto & out_offsets = out->getOffsets();
 
         IColumn::Offset_t offset{};
         for (size_t row_idx = 0, rows = in->size(); row_idx < rows; ++row_idx)
@@ -2463,7 +2401,7 @@ bool FunctionRange::executeInternal(Block &block, const IColumn *arg, const size
         return false;
 }
 
-void FunctionRange::executeImpl(Block &block, const ColumnNumbers &arguments, const size_t result)
+void FunctionRange::executeImpl(Block & block, const ColumnNumbers & arguments, const size_t result)
 {
     const auto col = block.getByPosition(arguments[0]).column.get();
 
@@ -2473,15 +2411,15 @@ void FunctionRange::executeImpl(Block &block, const ColumnNumbers &arguments, co
         !executeInternal<UInt64>(block, col, result))
     {
         throw Exception{
-                "Illegal column " + col->getName() + " of argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN
+            "Illegal column " + col->getName() + " of argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN
         };
     }
 }
 
 /// Implementation of FunctionArrayReverse.
 
-FunctionPtr FunctionArrayReverse::create(const Context &context)
+FunctionPtr FunctionArrayReverse::create(const Context & context)
 {
     return std::make_shared<FunctionArrayReverse>();
 }
@@ -2491,41 +2429,40 @@ String FunctionArrayReverse::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayReverse::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayReverse::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("Argument for function " + getName() + " must be array.",
-                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return arguments[0]->clone();
 }
 
-void FunctionArrayReverse::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayReverse::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     if (executeConst(block, arguments, result))
         return;
 
-    const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() +
-                        " of first argument of function " + getName(),
-                        ErrorCodes::ILLEGAL_COLUMN);
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
 
     ColumnPtr res_ptr = array->cloneEmpty();
     block.getByPosition(result).column = res_ptr;
-    ColumnArray &res = static_cast<ColumnArray &>(*res_ptr);
+    ColumnArray & res = static_cast<ColumnArray &>(*res_ptr);
 
-    const IColumn &src_data = array->getData();
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
-    IColumn &res_data = res.getData();
+    const IColumn & src_data = array->getData();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    IColumn & res_data = res.getData();
     res.getOffsetsColumn() = array->getOffsetsColumn();
 
-    const ColumnNullable *nullable_col = nullptr;
-    ColumnNullable *nullable_res_col = nullptr;
+    const ColumnNullable * nullable_col = nullptr;
+    ColumnNullable * nullable_res_col = nullptr;
 
-    const IColumn *inner_col;
-    IColumn *inner_res_col;
+    const IColumn * inner_col;
+    IColumn * inner_res_col;
 
     if (src_data.isNullable())
     {
@@ -2541,27 +2478,26 @@ void FunctionArrayReverse::executeImpl(Block &block, const ColumnNumbers &argume
         inner_res_col = &res_data;
     }
 
-    if (!(executeNumber<UInt8>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<UInt16>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<UInt32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<UInt64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Int8>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Int16>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Int32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Int64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Float32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Float64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeString(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeFixedString(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)))
+    if (!(    executeNumber<UInt8>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<UInt16>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<UInt32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<UInt64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Int8>        (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Int16>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Int32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Int64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Float32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Float64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeString            (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeFixedString        (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)))
         throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                        + " of first argument of function " + getName(),
-                        ErrorCodes::ILLEGAL_COLUMN);
+            + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
 }
 
-bool FunctionArrayReverse::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
+bool FunctionArrayReverse::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    if (const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
-            block.getByPosition(arguments[0]).column.get()))
+    if (const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
     {
         Array arr = const_array->getValue<Array>();
 
@@ -2579,22 +2515,22 @@ bool FunctionArrayReverse::executeConst(Block &block, const ColumnNumbers &argum
         return false;
 }
 
-template<typename T>
+template <typename T>
 bool FunctionArrayReverse::executeNumber(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data_col,
-        const ColumnNullable *nullable_col,
-        ColumnNullable *nullable_res_col)
+    const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+    IColumn & res_data_col,
+    const ColumnNullable * nullable_col,
+    ColumnNullable * nullable_res_col)
 {
-    auto do_reverse = [](const auto &src_data, const auto &src_offsets, auto &res_data)
+    auto do_reverse = [](const auto & src_data, const auto & src_offsets, auto & res_data)
     {
         size_t size = src_offsets.size();
         ColumnArray::Offset_t src_prev_offset = 0;
 
         for (size_t i = 0; i < size; ++i)
         {
-            const auto *src = &src_data[src_prev_offset];
-            const auto *src_end = &src_data[src_offsets[i]];
+            const auto * src = &src_data[src_prev_offset];
+            const auto * src_end = &src_data[src_offsets[i]];
 
             if (src == src_end)
                 continue;
@@ -2612,18 +2548,18 @@ bool FunctionArrayReverse::executeNumber(
         }
     };
 
-    if (const ColumnVector<T> *src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
+    if (const ColumnVector<T> * src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
     {
-        const PaddedPODArray<T> &src_data = src_data_concrete->getData();
-        PaddedPODArray<T> &res_data = typeid_cast<ColumnVector<T> &>(res_data_col).getData();
+        const PaddedPODArray<T> & src_data = src_data_concrete->getData();
+        PaddedPODArray<T> & res_data = typeid_cast<ColumnVector<T> &>(res_data_col).getData();
         res_data.resize(src_data.size());
         do_reverse(src_data, src_offsets, res_data);
 
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_data.size());
             do_reverse(src_null_map, src_offsets, res_null_map);
         }
@@ -2635,16 +2571,16 @@ bool FunctionArrayReverse::executeNumber(
 }
 
 bool FunctionArrayReverse::executeFixedString(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data_col,
-        const ColumnNullable *nullable_col,
-        ColumnNullable *nullable_res_col)
+    const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+    IColumn & res_data_col,
+    const ColumnNullable * nullable_col,
+    ColumnNullable * nullable_res_col)
 {
-    if (const ColumnFixedString *src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
+    if (const ColumnFixedString * src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
     {
         const size_t n = src_data_concrete->getN();
-        const ColumnFixedString::Chars_t &src_data = src_data_concrete->getChars();
-        ColumnFixedString::Chars_t &res_data = typeid_cast<ColumnFixedString &>(res_data_col).getChars();
+        const ColumnFixedString::Chars_t & src_data = src_data_concrete->getChars();
+        ColumnFixedString::Chars_t & res_data = typeid_cast<ColumnFixedString &>(res_data_col).getChars();
         size_t size = src_offsets.size();
         res_data.resize(src_data.size());
 
@@ -2652,13 +2588,13 @@ bool FunctionArrayReverse::executeFixedString(
 
         for (size_t i = 0; i < size; ++i)
         {
-            const UInt8 *src = &src_data[src_prev_offset * n];
-            const UInt8 *src_end = &src_data[src_offsets[i] * n];
+            const UInt8 * src = &src_data[src_prev_offset * n];
+            const UInt8 * src_end = &src_data[src_offsets[i] * n];
 
             if (src == src_end)
                 continue;
 
-            UInt8 *dst = &res_data[src_offsets[i] * n - n];
+            UInt8 * dst = &res_data[src_offsets[i] * n - n];
 
             while (src < src_end)
             {
@@ -2674,21 +2610,21 @@ bool FunctionArrayReverse::executeFixedString(
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_null_map.size());
 
             ColumnArray::Offset_t src_prev_offset = 0;
 
             for (size_t i = 0; i < size; ++i)
             {
-                const UInt8 *src = &src_null_map[src_prev_offset];
-                const UInt8 *src_end = &src_null_map[src_offsets[i]];
+                const UInt8 * src = &src_null_map[src_prev_offset];
+                const UInt8 * src_end = &src_null_map[src_offsets[i]];
 
                 if (src == src_end)
                     continue;
 
-                UInt8 *dst = &res_null_map[src_offsets[i] - 1];
+                UInt8 * dst = &res_null_map[src_offsets[i] - 1];
 
                 while (src < src_end)
                 {
@@ -2708,18 +2644,18 @@ bool FunctionArrayReverse::executeFixedString(
 }
 
 bool FunctionArrayReverse::executeString(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
-        IColumn &res_data_col,
-        const ColumnNullable *nullable_col,
-        ColumnNullable *nullable_res_col)
+    const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
+    IColumn & res_data_col,
+    const ColumnNullable * nullable_col,
+    ColumnNullable * nullable_res_col)
 {
-    if (const ColumnString *src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+    if (const ColumnString * src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
     {
-        const ColumnString::Offsets_t &src_string_offsets = src_data_concrete->getOffsets();
-        ColumnString::Offsets_t &res_string_offsets = typeid_cast<ColumnString &>(res_data_col).getOffsets();
+        const ColumnString::Offsets_t & src_string_offsets = src_data_concrete->getOffsets();
+        ColumnString::Offsets_t & res_string_offsets = typeid_cast<ColumnString &>(res_data_col).getOffsets();
 
-        const ColumnString::Chars_t &src_data = src_data_concrete->getChars();
-        ColumnString::Chars_t &res_data = typeid_cast<ColumnString &>(res_data_col).getChars();
+        const ColumnString::Chars_t & src_data = src_data_concrete->getChars();
+        ColumnString::Chars_t & res_data = typeid_cast<ColumnString &>(res_data_col).getChars();
 
         size_t size = src_array_offsets.size();
         res_string_offsets.resize(src_string_offsets.size());
@@ -2738,13 +2674,10 @@ bool FunctionArrayReverse::executeString(
                 {
                     size_t j_reversed = array_size - j - 1;
 
-                    auto src_pos =
-                            src_array_prev_offset + j_reversed == 0 ? 0 : src_string_offsets[src_array_prev_offset +
-                                                                                             j_reversed - 1];
+                    auto src_pos = src_array_prev_offset + j_reversed == 0 ? 0 : src_string_offsets[src_array_prev_offset + j_reversed - 1];
                     size_t string_size = src_string_offsets[src_array_prev_offset + j_reversed] - src_pos;
 
-                    memcpySmallAllowReadWriteOverflow15(&res_data[res_string_prev_offset], &src_data[src_pos],
-                                                        string_size);
+                    memcpySmallAllowReadWriteOverflow15(&res_data[res_string_prev_offset], &src_data[src_pos], string_size);
 
                     res_string_prev_offset += string_size;
                     res_string_offsets[src_array_prev_offset + j] = res_string_prev_offset;
@@ -2757,8 +2690,8 @@ bool FunctionArrayReverse::executeString(
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_string_offsets.size());
 
             size_t size = src_string_offsets.size();
@@ -2766,8 +2699,8 @@ bool FunctionArrayReverse::executeString(
 
             for (size_t i = 0; i < size; ++i)
             {
-                const auto *src = &src_null_map[src_prev_offset];
-                const auto *src_end = &src_null_map[src_array_offsets[i]];
+                const auto * src = &src_null_map[src_prev_offset];
+                const auto * src_end = &src_null_map[src_array_offsets[i]];
 
                 if (src == src_end)
                     continue;
@@ -2793,7 +2726,7 @@ bool FunctionArrayReverse::executeString(
 
 /// Implementation of FunctionArrayReduce.
 
-FunctionPtr FunctionArrayReduce::create(const Context &context)
+FunctionPtr FunctionArrayReduce::create(const Context & context)
 {
     return std::make_shared<FunctionArrayReduce>();
 }
@@ -2804,32 +2737,30 @@ String FunctionArrayReduce::getName() const
 }
 
 void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
-        const ColumnsWithTypeAndName &arguments,
-        DataTypePtr &out_return_type,
-        std::vector<ExpressionAction> &out_prerequisites)
+    const ColumnsWithTypeAndName & arguments,
+    DataTypePtr & out_return_type,
+    std::vector<ExpressionAction> & out_prerequisites)
 {
     /// The first argument is a constant string with the name of the aggregate function
     ///  (possibly with parameters in parentheses, for example: "quantile(0.99)").
 
     if (arguments.size() < 2)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-                        + toString(arguments.size()) + ", should be at least 2.",
-                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+            + toString(arguments.size()) + ", should be at least 2.",
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-    const ColumnConst *aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
+    const ColumnConst * aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
     if (!aggregate_function_name_column)
-        throw Exception(
-                "First argument for function " + getName() + " must be constant string: name of aggregate function.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("First argument for function " + getName() + " must be constant string: name of aggregate function.",
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     DataTypes argument_types(arguments.size() - 1);
     for (size_t i = 1, size = arguments.size(); i < size; ++i)
     {
-        const DataTypeArray *arg = checkAndGetDataType<DataTypeArray>(arguments[i].type.get());
+        const DataTypeArray * arg = checkAndGetDataType<DataTypeArray>(arguments[i].type.get());
         if (!arg)
-            throw Exception(
-                    "Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
-                    + arguments[i].type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
+                + arguments[i].type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         argument_types[i - 1] = arg->getNestedType()->clone();
     }
@@ -2839,17 +2770,15 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
         String aggregate_function_name_with_params = aggregate_function_name_column->getValue<String>();
 
         if (aggregate_function_name_with_params.empty())
-            throw Exception(
-                    "First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
-                    ErrorCodes::BAD_ARGUMENTS);
+            throw Exception("First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
+                ErrorCodes::BAD_ARGUMENTS);
 
         String aggregate_function_name;
         Array params_row;
         getAggregateFunctionNameAndParametersArray(aggregate_function_name_with_params,
                                                    aggregate_function_name, params_row, "function " + getName());
 
-        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types,
-                                                                      params_row);
+        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types, params_row);
         if (!params_row.empty())
             aggregate_function->setParameters(params_row);
         aggregate_function->setArguments(argument_types);
@@ -2859,10 +2788,11 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
 }
 
 
-void FunctionArrayReduce::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+
+void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    IAggregateFunction &agg_func = *aggregate_function.get();
-    std::unique_ptr<char[]> place_holder{new char[agg_func.sizeOfData()]};
+    IAggregateFunction & agg_func = *aggregate_function.get();
+    std::unique_ptr<char[]> place_holder { new char[agg_func.sizeOfData()] };
     AggregateDataPtr place = place_holder.get();
 
     std::unique_ptr<Arena> arena = agg_func.allocatesMemoryInArena() ? std::make_unique<Arena>() : nullptr;
@@ -2878,31 +2808,30 @@ void FunctionArrayReduce::executeImpl(Block &block, const ColumnNumbers &argumen
 
     for (size_t i = 0, size = arguments.size() - 1; i < size; ++i)
     {
-        const IColumn *col = block.getByPosition(arguments[i + 1]).column.get();
-        if (const ColumnArray *arr = checkAndGetColumn<ColumnArray>(col))
+        const IColumn * col = block.getByPosition(arguments[i + 1]).column.get();
+        if (const ColumnArray * arr = checkAndGetColumn<ColumnArray>(col))
         {
             aggregate_arguments_vec[i] = arr->getDataPtr().get();
             is_const = false;
         }
-        else if (const ColumnConst *arr = checkAndGetColumnConst<ColumnArray>(col))
+        else if (const ColumnConst * arr = checkAndGetColumnConst<ColumnArray>(col))
         {
             materialized_columns.emplace_back(arr->convertToFullColumn());
             aggregate_arguments_vec[i] = typeid_cast<const ColumnArray &>(*materialized_columns.back().get()).getDataPtr().get();
         }
         else
-            throw Exception("Illegal column " + col->getName() + " as argument of function " + getName(),
-                            ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("Illegal column " + col->getName() + " as argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
 
     }
-    const IColumn **aggregate_arguments = aggregate_arguments_vec.data();
+    const IColumn ** aggregate_arguments = aggregate_arguments_vec.data();
 
-    const ColumnArray::Offsets_t &offsets = typeid_cast<const ColumnArray &>(!materialized_columns.empty()
-                                                                             ? *materialized_columns.front().get()
-                                                                             : *block.getByPosition(arguments[1]).column.get()).getOffsets();
+    const ColumnArray::Offsets_t & offsets = typeid_cast<const ColumnArray &>(!materialized_columns.empty()
+        ? *materialized_columns.front().get()
+        : *block.getByPosition(arguments[1]).column.get()).getOffsets();
 
 
     ColumnPtr result_holder = block.getByPosition(result).type->createColumn();
-    IColumn &res_col = *result_holder;
+    IColumn & res_col = *result_holder;
 
     /// AggregateFunction's states should be inserted into column using specific way
     auto res_col_aggregate_function = typeid_cast<ColumnAggregateFunction *>(&res_col);

From df0991286486182fb9bf00d5b108a85cbc4a1baa Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 20:07:58 +0300
Subject: [PATCH 28/30] reformated GatherUtils.cpp [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 33 ++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index 636fb8ad049..67966653fa7 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -11,7 +11,8 @@ struct ArraySourceCreator;
 template <typename Type, typename ... Types>
 struct ArraySourceCreator<Type, Types ...>
 {
-    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    static std::unique_ptr<IArraySource>
+    create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
     {
         if (typeid_cast<const ColumnVector<Type> *>(&col.getData()))
         {
@@ -33,7 +34,8 @@ struct ArraySourceCreator<Type, Types ...>
 template <>
 struct ArraySourceCreator<>
 {
-    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    static std::unique_ptr<IArraySource>
+    create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
     {
         if (null_map)
         {
@@ -118,11 +120,11 @@ struct ArraySourceSelector<Base, Type, Types ...>
     {
         if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
             Base::selectImpl(*array, args ...);
-        else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
+        else if (auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
             Base::selectImpl(*nullable_array, args ...);
         else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
             Base::selectImpl(*const_array, args ...);
-        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
+        else if (auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
             Base::selectImpl(*const_nullable_array, args ...);
         else
             ArraySourceSelector<Base, Types ...>::select(source, args ...);
@@ -137,11 +139,11 @@ struct ArraySourceSelector<Base>
     {
         if (auto array = typeid_cast<GenericArraySource *>(&source))
             Base::selectImpl(*array, args ...);
-        else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
+        else if (auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
             Base::selectImpl(*nullable_array, args ...);
         else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
             Base::selectImpl(*const_array, args ...);
-        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
+        else if (auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
             Base::selectImpl(*const_nullable_array, args ...);
         else
             throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
@@ -149,7 +151,8 @@ struct ArraySourceSelector<Base>
 };
 
 template <typename Base>
-using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector,
+        typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
 
 template <typename Base, typename ... Types>
 struct ArraySinkSelector;
@@ -185,7 +188,8 @@ struct ArraySinkSelector<Base>
 };
 
 template <typename Base>
-using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector,
+        typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
 
 template <typename Base>
 struct ArraySinkSourceSelector
@@ -269,7 +273,7 @@ static void NO_INLINE concatGenericArray(const std::vector<std::unique_ptr<IArra
 
     for (auto i : ext::range(0, sources.size()))
     {
-        const auto &source = sources[i];
+        const auto & source = sources[i];
         if (auto generic_source = typeid_cast<GenericArraySource *>(source.get()))
             generic_sources.push_back(static_cast<GenericArraySource *>(generic_source));
         else if (auto const_generic_source = typeid_cast<ConstSource<GenericArraySource> *>(source.get()))
@@ -288,8 +292,9 @@ static void NO_INLINE concatGenericArray(const std::vector<std::unique_ptr<IArra
             is_nullable[i] = is_const[i] = true;
         }
         else
-            throw Exception(std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
-                            ErrorCodes::LOGICAL_ERROR);
+            throw Exception(
+                    std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
+                    ErrorCodes::LOGICAL_ERROR);
     }
 
     while (!sink.isEnd())
@@ -339,17 +344,23 @@ void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources
         if (source->isConst())
         {
             for (size_t i : ext::range(1, offsets.size()))
+            {
                 sink.offsets[i] += offsets[0];
+            }
         }
         else
         {
             for (size_t i : ext::range(1, offsets.size()))
+            {
                 sink.offsets[i] += offsets[i - 1] - (i > 1 ? offsets[i - 2] : 0);
+            }
         }
     }
 
     for (auto i : ext::range(1, sink.offsets.size()))
+    {
         sink.offsets[i] += sink.offsets[i - 1];
+    }
 
     sink.reserve(elements_to_reserve);
 

From a88bb9375a009a05db53148f45ee6c01030db423 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 20:14:47 +0300
Subject: [PATCH 29/30] removed useless code from GatherUtils
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 1c011a747a7..6c4b3d4edcb 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -900,15 +900,8 @@ inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArr
     if (typeid(slice.elements) == typeid(&sink.elements))
         sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
     else
-    {
-        for (size_t i = 0; i < slice.size; ++i)
-        {
-            Field field;
-            slice.elements->get(slice.begin + i, field);
-            sink.elements.insert(field);
-        }
-    }
-    sink.current_offset += slice.size;
+        throw Exception("Function writeSlice expect same column types for GenericArraySlice and GenericArraySink.",
+                        ErrorCodes::LOGICAL_ERROR);
 }
 
 template <typename T>

From 463c05b33d636e0b33268720540d65bd82a8a4e5 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 20:16:48 +0300
Subject: [PATCH 30/30] fixed build [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index d8682a9d5b0..eea4410ca26 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -7,6 +7,7 @@
 #include <Functions/FunctionsConversion.h>
 #include <Functions/Conditional/getArrayType.h>
 #include <Functions/Conditional/CondException.h>
+#include <Functions/GatherUtils.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/HashTable/ClearableHashMap.h>
 #include <Parsers/ExpressionListParsers.h>