From df668d62978b9c9033b1c6b5d1968ac5e1cfda4e Mon Sep 17 00:00:00 2001
From: antikvist <artem.tsyganov@gmail.com>
Date: Thu, 18 Jun 2020 18:21:19 +0300
Subject: [PATCH 01/12] Rank Correlation

(cherry picked from commit 3009c3885ba6317e2a1518f94a1de92e1ef2b6ed)
(cherry picked from commit 024ff439e71f7164602f3e193a0c896dc1fa3fe7)
---
 .../AggregateFunctionRankCorr.cpp             |  59 ++++
 .../AggregateFunctionRankCorr.h               | 290 ++++++++++++++++++
 .../registerAggregateFunctions.cpp            |   1 +
 .../registerAggregateFunctions.h              |   1 +
 4 files changed, 351 insertions(+)
 create mode 100644 src/AggregateFunctions/AggregateFunctionRankCorr.cpp
 create mode 100644 src/AggregateFunctions/AggregateFunctionRankCorr.h

diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
new file mode 100644
index 00000000000..d3e7ecccee2
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
@@ -0,0 +1,59 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionRankCorr.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+#include "registerAggregateFunctions.h"
+
+#include <AggregateFunctions/Helpers.h>
+#include <DataTypes/DataTypeAggregateFunction.h>
+
+
+namespace ErrorCodes
+{
+extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+extern const int NOT_IMPLEMENTED;
+}
+
+namespace DB
+{
+
+namespace
+{
+
+AggregateFunctionPtr createAggregateFunctionRankCorr(const std::string & name,
+                                                       const DataTypes & argument_types,
+                                                       const Array & parameters)
+{
+    assertBinary(name, argument_types);
+    assertNoParameters(name, parameters);
+
+    AggregateFunctionPtr res;
+
+    if (isDecimal(argument_types[0]) || isDecimal(argument_types[1]))
+    {
+        throw Exception("Aggregate function " + name + " only supports numerical types.", ErrorCodes::NOT_IMPLEMENTED);
+    }
+
+    else
+    {
+        res.reset(createWithTwoNumericTypes<AggregateFunctionRankCorr>(*argument_types[0], *argument_types[1],
+                                                                         argument_types));
+    }
+
+
+    if (!res)
+    {
+        throw Exception("Aggregate function " + name + " only supports numerical types.", ErrorCodes::NOT_IMPLEMENTED);
+    }
+
+    return res;
+}
+
+}
+
+
+void registerAggregateFunctionRankCorr(AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("RankCorr", createAggregateFunctionRankCorr, AggregateFunctionFactory::CaseInsensitive);
+}
+
+}
\ No newline at end of file
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.h b/src/AggregateFunctions/AggregateFunctionRankCorr.h
new file mode 100644
index 00000000000..4d59f3dea16
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.h
@@ -0,0 +1,290 @@
+#pragma once
+
+#include <AggregateFunctions/IAggregateFunction.h>
+#include <Columns/ColumnArray.h>
+#include <Columns/ColumnVector.h>
+#include <Columns/ColumnTuple.h>
+#include <Common/assert_cast.h>
+#include <Common/FieldVisitors.h>
+#include <Core/Types.h>
+#include <DataTypes/DataTypesDecimal.h>
+#include <DataTypes/DataTypeNullable.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <IO/ReadHelpers.h>
+#include <IO/WriteHelpers.h>
+#include <limits>
+
+#include <DataTypes/DataTypeArray.h>
+#include <DataTypes/DataTypesNumber.h>
+
+
+#include <Common/ArenaAllocator.h>
+#include <Common/assert_cast.h>
+
+#include <type_traits>
+
+namespace ErrorCodes
+{
+extern const int BAD_ARGUMENTS;
+}
+
+namespace DB
+{
+
+template <template <typename> class Comparator>
+struct ComparePairFirst final
+{
+    template <typename X, typename Y>
+    bool operator()(const std::pair<X, Y> & lhs, const std::pair<X, Y> & rhs) const
+    {
+        return Comparator<X>{}(lhs.first, rhs.first);
+    }
+};
+
+
+template <template <typename> class Comparator>
+struct ComparePairSecond final
+{
+    template <typename X, typename Y>
+    bool operator()(const std::pair<X, Y> & lhs, const std::pair<X, Y> & rhs) const
+    {
+        return Comparator<Y>{}(lhs.second, rhs.second);
+    }
+};
+
+template <typename X = Float64, typename Y = Float64>
+struct AggregateFunctionRankCorrData final
+{
+    size_t size_x = 0;
+
+    using Allocator = MixedAlignedArenaAllocator<alignof(std::pair<X, Y>), 4096>;
+    using Array = PODArray<std::pair<X, Y>, 32, Allocator>;
+
+    Array values;
+};
+
+template <typename X = Float64, typename Y = Float64>
+class AggregateFunctionRankCorr : public
+                                         IAggregateFunctionDataHelper<
+                                             AggregateFunctionRankCorrData<X, Y>,
+                                             AggregateFunctionRankCorr<X, Y>
+                                         >
+{
+    using Data = AggregateFunctionRankCorrData<X, Y>;
+    using Allocator = MixedAlignedArenaAllocator<alignof(std::pair<Float64, Float64>), 4096>;
+    using Array = PODArray<std::pair<Float64, Float64>, 32, Allocator>;
+
+public:
+    AggregateFunctionRankCorr(
+        const DataTypes & arguments
+    ):
+        IAggregateFunctionDataHelper<
+            AggregateFunctionRankCorrData<X, Y>,
+            AggregateFunctionRankCorr<X, Y>
+        > ({arguments}, {})
+    {
+        // notice: arguments has been in factory
+    }
+
+    String getName() const override
+    {
+        return "RankCorr";
+    }
+
+    DataTypePtr getReturnType() const override
+    {
+        return std::make_shared<DataTypeNumber<Int8>>();
+    }
+
+    void insert(Data & a, const std::pair<X, Y> & x, Arena * arena) const
+    {
+        ++a.size_x;
+        a.values.push_back(x, arena);
+    }
+
+    void add(
+        AggregateDataPtr place,
+        const IColumn ** columns,
+        size_t row_num,
+        Arena * arena
+    ) const override
+    {
+        auto & a = this->data(place);
+
+        auto new_x = assert_cast<const ColumnVector<X> &>(*columns[0]).getData()[row_num];
+        auto new_y = assert_cast<const ColumnVector<Y> &>(*columns[1]).getData()[row_num];
+
+        auto new_arg = std::make_pair(new_x, new_y);
+
+        a.size_x += 1;
+
+        a.values.push_back(new_arg, arena);
+    }
+
+    void merge(
+        AggregateDataPtr place,
+        ConstAggregateDataPtr rhs,
+        Arena * arena
+    ) const override
+    {
+        auto & a = this->data(place);
+        auto & b = this->data(rhs);
+
+        if (b.size_x)
+        {
+            for (size_t i = 0; i < b.size_x; ++i)
+                insert(a, b.values[i], arena);
+        }
+    }
+
+    void serialize(
+        ConstAggregateDataPtr place,
+        WriteBuffer & buf
+    ) const override
+    {
+        const auto & value = this->data(place).values;
+        size_t size = this->data(place).size_x;
+        writeVarUInt(size, buf);
+        buf.write(reinterpret_cast<const char *>(value.data()), size * sizeof(value[0]));
+    }
+
+    void deserialize(
+        AggregateDataPtr place,
+        ReadBuffer & buf,
+        Arena * arena
+    ) const override
+    {
+        size_t size = 0;
+        readVarUInt(size, buf);
+
+        auto & value = this->data(place).values;
+
+        value.resize(size, arena);
+        buf.read(reinterpret_cast<char *>(value.data()), size * sizeof(value[0]));
+    }
+
+    void insertResultInto(
+        AggregateDataPtr place,
+        IColumn & to
+    ) const override
+    {
+        const auto & value = this->data(place).values;
+        size_t size = this->data(place).size_x;
+
+        if (size < 2)
+        {
+            throw Exception("Aggregate function " + getName() + " requires samples to be of size > 1", ErrorCodes::BAD_ARGUMENTS);
+        }
+
+        //create a copy of values not to format data
+        PODArrayWithStackMemory<std::pair<Float64, Float64>, 32> tmp_values;
+        tmp_values.resize(size);
+        for (size_t j = 0; j < size; ++ j){
+            tmp_values[j] = static_cast<std::pair<Float64, Float64>>(value[j]);
+        }
+
+//        size_t k = 1;
+//        if (k){
+//            throw Exception("passed making tmp array", ErrorCodes::BAD_ARGUMENTS);
+//        }
+
+        //sort x_values
+        std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairFirst<std::greater>{});
+
+        for (size_t j = 0; j < size; ){
+            //replace x_values with their ranks
+            size_t same = 1;
+            size_t cur_sum = 0;
+            size_t rank = j + 1;
+            size_t cur_start = j;
+
+            while (j < size - 1)
+            {
+                if (value[j].first == value[j + 1].first)
+                {
+                    // rank of (j + 1)th number
+                    rank += 1;
+                    same++;
+                    cur_sum += rank;
+                    j++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            // insert rank is calculated as average of ranks of equal values
+            Float64 insert_rank = static_cast<Float64>(cur_sum) / same;
+            for (size_t i = cur_start; i <= j; ++i) {
+                tmp_values[i].first = insert_rank;
+            }
+            j++;
+        }
+
+        //sort y_values
+        std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairSecond<std::greater>{});
+
+        //replace y_values with their ranks
+        for (size_t j = 0; j < size; ){
+            //replace x_values with their ranks
+            size_t same = 1;
+            size_t cur_sum = 0;
+            size_t rank = j + 1;
+            size_t cur_start = j;
+
+            while (j < size - 1)
+            {
+                if (value[j].second == value[j + 1].second)
+                {
+                    // rank of (j + 1)th number
+                    rank += 1;
+                    same++;
+                    cur_sum += rank;
+                    j++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            // insert rank is calculated as average of ranks of equal values
+            Float64 insert_rank = static_cast<Float64>(cur_sum) / same;
+            for (size_t i = cur_start; i <= j; ++i) {
+                tmp_values[i].second = insert_rank;
+            }
+            j++;
+        }
+
+        //count d^2 sum
+        Float64 answ = static_cast<Float64>(0);
+        for (size_t j = 0; j < size; ++ j)
+        {
+            answ += (tmp_values[j].first - tmp_values[j].second) * (tmp_values[j].first - tmp_values[j].second);
+        }
+
+        answ *= 6;
+        answ /= size * (size * size - 1);
+
+        answ = 1 - answ;
+
+        auto & column = static_cast<ColumnVector<Int8> &>(to);
+        if (answ > 0)
+        {
+            column.getData().push_back(static_cast<Int8>(1));
+        }
+        else if (answ < 0)
+        {
+            column.getData().push_back(static_cast<Int8>(-1));
+        }
+        else
+        {
+            column.getData().push_back(static_cast<Int8>(0));
+        }
+    }
+
+};
+
+};
\ No newline at end of file
diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp
index a8d0cf6e37c..ef6a392694f 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -45,6 +45,7 @@ void registerAggregateFunctions()
         registerAggregateFunctionMoving(factory);
         registerAggregateFunctionCategoricalIV(factory);
         registerAggregateFunctionAggThrow(factory);
+        registerAggregateFunctionRankCorr(factory);
     }
 
     {
diff --git a/src/AggregateFunctions/registerAggregateFunctions.h b/src/AggregateFunctions/registerAggregateFunctions.h
index 981273141f9..28fc9759fcf 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.h
+++ b/src/AggregateFunctions/registerAggregateFunctions.h
@@ -35,6 +35,7 @@ void registerAggregateFunctionSimpleLinearRegression(AggregateFunctionFactory &)
 void registerAggregateFunctionMoving(AggregateFunctionFactory &);
 void registerAggregateFunctionCategoricalIV(AggregateFunctionFactory &);
 void registerAggregateFunctionAggThrow(AggregateFunctionFactory &);
+void registerAggregateFunctionRankCorr(AggregateFunctionFactory &);
 
 class AggregateFunctionCombinatorFactory;
 void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory &);

From 098561def3251a5b2ec6181d6a32346d6df2dfa7 Mon Sep 17 00:00:00 2001
From: antikvist <artem.tsyganov@gmail.com>
Date: Thu, 18 Jun 2020 20:52:35 +0300
Subject: [PATCH 02/12] welch t-test

(cherry picked from commit 5cd118dcee91c2600d86048ab5bf641046a7ebae)
(cherry picked from commit 8f19270f8d8e75989b3154ec56f9ac43dffbfbc7)
---
 src/AggregateFunctions/AggregateFunctionRankCorr.cpp | 2 +-
 src/AggregateFunctions/AggregateFunctionRankCorr.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
index d3e7ecccee2..25ba9d55999 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
@@ -56,4 +56,4 @@ void registerAggregateFunctionRankCorr(AggregateFunctionFactory & factory)
     factory.registerFunction("RankCorr", createAggregateFunctionRankCorr, AggregateFunctionFactory::CaseInsensitive);
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.h b/src/AggregateFunctions/AggregateFunctionRankCorr.h
index 4d59f3dea16..49aa75b2f9a 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.h
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.h
@@ -287,4 +287,4 @@ public:
 
 };
 
