From 8dac30ae955a1ef0b78826d8d7b06594e583263d Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 14 Jun 2020 21:42:10 +0300
Subject: [PATCH] Split file for better build times

---
 src/Common/FieldVisitors.h                   | 128 -----------------
 src/Common/FieldVisitorsAccurateComparison.h | 142 +++++++++++++++++++
 src/Functions/array/arrayIndex.h             |   2 +-
 src/Interpreters/FillingRow.cpp              |   2 +
 src/Interpreters/FillingRow.h                |   2 +-
 src/Interpreters/InterpreterSelectQuery.cpp  |   2 +-
 src/Storages/MergeTree/KeyCondition.cpp      |   2 +-
 7 files changed, 148 insertions(+), 132 deletions(-)
 create mode 100644 src/Common/FieldVisitorsAccurateComparison.h

diff --git a/src/Common/FieldVisitors.h b/src/Common/FieldVisitors.h
index 257994a6bd2..ddeddb8fbf6 100644
--- a/src/Common/FieldVisitors.h
+++ b/src/Common/FieldVisitors.h
@@ -1,10 +1,7 @@
 #pragma once
 
 #include <Core/Field.h>
-#include <Core/AccurateComparison.h>
 #include <common/demangle.h>
-#include <IO/ReadBufferFromString.h>
-#include <IO/ReadHelpers.h>
 
 
 class SipHash;
@@ -16,7 +13,6 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int CANNOT_CONVERT_TYPE;
-    extern const int BAD_TYPE_OF_FIELD;
     extern const int LOGICAL_ERROR;
 }
 
