remove CppToType usage from SimpleFunctionAdapter and ComplexViewTypes (#4420)

Summary:
Pull Request resolved: #4420

Pull Request resolved: #4304

There is one remaining place, ComplexWriterTypes for the generic writer
I will address that in a different diff since there are pending changes on that file that needs to land first.

Reviewed By: kagamiori

Differential Revision: D44388667

fbshipit-source-id: da2281dbdbcc95971d8ce3df100889deaebe9004

Author: laithsakka

velox/core/SimpleFunctionMetadata.h

@@ -191,14 +191,16 @@ struct TypeAnalysis {
   void run(TypeAnalysisResults& results) {
     // This should only handle primitives and OPAQUE.
     static_assert(
-        CppToType<T>::isPrimitiveType ||
-        CppToType<T>::typeKind == TypeKind::OPAQUE);
+        SimpleTypeTrait<T>::isPrimitiveType ||
+        SimpleTypeTrait<T>::typeKind == TypeKind::OPAQUE);
     results.stats.concreteCount++;
-    if (isDecimalKind(CppToType<T>::typeKind)) {
-      results.out << detail::strToLowerCopy(std::string(CppToType<T>::name))
+    if (isDecimalKind(SimpleTypeTrait<T>::typeKind)) {
+      results.out << detail::strToLowerCopy(
+                         std::string(SimpleTypeTrait<T>::name))
                   << "(" << kPrecisionVariable << "," << kScaleVariable << ")";
     } else {
-      results.out << detail::strToLowerCopy(std::string(CppToType<T>::name));
+      results.out << detail::strToLowerCopy(
+          std::string(SimpleTypeTrait<T>::name));
     }
   }
 };

velox/expression/ComplexViewTypes.h

@@ -1026,11 +1026,11 @@ class GenericView {
   GenericView(
       const DecodedVector& decoded,
       std::array<std::shared_ptr<void>, 3>& castReaders,
-      TypePtr& castType,
+      std::optional<const std::type_info*>& castTypeInfo,
       vector_size_t index)
       : decoded_(decoded),
         castReaders_(castReaders),
-        castType_(castType),
+        castTypeInfo_(castTypeInfo),
         index_(index) {}
 
   uint64_t hash() const {
@@ -1064,9 +1064,8 @@ class GenericView {
     VELOX_DCHECK(
         CastTypeChecker<ToType>::check(type()),
         fmt::format(
-            "castTo type is not compatible with type of vector, vector type is {}, casted to type is {}",
-            type()->toString(),
-            CppToType<ToType>::create()->toString()));
+            "castTo type is not compatible with type of vector, vector type is {}",
+            type()->toString()));
 
     // TODO: We can distinguish if this is a null-free or not null-free
     // generic. And based on that determine if we want to call operator[] or
@@ -1103,17 +1102,18 @@ class GenericView {
         // This is basically Array<Any>, Map<Any,Any>, Row<Any....>.
         return ensureReaderImpl<B, 1>();
       } else {
-        auto requestedType = CppToType<B>::create();
-        if (castType_) {
+        auto* requestedTypeId = &typeid(B);
+        if (castTypeInfo_.has_value()) {
           VELOX_USER_CHECK(
-              castType_->operator==(*requestedType),
+              std::type_index(**castTypeInfo_) ==
+                  std::type_index(*requestedTypeId),
               fmt::format(
                   "Not allowed to cast to the two types {} and {} within the same batch."
                   "Consider creating a new type set to allow it.",
-                  castType_->toString(),
-                  requestedType->toString()));
+                  typeid(B).name(),
+                  castTypeInfo_.value()->name()));
         } else {
-          castType_ = std::move(requestedType);
+          castTypeInfo_ = {requestedTypeId};
         }
         return ensureReaderImpl<B, 2>();
       }
@@ -1133,7 +1133,7 @@ class GenericView {
 
   const DecodedVector& decoded_;
   std::array<std::shared_ptr<void>, 3>& castReaders_;
-  TypePtr& castType_;
+  std::optional<const std::type_info*>& castTypeInfo_;
   vector_size_t index_;
 };
 

velox/expression/GenericWriter.cpp

@@ -22,14 +22,20 @@ namespace facebook::velox::exec {
 
 namespace {
 
-// Base case for primitives
-template <TypeKind T>
-void copy_from_internal(GenericWriter& out, const GenericView& in) {
-  // Maybe we should print a warning asking the user to have a fast path
-  // specialization for primitives and not to use this?.
-  using native_t = typename TypeTraits<T>::NativeType;
-  out.castTo<native_t>() = in.castTo<native_t>();
-}
+template <TypeKind kind>
+struct KindToSimpleType {
+  using type = typename TypeTraits<kind>::NativeType;
+};
+
+template <>
+struct KindToSimpleType<TypeKind::VARCHAR> {
+  using type = Varchar;
+};
+
+template <>
+struct KindToSimpleType<TypeKind::VARBINARY> {
+  using type = Varbinary;
+};
 
 // Fast path when array elements are primitives.
 template <TypeKind T>
@@ -39,11 +45,35 @@ void copy_from_internal_array_fast(GenericWriter& out, const GenericView& in) {
     VELOX_UNREACHABLE(
         "Element type for fast path of copy_from must be primitive.");
   } else {
-    using native_t = typename TypeTraits<T>::NativeType;
-    out.castTo<Array<native_t>>().copy_from(in.castTo<Array<native_t>>());
+    using simple_element_t = typename KindToSimpleType<T>::type;
+    out.castTo<Array<simple_element_t>>().copy_from(
+        in.castTo<Array<simple_element_t>>());
   }
 }
 
+// Base case for primitives.
+template <TypeKind T>
+void copy_from_internal(GenericWriter& out, const GenericView& in) {
+  // Maybe we should print a warning asking the user to have a fast path
+  // specialization for primitives and not to use this?.
+  using simple_element_t = typename KindToSimpleType<T>::type;
+  out.castTo<simple_element_t>() = in.castTo<simple_element_t>();
+}
+
+template <>
+void copy_from_internal<TypeKind::VARBINARY>(
+    GenericWriter& out,
+    const GenericView& in) {
+  out.castTo<Varbinary>().copy_from(in.castTo<Varbinary>());
+}
+
+template <>
+void copy_from_internal<TypeKind::VARCHAR>(
+    GenericWriter& out,
+    const GenericView& in) {
+  out.castTo<Varchar>().copy_from(in.castTo<Varchar>());
+}
+
 template <>
 void copy_from_internal<TypeKind::ARRAY>(
     GenericWriter& out,

velox/expression/SimpleFunctionAdapter.h

@@ -62,19 +62,10 @@ struct udf_reuse_strings_from_arg<
     util::detail::void_t<decltype(T::reuse_strings_from_arg)>>
     : std::integral_constant<int32_t, T::reuse_strings_from_arg> {};
 
-struct GenericOutputTypeTrait {
-  static constexpr TypeKind typeKind = TypeKind::INVALID;
-  static constexpr bool isPrimitiveType = false;
-  static constexpr bool isFixedWidth = false;
-};
-
 template <typename FUNC>
 class SimpleFunctionAdapter : public VectorFunction {
   using T = typename FUNC::exec_return_type;
-  using return_type_traits = std::conditional_t<
-      isGenericType<typename FUNC::return_type>::value,
-      GenericOutputTypeTrait,
-      CppToType<typename FUNC::return_type>>;
+  using return_type_traits = SimpleTypeTrait<typename FUNC::return_type>;
 
   template <int32_t POSITION>
   using exec_arg_at = typename std::
@@ -94,9 +85,8 @@ class SimpleFunctionAdapter : public VectorFunction {
   // boolean.
   template <int32_t POSITION>
   static constexpr bool isArgFlatConstantFastPathEligible =
-      !isGenericType<arg_at<POSITION>>::value &&
-      CppToType<arg_at<POSITION>>::isPrimitiveType &&
-      CppToType<arg_at<POSITION>>::typeKind != TypeKind::BOOLEAN;
+      SimpleTypeTrait<arg_at<POSITION>>::isPrimitiveType&&
+          SimpleTypeTrait<arg_at<POSITION>>::typeKind != TypeKind::BOOLEAN;
 
   constexpr int32_t reuseStringsFromArgValue() const {
     return udf_reuse_strings_from_arg<typename FUNC::udf_struct_t>();
@@ -241,7 +231,8 @@ class SimpleFunctionAdapter : public VectorFunction {
           VectorPtr* findReusableArg(std::vector<VectorPtr>& args) const {
     if constexpr (isVariadicType<arg_at<POSITION>>::value) {
       if constexpr (
-          CppToType<typename arg_at<POSITION>::underlying_type>::typeKind ==
+          SimpleTypeTrait<
+              typename arg_at<POSITION>::underlying_type>::typeKind ==
           return_type_traits::typeKind) {
         for (auto i = POSITION; i < args.size(); i++) {
           if (BaseVector::isVectorWritable(args[i])) {
@@ -253,7 +244,8 @@ class SimpleFunctionAdapter : public VectorFunction {
       // yet, we know for sure that we won't.
       return nullptr;
     } else if constexpr (
-        CppToType<arg_at<POSITION>>::typeKind == return_type_traits::typeKind) {
+        SimpleTypeTrait<arg_at<POSITION>>::typeKind ==
+        return_type_traits::typeKind) {
       using type =
           typename VectorExec::template resolver<arg_at<POSITION>>::in_type;
       if (args[POSITION]->isFlatEncoding() && args[POSITION].unique() &&

velox/expression/VectorReaders.h

@@ -22,6 +22,8 @@
 #include <optional>
 #include <string_view>
 #include <type_traits>
+#include <typeindex>
+#include <typeinfo>
 #include <utility>
 
 #include "velox/expression/ComplexViewTypes.h"
@@ -697,7 +699,7 @@ struct VectorReader<Generic<T>> {
   // Those two variables are mutated by the GenericView during cast operations,
   // and are shared across GenericViews constructed by the reader.
   mutable std::array<std::shared_ptr<void>, 3> castReaders_;
-  mutable TypePtr castType_ = nullptr;
+  mutable std::optional<const std::type_info*> castType_ = std::nullopt;
 };
 
 template <typename T>

velox/type/Type.h

@@ -1567,6 +1567,100 @@ struct CustomType {
   CustomType() {}
 };
 
+struct Varbinary {
+ private:
+  Varbinary() {}
+};
+struct Varchar {
+ private:
+  Varchar() {}
+};
+
+template <typename T>
+struct SimpleTypeTrait {};
+
+template <>
+struct SimpleTypeTrait<int64_t> : public TypeTraits<TypeKind::BIGINT> {};
+
+template <>
+struct SimpleTypeTrait<int32_t> : public TypeTraits<TypeKind::INTEGER> {};
+
+template <>
+struct SimpleTypeTrait<int16_t> : public TypeTraits<TypeKind::SMALLINT> {};
+
+template <>
+struct SimpleTypeTrait<int8_t> : public TypeTraits<TypeKind::TINYINT> {};
+
+template <>
+struct SimpleTypeTrait<float> : public TypeTraits<TypeKind::REAL> {};
+
+template <>
+struct SimpleTypeTrait<double> : public TypeTraits<TypeKind::DOUBLE> {};
+
+template <>
+struct SimpleTypeTrait<bool> : public TypeTraits<TypeKind::BOOLEAN> {};
+
+template <>
+struct SimpleTypeTrait<Varchar> : public TypeTraits<TypeKind::VARCHAR> {};
+
+template <>
+struct SimpleTypeTrait<Varbinary> : public TypeTraits<TypeKind::VARBINARY> {};
+
+template <>
+struct SimpleTypeTrait<Timestamp> : public TypeTraits<TypeKind::TIMESTAMP> {};
+
+template <>
+struct SimpleTypeTrait<Date> : public TypeTraits<TypeKind::DATE> {};
+
+template <>
+struct SimpleTypeTrait<IntervalDayTime>
+    : public TypeTraits<TypeKind::INTERVAL_DAY_TIME> {};
+
+template <typename T>
+struct SimpleTypeTrait<Generic<T>> {
+  static constexpr TypeKind typeKind = TypeKind::UNKNOWN;
+  static constexpr bool isPrimitiveType = false;
+  static constexpr bool isFixedWidth = false;
+};
+
+template <typename T>
+struct SimpleTypeTrait<std::shared_ptr<T>>
+    : public TypeTraits<TypeKind::OPAQUE> {};
+
+template <typename KEY, typename VAL>
+struct SimpleTypeTrait<Map<KEY, VAL>> : public TypeTraits<TypeKind::MAP> {};
+
+template <typename ELEMENT>
+struct SimpleTypeTrait<Array<ELEMENT>> : public TypeTraits<TypeKind::ARRAY> {};
+
+template <typename... T>
+struct SimpleTypeTrait<Row<T...>> : public TypeTraits<TypeKind::ROW> {};
+
+template <>
+struct SimpleTypeTrait<DynamicRow> : public TypeTraits<TypeKind::ROW> {};
+
+template <>
+struct SimpleTypeTrait<UnscaledShortDecimal>
+    : public TypeTraits<TypeKind::SHORT_DECIMAL> {};
+
+template <>
+struct SimpleTypeTrait<UnscaledLongDecimal>
+    : public TypeTraits<TypeKind::LONG_DECIMAL> {};
+
+// T is also a simple type that represent the physical type of the custom type.
+template <typename T>
+struct SimpleTypeTrait<CustomType<T>>
+    : public SimpleTypeTrait<typename T::type> {
+  using physical_t = SimpleTypeTrait<typename T::type>;
+  static constexpr TypeKind typeKind = physical_t::typeKind;
+  static constexpr bool isPrimitiveType = physical_t::isPrimitiveType;
+  static constexpr bool isFixedWidth = physical_t::isFixedWidth;
+
+  // This is different than the physical type name.
+  static constexpr char* name = T::typeName;
+};
+
+// TODO: move cppToType testing utilities.
 template <typename T>
 struct CppToType {};
 
@@ -1577,14 +1671,6 @@ struct CppToTypeBase : public TypeTraits<KIND> {
   }
 };
 
-struct Varbinary {
- private:
-  Varbinary() {}
-};
-struct Varchar {
- private:
-  Varchar() {}
-};
 template <>
 struct CppToType<int64_t> : public CppToTypeBase<TypeKind::BIGINT> {};
 

velox/vector/VectorTypeUtils.h

@@ -109,7 +109,7 @@ struct KindToFlatVector<TypeKind::OPAQUE> {
 
 template <typename T>
 struct TypeToFlatVector {
-  using type = typename KindToFlatVector<CppToType<T>::typeKind>::type;
+  using type = typename KindToFlatVector<SimpleTypeTrait<T>::typeKind>::type;
 };
 
 } // namespace velox