-};
\ No newline at end of file
+};

From 950094c233ac61569f87ec6d184f438c4eaf4d9f Mon Sep 17 00:00:00 2001
From: antikvist <artem.tsyganov@gmail.com>
Date: Fri, 19 Jun 2020 00:20:30 +0300
Subject: [PATCH 03/12] rank correlation

(cherry picked from commit f9dda1e13ed301aa871941f654b9ba4d4b7d7d24)
(cherry picked from commit 2a7026cb0c859a44238e43291412003ce9ec4bef)
---
 .../AggregateFunctionRankCorr.h               | 31 +++++++++----------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.h b/src/AggregateFunctions/AggregateFunctionRankCorr.h
index 49aa75b2f9a..1f8b69e5ff5 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.h
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.h
@@ -16,11 +16,8 @@
 #include <limits>
 
 #include <DataTypes/DataTypeArray.h>
-#include <DataTypes/DataTypesNumber.h>
-
 
 #include <Common/ArenaAllocator.h>
-#include <Common/assert_cast.h>
 
 #include <type_traits>
 
@@ -180,23 +177,20 @@ public:
         //create a copy of values not to format data
         PODArrayWithStackMemory<std::pair<Float64, Float64>, 32> tmp_values;
         tmp_values.resize(size);
-        for (size_t j = 0; j < size; ++ j){
+        for (size_t j = 0; j < size; ++ j)
+        {
             tmp_values[j] = static_cast<std::pair<Float64, Float64>>(value[j]);
         }
 
-//        size_t k = 1;
-//        if (k){
-//            throw Exception("passed making tmp array", ErrorCodes::BAD_ARGUMENTS);
-//        }
-
         //sort x_values
         std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairFirst<std::greater>{});
 