@@ -179,130 +175,6 @@ template <> constexpr bool isDecimalField<DecimalField<Decimal64>>() { return tr
 template <> constexpr bool isDecimalField<DecimalField<Decimal128>>() { return true; }
 
 
-/** More precise comparison, used for index.
-  * Differs from Field::operator< and Field::operator== in that it also compares values of different types.
-  * Comparison rules are same as in FunctionsComparison (to be consistent with expression evaluation in query).
-  */
-class FieldVisitorAccurateEquals : public StaticVisitor<bool>
-{
-public:
-    template <typename T, typename U>
-    bool operator() (const T & l, const U & r) const
-    {
-        if constexpr (std::is_same_v<T, Null> || std::is_same_v<U, Null>)
-            return std::is_same_v<T, U>;
-        else
-        {
-            if constexpr (std::is_same_v<T, U>)
-                return l == r;
-
-            if constexpr (std::is_arithmetic_v<T> && std::is_arithmetic_v<U>)
-                return accurate::equalsOp(l, r);
-
-            if constexpr (isDecimalField<T>() && isDecimalField<U>())
-                return l == r;
-
-            if constexpr (isDecimalField<T>() && std::is_arithmetic_v<U>)
-                return l == DecimalField<Decimal128>(r, 0);
-
-            if constexpr (std::is_arithmetic_v<T> && isDecimalField<U>())
-                return DecimalField<Decimal128>(l, 0) == r;
-
-            if constexpr (std::is_same_v<T, String>)
-            {
-                if constexpr (std::is_same_v<U, UInt128>)
-                    return stringToUUID(l) == r;
-
-                if constexpr (std::is_arithmetic_v<U>)
-                {
-                    ReadBufferFromString in(l);
-                    T parsed;
-                    readText(parsed, in);
-                    return operator()(parsed, r);
-                }
-            }
-
-            if constexpr (std::is_same_v<U, String>)
-            {
-                if constexpr (std::is_same_v<T, UInt128>)
-                    return l == stringToUUID(r);
-
-                if constexpr (std::is_arithmetic_v<T>)
-                {
-                    ReadBufferFromString in(r);
-                    T parsed;
-                    readText(parsed, in);
-                    return operator()(l, parsed);
-                }
-            }
-        }
-
-        throw Exception("Cannot compare " + demangle(typeid(T).name()) + " with " + demangle(typeid(U).name()),
-            ErrorCodes::BAD_TYPE_OF_FIELD);
-    }
-};
-
-
-class FieldVisitorAccurateLess : public StaticVisitor<bool>
-{
-public:
-    template <typename T, typename U>
-    bool operator() (const T & l, const U & r) const
-    {
-        if constexpr (std::is_same_v<T, Null> || std::is_same_v<U, Null>)
-            return false;
-        else
-        {
-            if constexpr (std::is_same_v<T, U>)
-                return l < r;
-
-            if constexpr (std::is_arithmetic_v<T> && std::is_arithmetic_v<U>)
-                return accurate::lessOp(l, r);
-
-            if constexpr (isDecimalField<T>() && isDecimalField<U>())
-                return l < r;
-
-            if constexpr (isDecimalField<T>() && std::is_arithmetic_v<U>)
-                return l < DecimalField<Decimal128>(r, 0);
-
-            if constexpr (std::is_arithmetic_v<T> && isDecimalField<U>())
-                return DecimalField<Decimal128>(l, 0) < r;
-
-            if constexpr (std::is_same_v<T, String>)
-            {
-                if constexpr (std::is_same_v<U, UInt128>)
-                    return stringToUUID(l) < r;
-
-                if constexpr (std::is_arithmetic_v<U>)
-                {
-                    ReadBufferFromString in(l);
-                    T parsed;
-                    readText(parsed, in);
-                    return operator()(parsed, r);
-                }
-            }
-
-            if constexpr (std::is_same_v<U, String>)
-            {
-                if constexpr (std::is_same_v<T, UInt128>)
-                    return l < stringToUUID(r);
-
-                if constexpr (std::is_arithmetic_v<T>)
-                {
-                    ReadBufferFromString in(r);
-                    T parsed;
-                    readText(parsed, in);
-                    return operator()(l, parsed);
-                }
-            }
-        }
-
-        throw Exception("Cannot compare " + demangle(typeid(T).name()) + " with " + demangle(typeid(U).name()),
-            ErrorCodes::BAD_TYPE_OF_FIELD);
-    }
-};
-
-
 /** Implements `+=` operation.
  *  Returns false if the result is zero.
  */
diff --git a/src/Common/FieldVisitorsAccurateComparison.h b/src/Common/FieldVisitorsAccurateComparison.h
new file mode 100644
index 00000000000..91fa4bf28de
--- /dev/null
+++ b/src/Common/FieldVisitorsAccurateComparison.h
@@ -0,0 +1,142 @@
+#pragma once
+
+#include <Core/Field.h>
+#include <Core/AccurateComparison.h>
+#include <common/demangle.h>
+#include <Common/FieldVisitors.h>
+#include <IO/ReadBufferFromString.h>
+#include <IO/ReadHelpers.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int BAD_TYPE_OF_FIELD;
+}
+
+/** More precise comparison, used for index.
+  * Differs from Field::operator< and Field::operator== in that it also compares values of different types.
+  * Comparison rules are same as in FunctionsComparison (to be consistent with expression evaluation in query).
+  */
+class FieldVisitorAccurateEquals : public StaticVisitor<bool>
+{
+public:
+    template <typename T, typename U>
+    bool operator() (const T & l, const U & r) const
+    {
+        if constexpr (std::is_same_v<T, Null> || std::is_same_v<U, Null>)
+            return std::is_same_v<T, U>;
+        else
+        {
+            if constexpr (std::is_same_v<T, U>)
+                return l == r;
+
+            if constexpr (std::is_arithmetic_v<T> && std::is_arithmetic_v<U>)
+                return accurate::equalsOp(l, r);
+
+            if constexpr (isDecimalField<T>() && isDecimalField<U>())
+                return l == r;
+
+            if constexpr (isDecimalField<T>() && std::is_arithmetic_v<U>)
+                return l == DecimalField<Decimal128>(r, 0);
+
+            if constexpr (std::is_arithmetic_v<T> && isDecimalField<U>())
+                return DecimalField<Decimal128>(l, 0) == r;
+
+            if constexpr (std::is_same_v<T, String>)
+            {
+                if constexpr (std::is_same_v<U, UInt128>)
+                    return stringToUUID(l) == r;
+
+                if constexpr (std::is_arithmetic_v<U>)
+                {
+                    ReadBufferFromString in(l);
+                    T parsed;
+                    readText(parsed, in);
+                    return operator()(parsed, r);
+                }
+            }
+
+            if constexpr (std::is_same_v<U, String>)
+            {
+                if constexpr (std::is_same_v<T, UInt128>)
+                    return l == stringToUUID(r);
+
+                if constexpr (std::is_arithmetic_v<T>)
+                {
+                    ReadBufferFromString in(r);
+                    T parsed;
+                    readText(parsed, in);
+                    return operator()(l, parsed);
+                }
+            }
+        }
+
+        throw Exception("Cannot compare " + demangle(typeid(T).name()) + " with " + demangle(typeid(U).name()),
+            ErrorCodes::BAD_TYPE_OF_FIELD);
+    }
+};
+
+
+class FieldVisitorAccurateLess : public StaticVisitor<bool>
+{
+public:
+    template <typename T, typename U>
+    bool operator() (const T & l, const U & r) const
+    {
+        if constexpr (std::is_same_v<T, Null> || std::is_same_v<U, Null>)
+            return false;
+        else
+        {
+            if constexpr (std::is_same_v<T, U>)
+                return l < r;
+
+            if constexpr (std::is_arithmetic_v<T> && std::is_arithmetic_v<U>)
+                return accurate::lessOp(l, r);
+
+            if constexpr (isDecimalField<T>() && isDecimalField<U>())
+                return l < r;
+
+            if constexpr (isDecimalField<T>() && std::is_arithmetic_v<U>)
+                return l < DecimalField<Decimal128>(r, 0);
+
+            if constexpr (std::is_arithmetic_v<T> && isDecimalField<U>())
+                return DecimalField<Decimal128>(l, 0) < r;
+
+            if constexpr (std::is_same_v<T, String>)
+            {
+                if constexpr (std::is_same_v<U, UInt128>)
+                    return stringToUUID(l) < r;
+
+                if constexpr (std::is_arithmetic_v<U>)
+                {
+                    ReadBufferFromString in(l);
+                    T parsed;
+                    readText(parsed, in);
+                    return operator()(parsed, r);
+                }
+            }
+
+            if constexpr (std::is_same_v<U, String>)
+            {
+                if constexpr (std::is_same_v<T, UInt128>)
+                    return l < stringToUUID(r);
+
+                if constexpr (std::is_arithmetic_v<T>)
+                {
+                    ReadBufferFromString in(r);
+                    T parsed;
+                    readText(parsed, in);
+                    return operator()(l, parsed);
+                }
+            }
+        }
+
+        throw Exception("Cannot compare " + demangle(typeid(T).name()) + " with " + demangle(typeid(U).name()),
+            ErrorCodes::BAD_TYPE_OF_FIELD);
+    }
+};
+
+}
diff --git a/src/Functions/array/arrayIndex.h b/src/Functions/array/arrayIndex.h
index fab1332cbda..50214ee790f 100644
--- a/src/Functions/array/arrayIndex.h
+++ b/src/Functions/array/arrayIndex.h
@@ -9,7 +9,7 @@
 #include <Columns/ColumnFixedString.h>
 #include <Columns/ColumnsNumber.h>
 #include <Columns/ColumnNullable.h>
