diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 42a434ba53d..202d10c6929 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -221,6 +221,7 @@ add_library(
   src/binaryop/compiled/TrueDiv.cu
   src/binaryop/compiled/binary_ops.cu
   src/binaryop/compiled/util.cpp
+  src/binaryop/compiled/util_old.cpp
   src/labeling/label_bins.cu
   src/bitmask/null_mask.cu
   src/bitmask/is_element_valid.cpp
diff --git a/cpp/src/binaryop/compiled/binary_ops.hpp b/cpp/src/binaryop/compiled/binary_ops.hpp
index d1a40e15326..c0106d2c3c3 100644
--- a/cpp/src/binaryop/compiled/binary_ops.hpp
+++ b/cpp/src/binaryop/compiled/binary_ops.hpp
@@ -161,6 +161,9 @@ void binary_operation(mutable_column_view& out,
  * @return common type among @p out, @p lhs, @p rhs.
  */
 std::optional<data_type> get_common_type(data_type out, data_type lhs, data_type rhs);
+
+std::optional<data_type> get_common_type_old(data_type out, data_type lhs, data_type rhs);
+
 /**
  * @brief Check if input binary operation is supported for the given input and output types.
  *
@@ -172,6 +175,8 @@ std::optional<data_type> get_common_type(data_type out, data_type lhs, data_type
  */
 bool is_supported_operation(data_type out, data_type lhs, data_type rhs, binary_operator op);
 
+bool is_supported_operation_old(data_type out, data_type lhs, data_type rhs, binary_operator op);
+
 // Defined in individual .cu files.
 /**
  * @brief Deploys single type or double type dispatcher that runs binary operation on each element
diff --git a/cpp/src/binaryop/compiled/util_old.cpp b/cpp/src/binaryop/compiled/util_old.cpp
new file mode 100644
index 00000000000..8106240fcc2
--- /dev/null
+++ b/cpp/src/binaryop/compiled/util_old.cpp
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2021-2022, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "operation.cuh"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_device_view.cuh>
+#include <cudf/utilities/traits.hpp>
+#include <cudf/utilities/type_dispatcher.hpp>
+
+#include <optional>
+
+namespace cudf::binops::compiled {
+
+namespace {
+/**
+ * @brief Functor that returns optional common type of 2 or 3 given types.
+ *
+ */
+struct common_type_functor {
+  template <typename TypeLhs, typename TypeRhs>
+  struct nested_common_type_functor {
+    template <typename TypeOut>
+    std::optional<data_type> operator()()
+    {
+      // If common_type exists
+      if constexpr (cudf::has_common_type_v<TypeOut, TypeLhs, TypeRhs>) {
+        using TypeCommon = typename std::common_type<TypeOut, TypeLhs, TypeRhs>::type;
+        return data_type{type_to_id<TypeCommon>()};
+      } else if constexpr (cudf::has_common_type_v<TypeLhs, TypeRhs>) {
+        using TypeCommon = typename std::common_type<TypeLhs, TypeRhs>::type;
+        // Eg. d=t-t
+        return data_type{type_to_id<TypeCommon>()};
+      }
+
+      // A compiler bug may cause a compilation error when using empty initializer list to construct
+      // an std::optional object containing no `data_type` value. Therefore, we should explicitly
+      // return `std::nullopt` instead.
+      return std::nullopt;
+    }
+  };
+  template <typename TypeLhs, typename TypeRhs>
+  std::optional<data_type> operator()(data_type out)
+  {
+    return type_dispatcher(out, nested_common_type_functor<TypeLhs, TypeRhs>{});
+  }
+};
+
+/**
+ * @brief Functor that return true if BinaryOperator supports given input and output types.
+ *
+ * @tparam BinaryOperator binary operator functor
+ */
+template <typename BinaryOperator>
+struct is_binary_operation_supported {
+  // For types where Out type is fixed. (eg. comparison types)
+  template <typename TypeLhs, typename TypeRhs>
+  inline constexpr bool operator()()
+  {
+    if constexpr (column_device_view::has_element_accessor<TypeLhs>() and
+                  column_device_view::has_element_accessor<TypeRhs>()) {
+      if constexpr (has_common_type_v<TypeLhs, TypeRhs>) {
+        using common_t = std::common_type_t<TypeLhs, TypeRhs>;
+        return std::is_invocable_v<BinaryOperator, common_t, common_t>;
+      } else {
+        return std::is_invocable_v<BinaryOperator, TypeLhs, TypeRhs>;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  template <typename TypeOut, typename TypeLhs, typename TypeRhs>
+  inline constexpr bool operator()()
+  {
+    if constexpr (column_device_view::has_element_accessor<TypeLhs>() and
+                  column_device_view::has_element_accessor<TypeRhs>() and
+                  (mutable_column_device_view::has_element_accessor<TypeOut>() or
+                   is_fixed_point<TypeOut>())) {
+      if constexpr (has_common_type_v<TypeLhs, TypeRhs>) {
+        using common_t = std::common_type_t<TypeLhs, TypeRhs>;
+        if constexpr (std::is_invocable_v<BinaryOperator, common_t, common_t>) {
+          using ReturnType = std::invoke_result_t<BinaryOperator, common_t, common_t>;
+          return std::is_constructible_v<TypeOut, ReturnType> or
+                 (is_fixed_point<ReturnType>() and is_fixed_point<TypeOut>());
+        }
+      } else {
+        if constexpr (std::is_invocable_v<BinaryOperator, TypeLhs, TypeRhs>) {
+          using ReturnType = std::invoke_result_t<BinaryOperator, TypeLhs, TypeRhs>;
+          return std::is_constructible_v<TypeOut, ReturnType>;
+        }
+      }
+    }
+    return false;
+  }
+};
+
+struct is_supported_operation_functor {
+  template <typename TypeLhs, typename TypeRhs>
+  struct nested_support_functor {
+    template <typename BinaryOperator, typename TypeOut>
+    inline constexpr bool call()
+    {
+      return is_binary_operation_supported<BinaryOperator>{}
+        .template operator()<TypeOut, TypeLhs, TypeRhs>();
+    }
+    template <typename TypeOut>
+    inline constexpr bool operator()(binary_operator op)
+    {
+      switch (op) {
+        // clang-format off
+        case binary_operator::ADD:                  return call<ops::Add, TypeOut>();
+        case binary_operator::SUB:                  return call<ops::Sub, TypeOut>();
+        case binary_operator::MUL:                  return call<ops::Mul, TypeOut>();
+        case binary_operator::DIV:                  return call<ops::Div, TypeOut>();
+        case binary_operator::TRUE_DIV:             return call<ops::TrueDiv, TypeOut>();
+        case binary_operator::FLOOR_DIV:            return call<ops::FloorDiv, TypeOut>();
+        case binary_operator::MOD:                  return call<ops::Mod, TypeOut>();
+        case binary_operator::PYMOD:                return call<ops::PyMod, TypeOut>();
+        case binary_operator::POW:                  return call<ops::Pow, TypeOut>();
+        case binary_operator::BITWISE_AND:          return call<ops::BitwiseAnd, TypeOut>();
+        case binary_operator::BITWISE_OR:           return call<ops::BitwiseOr, TypeOut>();
+        case binary_operator::BITWISE_XOR:          return call<ops::BitwiseXor, TypeOut>();
+        case binary_operator::SHIFT_LEFT:           return call<ops::ShiftLeft, TypeOut>();
+        case binary_operator::SHIFT_RIGHT:          return call<ops::ShiftRight, TypeOut>();
+        case binary_operator::SHIFT_RIGHT_UNSIGNED: return call<ops::ShiftRightUnsigned, TypeOut>();
+        case binary_operator::LOG_BASE:             return call<ops::LogBase, TypeOut>();
+        case binary_operator::ATAN2:                return call<ops::ATan2, TypeOut>();
+        case binary_operator::PMOD:                 return call<ops::PMod, TypeOut>();
+        case binary_operator::NULL_MAX:             return call<ops::NullMax, TypeOut>();
+        case binary_operator::NULL_MIN:             return call<ops::NullMin, TypeOut>();
+        /*
+        case binary_operator::GENERIC_BINARY:       // defined in jit only.
+        */
+        default:                                    return false;
+          // clang-format on
+      }
+    }
+  };
+
+  template <typename BinaryOperator, typename TypeLhs, typename TypeRhs>
+  inline constexpr bool bool_op(data_type out)
+  {
+    return out.id() == type_id::BOOL8 and
+           is_binary_operation_supported<BinaryOperator>{}.template operator()<TypeLhs, TypeRhs>();
+  }
+  template <typename TypeLhs, typename TypeRhs>
+  inline constexpr bool operator()(data_type out, binary_operator op)
+  {
+    switch (op) {
+      // output type should be bool type.
+      case binary_operator::LOGICAL_AND: return bool_op<ops::LogicalAnd, TypeLhs, TypeRhs>(out);
+      case binary_operator::LOGICAL_OR: return bool_op<ops::LogicalOr, TypeLhs, TypeRhs>(out);
+      case binary_operator::EQUAL: return bool_op<ops::Equal, TypeLhs, TypeRhs>(out);
+      case binary_operator::NOT_EQUAL: return bool_op<ops::NotEqual, TypeLhs, TypeRhs>(out);
+      case binary_operator::LESS: return bool_op<ops::Less, TypeLhs, TypeRhs>(out);
+      case binary_operator::GREATER: return bool_op<ops::Greater, TypeLhs, TypeRhs>(out);
+      case binary_operator::LESS_EQUAL: return bool_op<ops::LessEqual, TypeLhs, TypeRhs>(out);
+      case binary_operator::GREATER_EQUAL: return bool_op<ops::GreaterEqual, TypeLhs, TypeRhs>(out);
+      case binary_operator::NULL_EQUALS: return bool_op<ops::NullEquals, TypeLhs, TypeRhs>(out);
+      case binary_operator::NULL_LOGICAL_AND:
+        return bool_op<ops::NullLogicalAnd, TypeLhs, TypeRhs>(out);
+      case binary_operator::NULL_LOGICAL_OR:
+        return bool_op<ops::NullLogicalOr, TypeLhs, TypeRhs>(out);
+      default: return type_dispatcher(out, nested_support_functor<TypeLhs, TypeRhs>{}, op);
+    }
+    return false;
+  }
+};
+
+}  // namespace
+
+std::optional<data_type> get_common_type_old(data_type out, data_type lhs, data_type rhs)
+{
+  return double_type_dispatcher(lhs, rhs, common_type_functor{}, out);
+}
+
+bool is_supported_operation_old(data_type out, data_type lhs, data_type rhs, binary_operator op)
+{
+  return double_type_dispatcher(lhs, rhs, is_supported_operation_functor{}, out, op);
+}
+}  // namespace cudf::binops::compiled
diff --git a/cpp/tests/binaryop/binop-verify-input-test.cpp b/cpp/tests/binaryop/binop-verify-input-test.cpp
index 167fbc22bde..ac0ed3e081c 100644
--- a/cpp/tests/binaryop/binop-verify-input-test.cpp
+++ b/cpp/tests/binaryop/binop-verify-input-test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2022, NVIDIA CORPORATION.
  *
  * Copyright 2018-2019 BlazingDB, Inc.
  *     Copyright 2018 Christian Noboa Mardini <christian@blazingdb.com>
@@ -19,8 +19,12 @@
 
 #include <cudf/binaryop.hpp>
 
+#include <binaryop/compiled/binary_ops.hpp>
+
 #include <tests/binaryop/binop-fixture.hpp>
 
+#include <iostream>
+
 namespace cudf {
 namespace test {
 namespace binop {
@@ -54,6 +58,158 @@ TEST_F(BinopVerifyInputTest, Vector_Vector_ErrorSecondOperandVectorZeroSize)
     cudf::logic_error);
 }
 
+struct BinopTypeTest : public BinaryOperationTest {
+};
+TEST_F(BinopTypeTest, GetCommonTypeTest)
+{
+  auto const type_ids = std::vector<cudf::type_id>{
+    // cudf::type_id::EMPTY,  ///< Always null with no underlying data
+    cudf::type_id::INT8,               ///< 1 byte signed integer
+    cudf::type_id::INT16,              ///< 2 byte signed integer
+    cudf::type_id::INT32,              ///< 4 byte signed integer
+    cudf::type_id::INT64,              ///< 8 byte signed integer
+    cudf::type_id::UINT8,              ///< 1 byte unsigned integer
+    cudf::type_id::UINT16,             ///< 2 byte unsigned integer
+    cudf::type_id::UINT32,             ///< 4 byte unsigned integer
+    cudf::type_id::UINT64,             ///< 8 byte unsigned integer
+    cudf::type_id::FLOAT32,            ///< 4 byte floating point
+    cudf::type_id::FLOAT64,            ///< 8 byte floating point
+    cudf::type_id::BOOL8,              ///< Boolean using one byte per value, 0 == false, else true
+    cudf::type_id::TIMESTAMP_DAYS,     ///< point in time in days since Unix Epoch in int32
+    cudf::type_id::TIMESTAMP_SECONDS,  ///< point in time in seconds since Unix Epoch in int64
+    cudf::type_id::TIMESTAMP_MILLISECONDS,  ///< point in time in milliseconds since Unix Epoch in
+                                            ///< int64
+    cudf::type_id::TIMESTAMP_MICROSECONDS,  ///< point in time in microseconds since Unix Epoch in
+                                            ///< int64
+    cudf::type_id::TIMESTAMP_NANOSECONDS,   ///< point in time in nanoseconds since Unix Epoch in
+                                            ///< int64
+    cudf::type_id::DURATION_DAYS,           ///< time interval of days in int32
+    cudf::type_id::DURATION_SECONDS,        ///< time interval of seconds in int64
+    cudf::type_id::DURATION_MILLISECONDS,   ///< time interval of milliseconds in int64
+    cudf::type_id::DURATION_MICROSECONDS,   ///< time interval of microseconds in int64
+    cudf::type_id::DURATION_NANOSECONDS,    ///< time interval of nanoseconds in int64
+    cudf::type_id::DICTIONARY32,            ///< Dictionary type using int32 indices
+    cudf::type_id::STRING,                  ///< String elements
+    cudf::type_id::LIST,                    ///< List elements
+    cudf::type_id::DECIMAL32,               ///< Fixed-point type with int32_t
+    cudf::type_id::DECIMAL64,               ///< Fixed-point type with int64_t
+    cudf::type_id::DECIMAL128,              ///< Fixed-point type with __int128_t
+    cudf::type_id::STRUCT                   ///< Struct elements
+  };
+  for (auto const& t1 : type_ids) {
+    for (auto const& t2 : type_ids) {
+      for (auto const& t3 : type_ids) {
+        auto const d1  = cudf::data_type(t1);
+        auto const d2  = cudf::data_type(t2);
+        auto const d3  = cudf::data_type(t3);
+        auto const old = cudf::binops::compiled::get_common_type_old(d1, d2, d3);
+        (void)old;
+        auto const new_ = cudf::binops::compiled::get_common_type(d1, d2, d3);
+        (void)new_;
+        std::cerr << static_cast<int32_t>(t1) << ", " << static_cast<int32_t>(t2) << ", "
+                  << static_cast<int32_t>(t3) << std::endl;
+        EXPECT_EQ(old, new_);
+      }
+    }
+  }
+}
+
+TEST_F(BinopTypeTest, IsSupportedOperationTest)
+{
+  auto const binops = std::vector<cudf::binary_operator>{
+    cudf::binary_operator::ADD,        ///< operator +
+    cudf::binary_operator::SUB,        ///< operator -
+    cudf::binary_operator::MUL,        ///< operator *
+    cudf::binary_operator::DIV,        ///< operator / using common type of lhs and rhs
+    cudf::binary_operator::TRUE_DIV,   ///< operator / after promoting type to floating point
+    cudf::binary_operator::FLOOR_DIV,  ///< operator / after promoting to 64 bit floating point and
+                                       ///< then
+    cudf::binary_operator::MOD,        ///< operator %
+    cudf::binary_operator::PMOD,       ///< positive modulo operator
+    cudf::binary_operator::PYMOD,  ///< operator % but following Python's sign rules for negatives
+    cudf::binary_operator::POW,    ///< lhs ^ rhs
+    cudf::binary_operator::LOG_BASE,              ///< logarithm to the base
+    cudf::binary_operator::ATAN2,                 ///< 2-argument arctangent
+    cudf::binary_operator::SHIFT_LEFT,            ///< operator <<
+    cudf::binary_operator::SHIFT_RIGHT,           ///< operator >>
+    cudf::binary_operator::SHIFT_RIGHT_UNSIGNED,  ///< operator >>> (from Java)
+    cudf::binary_operator::BITWISE_AND,           ///< operator &
+    cudf::binary_operator::BITWISE_OR,            ///< operator |
+    cudf::binary_operator::BITWISE_XOR,           ///< operator ^
+    cudf::binary_operator::LOGICAL_AND,           ///< operator &&
+    cudf::binary_operator::LOGICAL_OR,            ///< operator ||
+    cudf::binary_operator::EQUAL,                 ///< operator ==
+    cudf::binary_operator::NOT_EQUAL,             ///< operator !=
+    cudf::binary_operator::LESS,                  ///< operator <
+    cudf::binary_operator::GREATER,               ///< operator >
+    cudf::binary_operator::LESS_EQUAL,            ///< operator <=
+    cudf::binary_operator::GREATER_EQUAL,         ///< operator >=
+    cudf::binary_operator::NULL_EQUALS,  ///< Returns true when both operands are null; false when
+                                         ///< one is null; the
+    cudf::binary_operator::NULL_MAX,  ///< Returns max of operands when both are non-null; returns
+                                      ///< the non-null
+    cudf::binary_operator::NULL_MIN,  ///< Returns min of operands when both are non-null; returns
+                                      ///< the non-null
+    cudf::binary_operator::GENERIC_BINARY,  ///< generic binary operator to be generated with input
+    cudf::binary_operator::NULL_LOGICAL_AND,  ///< operator && with Spark rules: (null, null) is
+                                              ///< null, (null, true) is
+    cudf::binary_operator::NULL_LOGICAL_OR,   ///< operator || with Spark rules: (null, null) is
+                                              ///< null, (null, true) is true,
+    cudf::binary_operator::INVALID_BINARY     ///< invalid operation
+  };
+
+  auto const type_ids = std::vector<cudf::type_id>{
+    // cudf::type_id::EMPTY,  ///< Always null with no underlying data
+    cudf::type_id::INT8,               ///< 1 byte signed integer
+    cudf::type_id::INT16,              ///< 2 byte signed integer
+    cudf::type_id::INT32,              ///< 4 byte signed integer
+    cudf::type_id::INT64,              ///< 8 byte signed integer
+    cudf::type_id::UINT8,              ///< 1 byte unsigned integer
+    cudf::type_id::UINT16,             ///< 2 byte unsigned integer
+    cudf::type_id::UINT32,             ///< 4 byte unsigned integer
+    cudf::type_id::UINT64,             ///< 8 byte unsigned integer
+    cudf::type_id::FLOAT32,            ///< 4 byte floating point
+    cudf::type_id::FLOAT64,            ///< 8 byte floating point
+    cudf::type_id::BOOL8,              ///< Boolean using one byte per value, 0 == false, else true
+    cudf::type_id::TIMESTAMP_DAYS,     ///< point in time in days since Unix Epoch in int32
+    cudf::type_id::TIMESTAMP_SECONDS,  ///< point in time in seconds since Unix Epoch in int64
+    cudf::type_id::TIMESTAMP_MILLISECONDS,  ///< point in time in milliseconds since Unix Epoch in
+                                            ///< int64
+    cudf::type_id::TIMESTAMP_MICROSECONDS,  ///< point in time in microseconds since Unix Epoch in
+                                            ///< int64
+    cudf::type_id::TIMESTAMP_NANOSECONDS,   ///< point in time in nanoseconds since Unix Epoch in
+                                            ///< int64
+    cudf::type_id::DURATION_DAYS,           ///< time interval of days in int32
+    cudf::type_id::DURATION_SECONDS,        ///< time interval of seconds in int64
+    cudf::type_id::DURATION_MILLISECONDS,   ///< time interval of milliseconds in int64
+    cudf::type_id::DURATION_MICROSECONDS,   ///< time interval of microseconds in int64
+    cudf::type_id::DURATION_NANOSECONDS,    ///< time interval of nanoseconds in int64
+    cudf::type_id::DICTIONARY32,            ///< Dictionary type using int32 indices
+    cudf::type_id::STRING,                  ///< String elements
+    cudf::type_id::LIST,                    ///< List elements
+    cudf::type_id::DECIMAL32,               ///< Fixed-point type with int32_t
+    cudf::type_id::DECIMAL64,               ///< Fixed-point type with int64_t
+    cudf::type_id::DECIMAL128,              ///< Fixed-point type with __int128_t
+    cudf::type_id::STRUCT                   ///< Struct elements
+  };
+  for (auto const& op : binops) {
+    for (auto const& t1 : type_ids) {
+      for (auto const& t2 : type_ids) {
+        for (auto const& t3 : type_ids) {
+          auto const d1   = cudf::data_type(t1);
+          auto const d2   = cudf::data_type(t2);
+          auto const d3   = cudf::data_type(t3);
+          auto const old  = cudf::binops::compiled::is_supported_operation_old(d1, d2, d3, op);
+          auto const new_ = cudf::binops::compiled::is_supported_operation(d1, d2, d3, op);
+          std::cerr << static_cast<int32_t>(t1) << ", " << static_cast<int32_t>(t2) << ", "
+                    << static_cast<int32_t>(t3) << ", " << static_cast<int32_t>(op) << std::endl;
+          EXPECT_EQ(old, new_);
+        }
+      }
+    }
+  }
+}
+
 }  // namespace binop
 }  // namespace test
 }  // namespace cudf