-        for (size_t j = 0; j < size; ){
+        for (size_t j = 0; j < size; )
+        {
             //replace x_values with their ranks
-            size_t same = 1;
-            size_t cur_sum = 0;
             size_t rank = j + 1;
+            size_t same = 1;
+            size_t cur_sum = rank;
             size_t cur_start = j;
 
             while (j < size - 1)
@@ -217,7 +211,8 @@ public:
 
             // insert rank is calculated as average of ranks of equal values
             Float64 insert_rank = static_cast<Float64>(cur_sum) / same;
-            for (size_t i = cur_start; i <= j; ++i) {
+            for (size_t i = cur_start; i <= j; ++i)
+            {
                 tmp_values[i].first = insert_rank;
             }
             j++;
@@ -227,11 +222,12 @@ public:
         std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairSecond<std::greater>{});
 
         //replace y_values with their ranks
-        for (size_t j = 0; j < size; ){
+        for (size_t j = 0; j < size; )
+        {
             //replace x_values with their ranks
-            size_t same = 1;
-            size_t cur_sum = 0;
             size_t rank = j + 1;
+            size_t same = 1;
+            size_t cur_sum = rank;
             size_t cur_start = j;
 
             while (j < size - 1)
@@ -252,7 +248,8 @@ public:
 
             // insert rank is calculated as average of ranks of equal values
             Float64 insert_rank = static_cast<Float64>(cur_sum) / same;
-            for (size_t i = cur_start; i <= j; ++i) {
+            for (size_t i = cur_start; i <= j; ++i)
+            {
                 tmp_values[i].second = insert_rank;
             }
             j++;

From e32887d30071d6e8a9bb2377bd1eb792ce7dc7a4 Mon Sep 17 00:00:00 2001
From: antikvist <artem.tsyganov@gmail.com>
Date: Fri, 19 Jun 2020 06:21:48 +0300
Subject: [PATCH 04/12] rank corr

(cherry picked from commit 2815397a19a3149785f5a3dce7ef7e2e6b875708)
(cherry picked from commit d244797defb4ec3fcab7626e01ea42396703979b)
---
 src/AggregateFunctions/AggregateFunctionRankCorr.cpp | 1 -
 src/AggregateFunctions/AggregateFunctionRankCorr.h   | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
index 25ba9d55999..bd483ad5037 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
@@ -3,7 +3,6 @@
 #include <AggregateFunctions/FactoryHelpers.h>
 #include "registerAggregateFunctions.h"
 
-#include <AggregateFunctions/Helpers.h>
 #include <DataTypes/DataTypeAggregateFunction.h>
 
 
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.h b/src/AggregateFunctions/AggregateFunctionRankCorr.h
index 1f8b69e5ff5..c01f66a8b71 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.h
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.h
@@ -185,7 +185,7 @@ public:
         //sort x_values
         std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairFirst<std::greater>{});
 
-        for (size_t j = 0; j < size; )
+        for (size_t j = 0; j < size;)
         {
             //replace x_values with their ranks
             size_t rank = j + 1;
@@ -222,7 +222,7 @@ public:
         std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairSecond<std::greater>{});
 
         //replace y_values with their ranks
-        for (size_t j = 0; j < size; )
+        for (size_t j = 0; j < size;)
         {
             //replace x_values with their ranks
             size_t rank = j + 1;

From efc59d6686f0ea1da69713aa9683c7cb39e1fc0a Mon Sep 17 00:00:00 2001
From: antikvist <artem.tsyganov@gmail.com>
Date: Fri, 19 Jun 2020 07:57:39 +0300
Subject: [PATCH 05/12] rank corr

(cherry picked from commit 11c94bee69fe63b9a193928d8be2d91edcfba9b2)
(cherry picked from commit 483409f2e17b84c601ab3176d5a10633fb5a03c1)
---
 src/AggregateFunctions/AggregateFunctionRankCorr.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
index bd483ad5037..57d87a0bd81 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
@@ -2,7 +2,7 @@
 #include <AggregateFunctions/AggregateFunctionRankCorr.h>
 #include <AggregateFunctions/FactoryHelpers.h>
 #include "registerAggregateFunctions.h"
-
+#include <AggregateFunctions/Helpers.h>
 #include <DataTypes/DataTypeAggregateFunction.h>
 
 

From a6953444342efa3951e00300f6a3b565927a2141 Mon Sep 17 00:00:00 2001
From: antikvist <artem.tsyganov@gmail.com>
Date: Sat, 20 Jun 2020 19:18:23 +0300
Subject: [PATCH 06/12] rank corr

(cherry picked from commit 649e4dd913595124b0ee59c7aba645f5232baea4)
(cherry picked from commit ae17810201c0028c417fc0faab0ce1ebd8b6dcb1)
---
 src/AggregateFunctions/AggregateFunctionRankCorr.cpp | 1 -
 src/AggregateFunctions/AggregateFunctionRankCorr.h   | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
index 57d87a0bd81..8d836088607 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
@@ -8,7 +8,6 @@
 
 namespace ErrorCodes
 {
-extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
 extern const int NOT_IMPLEMENTED;
 }
 
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.h b/src/AggregateFunctions/AggregateFunctionRankCorr.h
index c01f66a8b71..8f1f176a1aa 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.h
+++ b/src/AggregateFunctions/AggregateFunctionRankCorr.h
@@ -195,7 +195,7 @@ public:
 
             while (j < size - 1)
             {
-                if (value[j].first == value[j + 1].first)
+                if (tmp_values[j].first == tmp_values[j + 1].first)
                 {
                     // rank of (j + 1)th number
                     rank += 1;
@@ -232,7 +232,7 @@ public:
 
             while (j < size - 1)
             {
-                if (value[j].second == value[j + 1].second)
+                if (tmp_values[j].second == tmp_values[j + 1].second)
                 {
                     // rank of (j + 1)th number
                     rank += 1;

From eee19dada4b1451594c32fd137e246dbf0c0cfdb Mon Sep 17 00:00:00 2001
From: Nikita Mikhaylov <mikhaylovnikitka@gmail.com>
Date: Mon, 24 Aug 2020 22:49:55 +0300
Subject: [PATCH 07/12] fixes + test

(cherry picked from commit 5daee1cae199816a4f3e8fbc466a8974999b772e)
(cherry picked from commit c3dfb8e83844ae73c1a9879fbc9b0d9353bfbb6d)
---
 .../AggregateFunctionRankCorr.cpp             | 57 -------------
 ...gregateFunctionRankCorrelationSpearman.cpp | 41 ++++++++++
 ...ggregateFunctionRankCorrelationSpearman.h} | 81 +++++--------------
 .../registerAggregateFunctions.cpp            |  2 +-
 .../registerAggregateFunctions.h              |  2 +-
 .../01455_rank_correlation_spearman.reference | 10 +++
 .../01455_rank_correlation_spearman.sql       | 29 +++++++
 7 files changed, 104 insertions(+), 118 deletions(-)
 delete mode 100644 src/AggregateFunctions/AggregateFunctionRankCorr.cpp
 create mode 100644 src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.cpp
 rename src/AggregateFunctions/{AggregateFunctionRankCorr.h => AggregateFunctionRankCorrelationSpearman.h} (74%)
 create mode 100644 tests/queries/0_stateless/01455_rank_correlation_spearman.reference
 create mode 100644 tests/queries/0_stateless/01455_rank_correlation_spearman.sql

diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp b/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
deleted file mode 100644
index 8d836088607..00000000000
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <AggregateFunctions/AggregateFunctionFactory.h>
-#include <AggregateFunctions/AggregateFunctionRankCorr.h>
-#include <AggregateFunctions/FactoryHelpers.h>
-#include "registerAggregateFunctions.h"
-#include <AggregateFunctions/Helpers.h>
-#include <DataTypes/DataTypeAggregateFunction.h>
-
-
-namespace ErrorCodes
-{
-extern const int NOT_IMPLEMENTED;
-}
-
-namespace DB
-{
-
-namespace
-{
-
-AggregateFunctionPtr createAggregateFunctionRankCorr(const std::string & name,
-                                                       const DataTypes & argument_types,
-                                                       const Array & parameters)
-{
-    assertBinary(name, argument_types);
-    assertNoParameters(name, parameters);
-
-    AggregateFunctionPtr res;
-
-    if (isDecimal(argument_types[0]) || isDecimal(argument_types[1]))
-    {
-        throw Exception("Aggregate function " + name + " only supports numerical types.", ErrorCodes::NOT_IMPLEMENTED);
-    }
-
-    else
-    {
-        res.reset(createWithTwoNumericTypes<AggregateFunctionRankCorr>(*argument_types[0], *argument_types[1],
-                                                                         argument_types));
-    }
-
-
-    if (!res)
-    {
-        throw Exception("Aggregate function " + name + " only supports numerical types.", ErrorCodes::NOT_IMPLEMENTED);
-    }
-
-    return res;
-}
-
-}
-
-
-void registerAggregateFunctionRankCorr(AggregateFunctionFactory & factory)
-{
-    factory.registerFunction("RankCorr", createAggregateFunctionRankCorr, AggregateFunctionFactory::CaseInsensitive);
-}
-
-}
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.cpp b/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.cpp
new file mode 100644
index 00000000000..277aea715d3
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.cpp
@@ -0,0 +1,41 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionRankCorrelationSpearman.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+#include "registerAggregateFunctions.h"
+#include <AggregateFunctions/Helpers.h>
+
+
+namespace ErrorCodes
+{
+extern const int NOT_IMPLEMENTED;
+}
+
+namespace DB
+{
+
+namespace
+{
+
+AggregateFunctionPtr createAggregateFunctionRankCorrelationSpearman(const std::string & name, const DataTypes & argument_types, const Array & parameters)
+{
+    assertBinary(name, argument_types);
+    assertNoParameters(name, parameters);
+
+    if (isDecimal(argument_types[0]) || isDecimal(argument_types[1]))
+    {
+        throw Exception("Aggregate function " + name + " only supports numerical types.", ErrorCodes::NOT_IMPLEMENTED);
+    }
+
+    AggregateFunctionPtr res(createWithTwoNumericTypes<AggregateFunctionRankCorrelationSpearman>(*argument_types[0], *argument_types[1], argument_types));
+    return res;
+}
+
+}
+
+
+void registerAggregateFunctionRankCorrelationSpearman (AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("rankCorrelationSpearman", createAggregateFunctionRankCorrelationSpearman, AggregateFunctionFactory::CaseInsensitive);
+}
+
+}
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorr.h b/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.h
similarity index 74%
rename from src/AggregateFunctions/AggregateFunctionRankCorr.h
rename to src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.h
index 8f1f176a1aa..f4c680bd10b 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorr.h
+++ b/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.h
@@ -51,7 +51,7 @@ struct ComparePairSecond final
 };
 
 template <typename X = Float64, typename Y = Float64>
-struct AggregateFunctionRankCorrData final
+struct AggregateFunctionRankCorrelationSpearmanData final
 {
     size_t size_x = 0;
 
@@ -61,37 +61,29 @@ struct AggregateFunctionRankCorrData final
     Array values;
 };
 
-template <typename X = Float64, typename Y = Float64>
-class AggregateFunctionRankCorr : public
-                                         IAggregateFunctionDataHelper<
-                                             AggregateFunctionRankCorrData<X, Y>,
-                                             AggregateFunctionRankCorr<X, Y>
-                                         >
+template <typename X, typename Y>
+class AggregateFunctionRankCorrelationSpearman :
+    public IAggregateFunctionDataHelper<AggregateFunctionRankCorrelationSpearmanData<X, Y>, AggregateFunctionRankCorrelationSpearman<X, Y>>
 {
-    using Data = AggregateFunctionRankCorrData<X, Y>;
+    using Data = AggregateFunctionRankCorrelationSpearmanData<X, Y>;
     using Allocator = MixedAlignedArenaAllocator<alignof(std::pair<Float64, Float64>), 4096>;
     using Array = PODArray<std::pair<Float64, Float64>, 32, Allocator>;
 
 public:
-    AggregateFunctionRankCorr(
-        const DataTypes & arguments
-    ):
-        IAggregateFunctionDataHelper<
-            AggregateFunctionRankCorrData<X, Y>,
-            AggregateFunctionRankCorr<X, Y>
-        > ({arguments}, {})
+    explicit AggregateFunctionRankCorrelationSpearman(const DataTypes & arguments)
+        :IAggregateFunctionDataHelper<AggregateFunctionRankCorrelationSpearmanData<X, Y>,AggregateFunctionRankCorrelationSpearman<X, Y>> ({arguments}, {})
     {
         // notice: arguments has been in factory
     }
 
     String getName() const override
     {
-        return "RankCorr";
+        return "rankCorrelationSpearman";
     }
 
     DataTypePtr getReturnType() const override
     {
-        return std::make_shared<DataTypeNumber<Int8>>();
+        return std::make_shared<DataTypeNumber<Float64>>();
     }
 
     void insert(Data & a, const std::pair<X, Y> & x, Arena * arena) const
@@ -100,12 +92,7 @@ public:
         a.values.push_back(x, arena);
     }
 
-    void add(
-        AggregateDataPtr place,
-        const IColumn ** columns,
-        size_t row_num,
-        Arena * arena
-    ) const override
+    void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const override
     {
         auto & a = this->data(place);
 
@@ -119,11 +106,7 @@ public:
         a.values.push_back(new_arg, arena);
     }
 
-    void merge(
-        AggregateDataPtr place,
-        ConstAggregateDataPtr rhs,
-        Arena * arena
-    ) const override
+    void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const override
     {
         auto & a = this->data(place);
         auto & b = this->data(rhs);
@@ -135,10 +118,7 @@ public:
         }
     }
 
-    void serialize(
-        ConstAggregateDataPtr place,
-        WriteBuffer & buf
-    ) const override
+    void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
     {
         const auto & value = this->data(place).values;
         size_t size = this->data(place).size_x;
@@ -146,11 +126,7 @@ public:
         buf.write(reinterpret_cast<const char *>(value.data()), size * sizeof(value[0]));
     }
 
-    void deserialize(
-        AggregateDataPtr place,
-        ReadBuffer & buf,
-        Arena * arena
-    ) const override
+    void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena * arena) const override
     {
         size_t size = 0;
         readVarUInt(size, buf);
@@ -161,10 +137,7 @@ public:
         buf.read(reinterpret_cast<char *>(value.data()), size * sizeof(value[0]));
     }
 
-    void insertResultInto(
-        AggregateDataPtr place,
-        IColumn & to
-    ) const override
+    void insertResultInto(AggregateDataPtr place, IColumn & to, Arena * /*arena*/) const override
     {
         const auto & value = this->data(place).values;
         size_t size = this->data(place).size_x;
@@ -256,30 +229,20 @@ public:
         }
 
         //count d^2 sum
-        Float64 answ = static_cast<Float64>(0);
+        Float64 answer = static_cast<Float64>(0);
         for (size_t j = 0; j < size; ++ j)
         {
-            answ += (tmp_values[j].first - tmp_values[j].second) * (tmp_values[j].first - tmp_values[j].second);
+            answer += (tmp_values[j].first - tmp_values[j].second) * (tmp_values[j].first - tmp_values[j].second);
         }
 
-        answ *= 6;
-        answ /= size * (size * size - 1);
+        answer *= 6;
+        answer /= size * (size * size - 1);
 
-        answ = 1 - answ;
+        answer = 1 - answer;
 
-        auto & column = static_cast<ColumnVector<Int8> &>(to);
-        if (answ > 0)
-        {
-            column.getData().push_back(static_cast<Int8>(1));
-        }
-        else if (answ < 0)
-        {
-            column.getData().push_back(static_cast<Int8>(-1));
-        }
-        else
-        {
-            column.getData().push_back(static_cast<Int8>(0));
-        }
+        auto & column = static_cast<ColumnVector<Float64> &>(to);
+        column.getData().push_back(answer);
+        std::cout << "AAAA" << std::endl;
     }
 
 };
diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp
index ef6a392694f..a77a156a52b 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -45,7 +45,7 @@ void registerAggregateFunctions()
         registerAggregateFunctionMoving(factory);
         registerAggregateFunctionCategoricalIV(factory);
         registerAggregateFunctionAggThrow(factory);
-        registerAggregateFunctionRankCorr(factory);
+        registerAggregateFunctionRankCorrelationSpearman(factory);
     }
 
     {
diff --git a/src/AggregateFunctions/registerAggregateFunctions.h b/src/AggregateFunctions/registerAggregateFunctions.h
index 28fc9759fcf..87852be78c0 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.h
+++ b/src/AggregateFunctions/registerAggregateFunctions.h
@@ -35,7 +35,7 @@ void registerAggregateFunctionSimpleLinearRegression(AggregateFunctionFactory &)
 void registerAggregateFunctionMoving(AggregateFunctionFactory &);
 void registerAggregateFunctionCategoricalIV(AggregateFunctionFactory &);
 void registerAggregateFunctionAggThrow(AggregateFunctionFactory &);
-void registerAggregateFunctionRankCorr(AggregateFunctionFactory &);
+void registerAggregateFunctionRankCorrelationSpearman(AggregateFunctionFactory &);
 
 class AggregateFunctionCombinatorFactory;
 void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory &);
diff --git a/tests/queries/0_stateless/01455_rank_correlation_spearman.reference b/tests/queries/0_stateless/01455_rank_correlation_spearman.reference
new file mode 100644
index 00000000000..67619b38acb
--- /dev/null
+++ b/tests/queries/0_stateless/01455_rank_correlation_spearman.reference
@@ -0,0 +1,10 @@
+1
+1
+-1
+-1
+-0.037
+-0.037
+-0.108
+-0.108
+0.286
+0.286
\ No newline at end of file
diff --git a/tests/queries/0_stateless/01455_rank_correlation_spearman.sql b/tests/queries/0_stateless/01455_rank_correlation_spearman.sql
new file mode 100644
index 00000000000..479399e1b41
--- /dev/null
+++ b/tests/queries/0_stateless/01455_rank_correlation_spearman.sql
@@ -0,0 +1,29 @@
+CREATE DATABASE IF NOT EXISTS db_01455_rank_correlation;
+USE db_01455_rank_correlation;
+DROP TABLE IF EXISTS moons;
+DROP TABLE IF EXISTS circles;
+
+SELECT '1';
+SELECT rankCorrelationSpearman(number, number) FROM numbers(100);
+
+SELECT '-1';
+SELECT rankCorrelationSpearman(number, -1 * number) FROM numbers(100);
+
+SELECT '-0.037';
+SELECT roundBankers(rankCorrelationSpearman(exp(number), sin(number)), 3) FROM numbers(100);
+
+CREATE TABLE moons(a Float64, b Float64) Engine=Memory();
+INSERT INTO moons VALUES (1.230365,1.291454), (1.93851,0.6499), (1.574085,0.744109), (1.416457,1.41872), (1.90165,1.298199), (2.023844,1.142459), (1.828602,0.636404), (1.568649,1.157387), (1.968863,1.160039), (1.790198,0.860815), (1.238993,0.252486), (1.690338,0.573545), (1.678741,0.739649), (1.363346,0.514698), (1.924442,0.484331), (0.849071,0.585017), (1.859407,1.098124), (1.657176,1.314958), (1.085181,0.761741), (1.184481,0.639135), (1.59856,0.688384), (1.304818,1.212579), (1.913821,0.663551), (1.872619,0.510627), (1.29273,0.795267), (1.767669,0.892397), (1.790311,1.21813), (1.621893,1.229768), (1.525505,0.752643), (1.513535,1.016012), (1.120456,1.427238), (1.71505,0.716654), (1.394756,0.733629), (1.746027,1.422821), (1.5376,1.387397), (1.358968,0.575393), (1.941569,0.572639), (1.904995,0.966926), (1.967455,0.436449), (2.045535,0.582434), (1.365599,0.446582), (2.035874,0.468542), (1.419283,0.739308), (1.718267,0.895579), (1.285871,1.014628), (2.010657,1.631207), (1.78226,0.576882), (1.78274,0.727585), (1.454934,1.285701), (1.657208,0.581418);
+SELECT '-0.108';
+SELECT roundBankers(rankCorrelationSpearman(a, b), 3) from moons;
+
+CREATE TABLE circles(a Float64, b Float64) Engine=Memory();
+INSERT INTO circles VALUES (1.20848,0.505643), (1.577706,1.726383), (1.945215,1.638926), (0.493616,0.792443), (0.827802,1.41133), (1.012179,1.654582), (1.815329,0.254426), (-0.068102,1.456476), (1.235432,1.565291), (1.269633,1.857153), (0.687433,1.24911), (0.131356,1.610389), (1.991372,0.204134), (1.678587,1.456911), (0.501133,0.68513), (0.924535,0.541514), (0.574115,0.340542), (-0.013384,1.17037), (0.917257,1.799431), (1.364786,0.396457), (1.931339,1.093935), (0.575076,0.427512), (2.084798,1.752707), (0.694029,0.257422), (-0.003821,0.160859), (0.037966,0.217695), (1.986527,1.249144), (1.864518,0.521483), (0.038928,0.175741), (1.855737,1.678827), (0.779503,0.963619), (0.035384,0.238397), (0.136108,0.128737), (0.0581,1.093712), (-0.012542,0.713137), (1.53441,0.447265), (0.198885,1.232961), (1.66781,0.259156), (1.478017,1.256315), (1.148358,1.659979), (0.340698,0.76793), (0.376184,0.578202), (0.251495,1.765917), (1.836389,1.75769), (1.573166,1.753943), (0.448309,0.965337), (1.704437,1.138451), (1.93234,1.723736), (1.412218,0.603027), (1.978789,0.938132);
+SELECT '0.286';
+SELECT roundBankers(rankCorrelationSpearman(a, b), 3) from circles;
+
+DROP TABLE IF EXISTS moons;
+DROP TABLE IF EXISTS circles;
+DROP DATABASE IF EXISTS db_01455_rank_correlation;
+
+

From e9a1f4a38367dea49c7e0a578d20ae5373043370 Mon Sep 17 00:00:00 2001
From: Nikita Mikhaylov <mikhaylovnikitka@gmail.com>
Date: Mon, 24 Aug 2020 22:55:00 +0300
Subject: [PATCH 08/12] update ya.make

(cherry picked from commit e62043e83b3f084d88699b8ced667b98a3ba6c8e)
(cherry picked from commit a850388e627af670dd79ea8060400c4b638022c8)
---
 src/AggregateFunctions/ya.make | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/AggregateFunctions/ya.make b/src/AggregateFunctions/ya.make
index 56b461e5ca5..8f2ed54475f 100644
--- a/src/AggregateFunctions/ya.make
+++ b/src/AggregateFunctions/ya.make
@@ -32,6 +32,8 @@ SRCS(
     AggregateFunctionNull.cpp
     AggregateFunctionOrFill.cpp
     AggregateFunctionQuantile.cpp
+    AggregateFunctionRankCorr.cpp
+    AggregateFunctionRankCorrelationSpearman.cpp
     AggregateFunctionResample.cpp
     AggregateFunctionRetention.cpp
     AggregateFunctionSequenceMatch.cpp

From 7021f6edc17e8dc8560c03305716a5a0923f43b5 Mon Sep 17 00:00:00 2001
From: Nikita Mikhaylov <mikhaylovnikitka@gmail.com>
Date: Wed, 2 Sep 2020 15:00:54 +0300
Subject: [PATCH 09/12] better

(cherry picked from commit 81481f26b5d1136daddc3265a90f52e4ef48a1c4)
---
 .../AggregateFunctionRankCorrelation.cpp      | 51 +++++++++++++++++++
 ...n.h => AggregateFunctionRankCorrelation.h} | 32 +++---------
 ...gregateFunctionRankCorrelationSpearman.cpp | 41 ---------------
 .../registerAggregateFunctions.cpp            |  2 +-
 .../registerAggregateFunctions.h              |  2 +-
 .../01455_rank_correlation_spearman.sql       | 10 ++--
 6 files changed, 66 insertions(+), 72 deletions(-)
 create mode 100644 src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp
 rename src/AggregateFunctions/{AggregateFunctionRankCorrelationSpearman.h => AggregateFunctionRankCorrelation.h} (90%)
 delete mode 100644 src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.cpp

diff --git a/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp b/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp
new file mode 100644
index 00000000000..20472279dba
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp
@@ -0,0 +1,51 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionRankCorrelation.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+#include "registerAggregateFunctions.h"
+#include <AggregateFunctions/Helpers.h>
+
+
+namespace ErrorCodes
+{
+extern const int NOT_IMPLEMENTED;
+}
+
+namespace DB
+{
+
+namespace
+{
+
+AggregateFunctionPtr createAggregateFunctionRankCorrelation(const std::string & name, const DataTypes & argument_types, const Array & parameters)
+{
+    assertBinary(name, argument_types);
+    assertNoParameters(name, parameters);
+
+    AggregateFunctionPtr res;
+
+    if (isDecimal(argument_types[0]) || isDecimal(argument_types[1]))
+    {
+        throw Exception("Aggregate function " + name + " only supports numerical types", ErrorCodes::NOT_IMPLEMENTED);
+    }
+    else
+    {
+        res.reset(createWithTwoNumericTypes<AggregateFunctionRankCorrelation>(*argument_types[0], *argument_types[1], argument_types));
+    }
+
+    if (!res)
+    {
+        throw Exception("Aggregate function " + name + " only supports numerical types", ErrorCodes::NOT_IMPLEMENTED);
+    }
+
+    return res;
+}
+
+}
+
+
+void registerAggregateFunctionRankCorrelation(AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("rankCorr", createAggregateFunctionRankCorrelation, AggregateFunctionFactory::CaseInsensitive);
+}
+
+}
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.h b/src/AggregateFunctions/AggregateFunctionRankCorrelation.h
similarity index 90%
rename from src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.h
rename to src/AggregateFunctions/AggregateFunctionRankCorrelation.h
index f4c680bd10b..379a8332f09 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.h
+++ b/src/AggregateFunctions/AggregateFunctionRankCorrelation.h
@@ -51,7 +51,7 @@ struct ComparePairSecond final
 };
 
 template <typename X = Float64, typename Y = Float64>
-struct AggregateFunctionRankCorrelationSpearmanData final
+struct AggregateFunctionRankCorrelationData final
 {
     size_t size_x = 0;
 
@@ -62,23 +62,21 @@ struct AggregateFunctionRankCorrelationSpearmanData final
 };
 
 template <typename X, typename Y>
-class AggregateFunctionRankCorrelationSpearman :
-    public IAggregateFunctionDataHelper<AggregateFunctionRankCorrelationSpearmanData<X, Y>, AggregateFunctionRankCorrelationSpearman<X, Y>>
+class AggregateFunctionRankCorrelation :
+    public IAggregateFunctionDataHelper<AggregateFunctionRankCorrelationData<X, Y>, AggregateFunctionRankCorrelation<X, Y>>
 {
-    using Data = AggregateFunctionRankCorrelationSpearmanData<X, Y>;
+    using Data = AggregateFunctionRankCorrelationData<X, Y>;
     using Allocator = MixedAlignedArenaAllocator<alignof(std::pair<Float64, Float64>), 4096>;
     using Array = PODArray<std::pair<Float64, Float64>, 32, Allocator>;
 
 public:
-    explicit AggregateFunctionRankCorrelationSpearman(const DataTypes & arguments)
-        :IAggregateFunctionDataHelper<AggregateFunctionRankCorrelationSpearmanData<X, Y>,AggregateFunctionRankCorrelationSpearman<X, Y>> ({arguments}, {})
-    {
-        // notice: arguments has been in factory
-    }
+    explicit AggregateFunctionRankCorrelation(const DataTypes & arguments)
+        :IAggregateFunctionDataHelper<AggregateFunctionRankCorrelationData<X, Y>,AggregateFunctionRankCorrelation<X, Y>> ({arguments}, {})
+    {}
 
     String getName() const override
     {
-        return "rankCorrelationSpearman";
+        return "rankCorr";
     }
 
     DataTypePtr getReturnType() const override
@@ -112,10 +110,8 @@ public:
         auto & b = this->data(rhs);
 
         if (b.size_x)
-        {
             for (size_t i = 0; i < b.size_x; ++i)
                 insert(a, b.values[i], arena);
-        }
     }
 
     void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
@@ -151,9 +147,7 @@ public:
         PODArrayWithStackMemory<std::pair<Float64, Float64>, 32> tmp_values;
         tmp_values.resize(size);
         for (size_t j = 0; j < size; ++ j)
-        {
             tmp_values[j] = static_cast<std::pair<Float64, Float64>>(value[j]);
-        }
 
         //sort x_values
         std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairFirst<std::greater>{});