-#include <Common/FieldVisitors.h>
+#include <Common/FieldVisitorsAccurateComparison.h>
 #include <Common/memcmpSmall.h>
 #include <Common/assert_cast.h>
 
diff --git a/src/Interpreters/FillingRow.cpp b/src/Interpreters/FillingRow.cpp
index dc48b5347c4..7e32d9514a6 100644
--- a/src/Interpreters/FillingRow.cpp
+++ b/src/Interpreters/FillingRow.cpp
@@ -1,4 +1,6 @@
 #include <Interpreters/FillingRow.h>
+#include <Common/FieldVisitorsAccurateComparison.h>
+
 
 namespace DB
 {
diff --git a/src/Interpreters/FillingRow.h b/src/Interpreters/FillingRow.h
index 1753508e139..0e1d60d0d7a 100644
--- a/src/Interpreters/FillingRow.h
+++ b/src/Interpreters/FillingRow.h
@@ -1,7 +1,7 @@
 #pragma once
 #include <Core/SortDescription.h>
 #include <Columns/IColumn.h>
-#include <Common/FieldVisitors.h>
+
 
 namespace DB
 {
diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp
index f9072e6176a..dc32371b6c1 100644
--- a/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/src/Interpreters/InterpreterSelectQuery.cpp
@@ -37,7 +37,7 @@
 #include <Core/Field.h>
 #include <Core/Types.h>
 #include <Columns/Collator.h>
-#include <Common/FieldVisitors.h>
+#include <Common/FieldVisitorsAccurateComparison.h>
 #include <Common/typeid_cast.h>
 #include <Common/checkStackSize.h>
 #include <ext/map.h>
diff --git a/src/Storages/MergeTree/KeyCondition.cpp b/src/Storages/MergeTree/KeyCondition.cpp
index 7265e818b51..281f8511a59 100644
--- a/src/Storages/MergeTree/KeyCondition.cpp
+++ b/src/Storages/MergeTree/KeyCondition.cpp
@@ -7,7 +7,7 @@
 #include <Interpreters/misc.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/IFunction.h>
-#include <Common/FieldVisitors.h>
+#include <Common/FieldVisitorsAccurateComparison.h>
 #include <Common/typeid_cast.h>
 #include <Interpreters/convertFieldToType.h>
 #include <Interpreters/Set.h>