Make PlanNode enum to string conversions code consistent (#11144)

Summary:
PartitionedOutputNode and LocalPartitionNode enum to string conversions were not consistent with how the enum to string conversions are done for rest of the PlanNodes enum fields.

Pull Request resolved: #11144

Reviewed By: Yuhta

Differential Revision: D63764489

Pulled By: xiaoxmeng

fbshipit-source-id: a1812b25556c5b9b079e4b4279c135db5b01e3b3

velox/core/PlanNode.cpp

@@ -1971,17 +1971,6 @@ PlanNodePtr LocalPartitionNode::create(
       deserializeSources(obj, context));
 }
 
-// static
-const char* LocalPartitionNode::typeName(Type type) {
-  switch (type) {
-    case Type::kGather:
-      return "GATHER";
-    case Type::kRepartition:
-      return "REPARTITION";
-  }
-  VELOX_UNREACHABLE();
-}
-
 namespace {
 std::unordered_map<LocalPartitionNode::Type, std::string>
 localPartitionTypeNames() {
@@ -1992,6 +1981,12 @@ localPartitionTypeNames() {
 }
 } // namespace
 
+// static
+const char* LocalPartitionNode::typeName(Type type) {
+  static const auto kLocalPartitionTypeNames = localPartitionTypeNames();
+  return kLocalPartitionTypeNames.at(type).c_str();
+}
+
 // static
 LocalPartitionNode::Type LocalPartitionNode::typeFromName(
     const std::string& name) {
@@ -2016,32 +2011,29 @@ PlanNodePtr EnforceSingleRowNode::create(
       deserializePlanNodeId(obj), deserializeSingleSource(obj, context));
 }
 
+namespace {
+std::unordered_map<PartitionedOutputNode::Kind, std::string>
+partitionKindNames() {
+  return {
+      {PartitionedOutputNode::Kind::kPartitioned, "PARTITIONED"},
+      {PartitionedOutputNode::Kind::kBroadcast, "BROADCAST"},
+      {PartitionedOutputNode::Kind::kArbitrary, "ARBITRARY"},
+  };
+}
+
+} // namespace
+
 // static
 std::string PartitionedOutputNode::kindString(Kind kind) {
-  switch (kind) {
-    case Kind::kPartitioned:
-      return "PARTITIONED";
-    case Kind::kBroadcast:
-      return "BROADCAST";
-    case Kind::kArbitrary:
-      return "ARBITRARY";
-    default:
-      return fmt::format("INVALID OUTPUT KIND {}", static_cast<int>(kind));
-  }
+  static const auto kPartitionNames = partitionKindNames();
+  return kPartitionNames.at(kind);
 }
 
 // static
 PartitionedOutputNode::Kind PartitionedOutputNode::stringToKind(
-    std::string str) {
-  if (str == "PARTITIONED") {
-    return Kind::kPartitioned;
-  } else if (str == "BROADCAST") {
-    return Kind::kBroadcast;
-  } else if (str == "ARBITRARY") {
-    return Kind::kArbitrary;
-  } else {
-    VELOX_FAIL("Unknown output buffer type: {}", str);
-  }
+    const std::string& name) {
+  static const auto kPartitionKinds = invertMap(partitionKindNames());
+  return kPartitionKinds.at(name);
 }
 
 void PartitionedOutputNode::addDetails(std::stringstream& stream) const {

velox/core/PlanNode.h

@@ -1221,7 +1221,7 @@ class PartitionedOutputNode : public PlanNode {
     kArbitrary,
   };
   static std::string kindString(Kind kind);
-  static Kind stringToKind(std::string str);
+  static Kind stringToKind(const std::string& str);
 
   PartitionedOutputNode(
       const PlanNodeId& id,

velox/exec/tests/OutputBufferManagerTest.cpp

@@ -535,10 +535,10 @@ TEST_F(OutputBufferManagerTest, outputType) {
       PartitionedOutputNode::kindString(
           PartitionedOutputNode::Kind::kBroadcast),
       "BROADCAST");
-  ASSERT_EQ(
+  EXPECT_THROW(
       PartitionedOutputNode::kindString(
           static_cast<PartitionedOutputNode::Kind>(100)),
-      "INVALID OUTPUT KIND 100");
+      std::out_of_range);
 }
 
 TEST_F(OutputBufferManagerTest, destinationBuffer) {