@@ -177,17 +171,13 @@ public:
                     j++;
                 }
                 else
-                {
                     break;
-                }
             }
 
             // insert rank is calculated as average of ranks of equal values
             Float64 insert_rank = static_cast<Float64>(cur_sum) / same;
             for (size_t i = cur_start; i <= j; ++i)
-            {
                 tmp_values[i].first = insert_rank;
-            }
             j++;
         }
 
@@ -222,27 +212,21 @@ public:
             // insert rank is calculated as average of ranks of equal values
             Float64 insert_rank = static_cast<Float64>(cur_sum) / same;
             for (size_t i = cur_start; i <= j; ++i)
-            {
                 tmp_values[i].second = insert_rank;
-            }
             j++;
         }
 
         //count d^2 sum
         Float64 answer = static_cast<Float64>(0);
         for (size_t j = 0; j < size; ++ j)
-        {
             answer += (tmp_values[j].first - tmp_values[j].second) * (tmp_values[j].first - tmp_values[j].second);
-        }
 
         answer *= 6;
         answer /= size * (size * size - 1);
-
         answer = 1 - answer;
 
         auto & column = static_cast<ColumnVector<Float64> &>(to);
         column.getData().push_back(answer);
-        std::cout << "AAAA" << std::endl;
     }
 
 };
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.cpp b/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.cpp
deleted file mode 100644
index 277aea715d3..00000000000
--- a/src/AggregateFunctions/AggregateFunctionRankCorrelationSpearman.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include <AggregateFunctions/AggregateFunctionFactory.h>
-#include <AggregateFunctions/AggregateFunctionRankCorrelationSpearman.h>
-#include <AggregateFunctions/FactoryHelpers.h>
-#include "registerAggregateFunctions.h"
-#include <AggregateFunctions/Helpers.h>
-
-
-namespace ErrorCodes
-{
-extern const int NOT_IMPLEMENTED;
-}
-
-namespace DB
-{
-
-namespace
-{
-
-AggregateFunctionPtr createAggregateFunctionRankCorrelationSpearman(const std::string & name, const DataTypes & argument_types, const Array & parameters)
-{
-    assertBinary(name, argument_types);
-    assertNoParameters(name, parameters);
-
-    if (isDecimal(argument_types[0]) || isDecimal(argument_types[1]))
-    {
-        throw Exception("Aggregate function " + name + " only supports numerical types.", ErrorCodes::NOT_IMPLEMENTED);
-    }
-
-    AggregateFunctionPtr res(createWithTwoNumericTypes<AggregateFunctionRankCorrelationSpearman>(*argument_types[0], *argument_types[1], argument_types));
-    return res;
-}
-
-}
-
-
-void registerAggregateFunctionRankCorrelationSpearman (AggregateFunctionFactory & factory)
-{
-    factory.registerFunction("rankCorrelationSpearman", createAggregateFunctionRankCorrelationSpearman, AggregateFunctionFactory::CaseInsensitive);
-}
-
-}
diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp
index a77a156a52b..b8af252eefa 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -45,7 +45,7 @@ void registerAggregateFunctions()
         registerAggregateFunctionMoving(factory);
         registerAggregateFunctionCategoricalIV(factory);
         registerAggregateFunctionAggThrow(factory);
