refactor: Implement one step type registration and serialization/deserialization for OpaqueCustomType (#15843)

Summary:

## Background.
- Today, a CustomType (inner type) may be wrapped by an OpaqueType (outer type), forming a OpaqueCustomType.
- When an OpaqueCustomType is defined, it needs to be registered in two place.
   - Custom Type Registry - a mapping from type name to an instance of CustomTypeFactory   that provides an instance of the type
   - OpaqueSerdeRegistry - a mapping from type name to functions that serialize and deserialize opaque type values
- Today, this requires two separate calls to the API. These separate calls are inconvenient and error prone.

## Implementation
- OpaqueCustomTypes.h
   - This PR changes the OpaqueCustomTypeRegister::registerType() function to accept optional serialization/deserialization functions, thus eliminating the need for a separate API call.
   - By keep the function arguments optional, it provides backward compatibility with existing code.

## Testing Changes
- OpaqueCustomTypesTest.cpp
   - Implements unit-tests that ensure that serialization/deserialization functions can be provided in the registerType function optionally.
   - Unit-tests ensure that serialization/deserialization functions can be provided utmost once.

Differential Revision: D89686612

Author: Ashish Misra

velox/type/OpaqueCustomTypes.h

@@ -34,15 +34,26 @@ class CastOperator;
 template <typename T, const char* customTypeName>
 class OpaqueCustomTypeRegister {
  public:
-  static bool registerType() {
-    return facebook::velox::registerCustomType(
-        customTypeName, std::make_unique<const TypeFactory>());
-  }
+  using SerializeFunc = OpaqueType::SerializeFunc<T>;
+  using DeserializeFunc = OpaqueType::DeserializeFunc<T>;
+
+  // Optional serialization and deserialization functions. If not provided, the
+  // the registerSerialization() can be invoked utmost once later.
+  static bool registerType(
+      SerializeFunc serialize = nullptr,
+      DeserializeFunc deserialize = nullptr);
 
   static bool unregisterType() {
     return facebook::velox::unregisterCustomType(customTypeName);
   }
 
+  // Can be invoked only if serialization/deserialization functions were not
+  // provided in the registerType function. In such a case, it can be invoked
+  // only once.
+  static void registerSerialization(
+      SerializeFunc serialize,
+      DeserializeFunc deserialize);
+
   // Type used in the simple function interface as CustomType<TypeT>.
   struct TypeT {
     using type = std::shared_ptr<T>;
@@ -108,4 +119,27 @@ class OpaqueCustomTypeRegister {
     }
   };
 };
+
+template <typename T, const char* customTypeName>
+bool OpaqueCustomTypeRegister<T, customTypeName>::registerType(
+    SerializeFunc serialize,
+    DeserializeFunc deserialize) {
+  if (facebook::velox::registerCustomType(
+          customTypeName, std::make_unique<const TypeFactory>())) {
+    if (serialize || deserialize) {
+      registerSerialization(serialize, deserialize);
+    }
+    return true;
+  }
+  return false;
+}
+
+template <typename T, const char* customTypeName>
+void OpaqueCustomTypeRegister<T, customTypeName>::registerSerialization(
+    SerializeFunc serialize,
+    DeserializeFunc deserialize) {
+  using Type = typename TypeT::type::element_type;
+  OpaqueType::registerSerialization<Type>(
+      customTypeName, serialize, deserialize);
+}
 } // namespace facebook::velox

velox/type/tests/CMakeLists.txt

@@ -21,6 +21,7 @@ add_executable(
   FilterSerDeTest.cpp
   FloatingPointUtilTest.cpp
   HugeIntTest.cpp
+  OpaqueCustomTypesTest.cpp
   StringViewTest.cpp
   SubfieldTest.cpp
   TimestampConversionTest.cpp

velox/type/tests/OpaqueCustomTypesTest.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * 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 <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/OpaqueCustomTypes.h"
+
+using namespace facebook;
+using namespace facebook::velox;
+
+namespace {
+
+TEST(OpaqueCustomTypeTest, RegisterWithoutSerde) {
+  // This is the C++ type registered within the opaque capsule. This could be
+  // anything.
+  struct TestCustomType {};
+  static constexpr char testCustomTypeName[] = "my_test_custom_type";
+  using TestCustomTypeRegister =
+      OpaqueCustomTypeRegister<TestCustomType, testCustomTypeName>;
+
+  // Register type without serialization/deserialization and build a TypePtr.
+  TestCustomTypeRegister::registerType();
+  auto testCustomType = TestCustomTypeRegister::VeloxType::get();
+
+  // Register serialization/deserialization should succeed since no
+  // serialization/deserialization was registered during type registration.
+  TestCustomTypeRegister::registerSerialization(
+      /*serialize=*/[](const std::shared_ptr<TestCustomType>&) { return ""; },
+      /*deserialize=*/
+      [](const std::string&) { return std::make_shared<TestCustomType>(); });
+
+  // Trying to re-register serialization/deserialization should fail.
+  VELOX_ASSERT_THROW(
+      TestCustomTypeRegister::registerSerialization(
+          /*serialize=*/[](const std::shared_ptr<
+                            TestCustomType>&) { return ""; },
+          /*deserialize=*/
+          [](const std::string&) {
+            return std::make_shared<TestCustomType>();
+          }),
+      "Trying to register duplicated serialization information for type OPAQUE");
+}
+
+TEST(OpaqueCustomTypeTest, RegisterWithSerde) {
+  // This is the C++ type registered within the opaque capsule. This could be
+  // anything.
+  struct TestCustomType {};
+  static constexpr char testCustomTypeName[] = "my_test_custom_type";
+  using TestCustomTypeRegister =
+      OpaqueCustomTypeRegister<TestCustomType, testCustomTypeName>;
+
+  // Register type with serialization/deserialization and build a TypePtr.
+  TestCustomTypeRegister::registerType(
+      /*serialize=*/[](const std::shared_ptr<TestCustomType>&) { return ""; },
+      /*deserialize=*/
+      [](const std::string&) { return std::make_shared<TestCustomType>(); });
+  auto testCustomType = TestCustomTypeRegister::VeloxType::get();
+
+  // Trying to re-register serialization/deserialization should fail since
+  // serialization/deserialization was already registered during type
+  // registration.
+  VELOX_ASSERT_THROW(
+      TestCustomTypeRegister::registerSerialization(
+          /*serialize=*/[](const std::shared_ptr<
+                            TestCustomType>&) { return ""; },
+          /*deserialize=*/
+          [](const std::string&) {
+            return std::make_shared<TestCustomType>();
+          }),
+      "Trying to register duplicated serialization information for type OPAQUE");
+}
+
+} // namespace