-        registerAggregateFunctionRankCorrelationSpearman(factory);
+        registerAggregateFunctionRankCorrelation(factory);
     }
 
     {
diff --git a/src/AggregateFunctions/registerAggregateFunctions.h b/src/AggregateFunctions/registerAggregateFunctions.h
index 87852be78c0..90054788613 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.h
+++ b/src/AggregateFunctions/registerAggregateFunctions.h
@@ -35,7 +35,7 @@ void registerAggregateFunctionSimpleLinearRegression(AggregateFunctionFactory &)
 void registerAggregateFunctionMoving(AggregateFunctionFactory &);
 void registerAggregateFunctionCategoricalIV(AggregateFunctionFactory &);
 void registerAggregateFunctionAggThrow(AggregateFunctionFactory &);
-void registerAggregateFunctionRankCorrelationSpearman(AggregateFunctionFactory &);
+void registerAggregateFunctionRankCorrelation(AggregateFunctionFactory &);
 
 class AggregateFunctionCombinatorFactory;
 void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory &);
diff --git a/tests/queries/0_stateless/01455_rank_correlation_spearman.sql b/tests/queries/0_stateless/01455_rank_correlation_spearman.sql
index 479399e1b41..f99969e6736 100644
--- a/tests/queries/0_stateless/01455_rank_correlation_spearman.sql
+++ b/tests/queries/0_stateless/01455_rank_correlation_spearman.sql
@@ -4,23 +4,23 @@ DROP TABLE IF EXISTS moons;
 DROP TABLE IF EXISTS circles;
 
 SELECT '1';
-SELECT rankCorrelationSpearman(number, number) FROM numbers(100);
+SELECT rankCorr(number, number) FROM numbers(100);
 
 SELECT '-1';
-SELECT rankCorrelationSpearman(number, -1 * number) FROM numbers(100);
+SELECT rankCorr(number, -1 * number) FROM numbers(100);
 
 SELECT '-0.037';
-SELECT roundBankers(rankCorrelationSpearman(exp(number), sin(number)), 3) FROM numbers(100);
+SELECT roundBankers(rankCorr(exp(number), sin(number)), 3) FROM numbers(100);
 
 CREATE TABLE moons(a Float64, b Float64) Engine=Memory();
 INSERT INTO moons VALUES (1.230365,1.291454), (1.93851,0.6499), (1.574085,0.744109), (1.416457,1.41872), (1.90165,1.298199), (2.023844,1.142459), (1.828602,0.636404), (1.568649,1.157387), (1.968863,1.160039), (1.790198,0.860815), (1.238993,0.252486), (1.690338,0.573545), (1.678741,0.739649), (1.363346,0.514698), (1.924442,0.484331), (0.849071,0.585017), (1.859407,1.098124), (1.657176,1.314958), (1.085181,0.761741), (1.184481,0.639135), (1.59856,0.688384), (1.304818,1.212579), (1.913821,0.663551), (1.872619,0.510627), (1.29273,0.795267), (1.767669,0.892397), (1.790311,1.21813), (1.621893,1.229768), (1.525505,0.752643), (1.513535,1.016012), (1.120456,1.427238), (1.71505,0.716654), (1.394756,0.733629), (1.746027,1.422821), (1.5376,1.387397), (1.358968,0.575393), (1.941569,0.572639), (1.904995,0.966926), (1.967455,0.436449), (2.045535,0.582434), (1.365599,0.446582), (2.035874,0.468542), (1.419283,0.739308), (1.718267,0.895579), (1.285871,1.014628), (2.010657,1.631207), (1.78226,0.576882), (1.78274,0.727585), (1.454934,1.285701), (1.657208,0.581418);
 SELECT '-0.108';
-SELECT roundBankers(rankCorrelationSpearman(a, b), 3) from moons;
+SELECT roundBankers(rankCorr(a, b), 3) from moons;
 
 CREATE TABLE circles(a Float64, b Float64) Engine=Memory();
 INSERT INTO circles VALUES (1.20848,0.505643), (1.577706,1.726383), (1.945215,1.638926), (0.493616,0.792443), (0.827802,1.41133), (1.012179,1.654582), (1.815329,0.254426), (-0.068102,1.456476), (1.235432,1.565291), (1.269633,1.857153), (0.687433,1.24911), (0.131356,1.610389), (1.991372,0.204134), (1.678587,1.456911), (0.501133,0.68513), (0.924535,0.541514), (0.574115,0.340542), (-0.013384,1.17037), (0.917257,1.799431), (1.364786,0.396457), (1.931339,1.093935), (0.575076,0.427512), (2.084798,1.752707), (0.694029,0.257422), (-0.003821,0.160859), (0.037966,0.217695), (1.986527,1.249144), (1.864518,0.521483), (0.038928,0.175741), (1.855737,1.678827), (0.779503,0.963619), (0.035384,0.238397), (0.136108,0.128737), (0.0581,1.093712), (-0.012542,0.713137), (1.53441,0.447265), (0.198885,1.232961), (1.66781,0.259156), (1.478017,1.256315), (1.148358,1.659979), (0.340698,0.76793), (0.376184,0.578202), (0.251495,1.765917), (1.836389,1.75769), (1.573166,1.753943), (0.448309,0.965337), (1.704437,1.138451), (1.93234,1.723736), (1.412218,0.603027), (1.978789,0.938132);
 SELECT '0.286';
-SELECT roundBankers(rankCorrelationSpearman(a, b), 3) from circles;
+SELECT roundBankers(rankCorr(a, b), 3) from circles;
 
 DROP TABLE IF EXISTS moons;
 DROP TABLE IF EXISTS circles;

From cdb1f3063025ed63d07ff0b06c066dc32eaeafbe Mon Sep 17 00:00:00 2001
From: Nikita Mikhaylov <mikhaylovnikitka@gmail.com>
Date: Wed, 2 Sep 2020 16:49:47 +0300
Subject: [PATCH 10/12] style + fast test

---
 src/AggregateFunctions/ya.make                                 | 3 +--
 .../0_stateless/01455_rank_correlation_spearman.reference      | 3 ++-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/AggregateFunctions/ya.make b/src/AggregateFunctions/ya.make
index 8f2ed54475f..d6876938f49 100644
--- a/src/AggregateFunctions/ya.make
+++ b/src/AggregateFunctions/ya.make
@@ -32,8 +32,7 @@ SRCS(
     AggregateFunctionNull.cpp
     AggregateFunctionOrFill.cpp
     AggregateFunctionQuantile.cpp
-    AggregateFunctionRankCorr.cpp
-    AggregateFunctionRankCorrelationSpearman.cpp
+    AggregateFunctionRankCorrelation.cpp
     AggregateFunctionResample.cpp
     AggregateFunctionRetention.cpp
     AggregateFunctionSequenceMatch.cpp
diff --git a/tests/queries/0_stateless/01455_rank_correlation_spearman.reference b/tests/queries/0_stateless/01455_rank_correlation_spearman.reference
index 67619b38acb..0707cf881f0 100644
--- a/tests/queries/0_stateless/01455_rank_correlation_spearman.reference
+++ b/tests/queries/0_stateless/01455_rank_correlation_spearman.reference
@@ -7,4 +7,5 @@
 -0.108
 -0.108
 0.286
-0.286
\ No newline at end of file
+0.286
+

From b7a2d9b176d80229dfd709056c99e2137ae825e3 Mon Sep 17 00:00:00 2001
From: nikitamikhaylov <mikhaylovnikitka@gmail.com>
Date: Thu, 3 Sep 2020 19:04:08 +0300
Subject: [PATCH 11/12] fast test

---
 .../0_stateless/01455_rank_correlation_spearman.reference        | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/queries/0_stateless/01455_rank_correlation_spearman.reference b/tests/queries/0_stateless/01455_rank_correlation_spearman.reference
index 0707cf881f0..f2d041eace6 100644
--- a/tests/queries/0_stateless/01455_rank_correlation_spearman.reference
+++ b/tests/queries/0_stateless/01455_rank_correlation_spearman.reference
@@ -8,4 +8,3 @@
 -0.108
 0.286
 0.286
-

From 198f08e457dcacb67ec599eb66db00fe7c5baa24 Mon Sep 17 00:00:00 2001
From: nikitamikhaylov <mikhaylovnikitka@gmail.com>
Date: Fri, 4 Sep 2020 13:45:13 +0300
Subject: [PATCH 12/12] Bump CI.