refactor: Reduce usage of dynamic_cast in ExprCompiler (facebookincubator#14145)

Summary:
Pull Request resolved: facebookincubator#14145

ExprCompiler uses dynamic_cast to switch on expr type. This is inefficient and shows up in the profile.

Introduce ExprKind enum and ITypedExpr::kind() getter to allow for more efficient switching.

Also, introduce SpecialFormKind enum.

Also, remove unnecessary includes.

Reviewed By: xiaoxmeng

Differential Revision: D78553108

fbshipit-source-id: 3469811bfc3c3f700ac5f5fd9bb71fdac5d336d3

Author: mbasmanova

velox/benchmarks/basic/SimpleCastExpr.cpp

@@ -19,6 +19,7 @@
 
 #include <gflags/gflags.h>
 
+#include "velox/core/Expressions.h"
 #include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 

velox/core/CMakeLists.txt

@@ -18,6 +18,7 @@ endif()
 velox_add_library(
   velox_core
   Expressions.cpp
+  ITypedExpr.cpp
   FilterToExpression.cpp
   PlanFragment.cpp
   PlanNode.cpp

velox/core/Expressions.cpp

@@ -640,7 +640,7 @@ TypePtr toRowType(
 ConcatTypedExpr::ConcatTypedExpr(
     const std::vector<std::string>& names,
     const std::vector<TypedExprPtr>& inputs)
-    : ITypedExpr{toRowType(names, inputs), inputs} {}
+    : ITypedExpr{ExprKind::kConcat, toRowType(names, inputs), inputs} {}
 
 std::string ConcatTypedExpr::toString() const {
   std::string str{};

velox/core/Expressions.h

@@ -23,7 +23,8 @@ namespace facebook::velox::core {
 
 class InputTypedExpr : public ITypedExpr {
  public:
-  explicit InputTypedExpr(TypePtr type) : ITypedExpr{std::move(type)} {}
+  explicit InputTypedExpr(TypePtr type)
+      : ITypedExpr{ExprKind::kInput, std::move(type)} {}
 
   bool operator==(const ITypedExpr& other) const final {
     const auto* casted = dynamic_cast<const InputTypedExpr*>(&other);
@@ -59,12 +60,13 @@ class ConstantTypedExpr : public ITypedExpr {
   // Creates constant expression. For complex types, only
   // Variant::null() value is supported.
   ConstantTypedExpr(TypePtr type, Variant value)
-      : ITypedExpr{std::move(type)}, value_{std::move(value)} {}
+      : ITypedExpr{ExprKind::kConstant, std::move(type)},
+        value_{std::move(value)} {}
 
   // Creates constant expression of scalar or complex type. The value comes from
   // index zero.
   explicit ConstantTypedExpr(const VectorPtr& value)
-      : ITypedExpr{value->type()},
+      : ITypedExpr{ExprKind::kConstant, value->type()},
         valueVector_{
             value->isConstantEncoding()
                 ? value
@@ -184,7 +186,7 @@ class CallTypedExpr : public ITypedExpr {
       TypePtr type,
       std::vector<TypedExprPtr> inputs,
       std::string name)
-      : ITypedExpr{std::move(type), std::move(inputs)},
+      : ITypedExpr{ExprKind::kCall, std::move(type), std::move(inputs)},
         name_(std::move(name)) {}
 
   virtual const std::string& name() const {
@@ -247,14 +249,14 @@ class FieldAccessTypedExpr : public ITypedExpr {
  public:
   /// Used as a leaf in an expression tree specifying input column by name.
   FieldAccessTypedExpr(TypePtr type, std::string name)
-      : ITypedExpr{std::move(type)},
+      : ITypedExpr{ExprKind::kFieldAccess, std::move(type)},
         name_(std::move(name)),
         isInputColumn_(true) {}
 
   /// Used as a dereference expression which selects a subfield in a struct by
   /// name.
   FieldAccessTypedExpr(TypePtr type, TypedExprPtr input, std::string name)
-      : ITypedExpr{std::move(type), {std::move(input)}},
+      : ITypedExpr{ExprKind::kFieldAccess, std::move(type), {std::move(input)}},
         name_(std::move(name)),
         isInputColumn_(dynamic_cast<const InputTypedExpr*>(inputs()[0].get())) {
   }
@@ -323,7 +325,8 @@ using FieldAccessTypedExprPtr = std::shared_ptr<const FieldAccessTypedExpr>;
 class DereferenceTypedExpr : public ITypedExpr {
  public:
   DereferenceTypedExpr(TypePtr type, TypedExprPtr input, uint32_t index)
-      : ITypedExpr{std::move(type), {std::move(input)}}, index_(index) {
+      : ITypedExpr{ExprKind::kDereference, std::move(type), {std::move(input)}},
+        index_(index) {
     // Make sure this isn't being used to access a top level column.
     VELOX_USER_CHECK_NULL(
         std::dynamic_pointer_cast<const InputTypedExpr>(inputs()[0]));
@@ -445,9 +448,11 @@ using ConcatTypedExprPtr = std::shared_ptr<const ConcatTypedExpr>;
 class LambdaTypedExpr : public ITypedExpr {
  public:
   LambdaTypedExpr(RowTypePtr signature, TypedExprPtr body)
-      : ITypedExpr(std::make_shared<FunctionType>(
-            std::vector<TypePtr>(signature->children()),
-            body->type())),
+      : ITypedExpr(
+            ExprKind::kLambda,
+            std::make_shared<FunctionType>(
+                std::vector<TypePtr>(signature->children()),
+                body->type())),
         signature_(std::move(signature)),
         body_(std::move(body)) {}
 
@@ -512,13 +517,13 @@ class CastTypedExpr : public ITypedExpr {
   /// and expected to be different from to-type.
   /// @param isTryCast Whether this expression is used for `try_cast`.
   CastTypedExpr(const TypePtr& type, const TypedExprPtr& input, bool isTryCast)
-      : ITypedExpr{type, {input}}, isTryCast_(isTryCast) {}
+      : ITypedExpr{ExprKind::kCast, type, {input}}, isTryCast_(isTryCast) {}
 
   CastTypedExpr(
       const TypePtr& type,
       const std::vector<TypedExprPtr>& inputs,
       bool isTryCast)
-      : ITypedExpr{type, inputs}, isTryCast_(isTryCast) {
+      : ITypedExpr{ExprKind::kCast, type, inputs}, isTryCast_(isTryCast) {
     VELOX_USER_CHECK_EQ(
         1, inputs.size(), "Cast expression requires exactly one input");
   }

velox/core/ITypedExpr.cpp

@@ -0,0 +1,39 @@
+/*
+ * 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 "velox/core/ITypedExpr.h"
+
+namespace facebook::velox::core {
+
+namespace {
+folly::F14FastMap<ExprKind, std::string> exprKindNames() {
+  static const folly::F14FastMap<ExprKind, std::string> kNames = {
+      {ExprKind::kInput, "INPUT"},
+      {ExprKind::kFieldAccess, "FIELD"},
+      {ExprKind::kDereference, "DEREFERENCE"},
+      {ExprKind::kCall, "CALL"},
+      {ExprKind::kCast, "CAST"},
+      {ExprKind::kConstant, "CONSTANT"},
+      {ExprKind::kConcat, "CONCAT"},
+      {ExprKind::kLambda, "LAMBDA"},
+  };
+
+  return kNames;
+}
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(ExprKind, exprKindNames);
+} // namespace facebook::velox::core

velox/core/ITypedExpr.h

@@ -19,6 +19,19 @@
 
 namespace facebook::velox::core {
 
+enum class ExprKind : int32_t {
+  kInput = 0,
+  kFieldAccess = 1,
+  kDereference = 2,
+  kCall = 3,
+  kCast = 5,
+  kConstant = 6,
+  kConcat = 7,
+  kLambda = 8,
+};
+
+VELOX_DECLARE_ENUM_NAME(ExprKind);
+
 class ITypedExpr;
 class ITypedExprVisitor;
 class ITypedExprVisitorContext;
@@ -28,21 +41,63 @@ using TypedExprPtr = std::shared_ptr<const ITypedExpr>;
 /// Strongly-typed expression, e.g. literal, function call, etc.
 class ITypedExpr : public ISerializable {
  public:
-  explicit ITypedExpr(TypePtr type) : type_{std::move(type)}, inputs_{} {}
+  ITypedExpr(ExprKind kind, TypePtr type)
+      : kind_{kind}, type_{std::move(type)}, inputs_{} {}
+
+  ITypedExpr(ExprKind kind, TypePtr type, std::vector<TypedExprPtr> inputs)
+      : kind_{kind}, type_{std::move(type)}, inputs_{std::move(inputs)} {}
 
-  ITypedExpr(TypePtr type, std::vector<TypedExprPtr> inputs)
-      : type_{std::move(type)}, inputs_{std::move(inputs)} {}
+  virtual ~ITypedExpr() = default;
+
+  ExprKind kind() const {
+    return kind_;
+  }
 
   const TypePtr& type() const {
     return type_;
   }
 
-  virtual ~ITypedExpr() = default;
-
   const std::vector<TypedExprPtr>& inputs() const {
     return inputs_;
   }
 
+  bool isInputKind() const {
+    return kind_ == ExprKind::kInput;
+  }
+
+  bool isFieldAccessKind() const {
+    return kind_ == ExprKind::kFieldAccess;
+  }
+
+  bool isDereferenceKind() const {
+    return kind_ == ExprKind::kDereference;
+  }
+
+  bool isCallKind() const {
+    return kind_ == ExprKind::kCall;
+  }
+
+  bool isCastKind() const {
+    return kind_ == ExprKind::kCast;
+  }
+
+  bool isConstantKind() const {
+    return kind_ == ExprKind::kConstant;
+  }
+
+  bool isConcatKind() const {
+    return kind_ == ExprKind::kConcat;
+  }
+
+  bool isLambdaKind() const {
+    return kind_ == ExprKind::kLambda;
+  }
+
+  template <typename T>
+  const T* asUnchecked() const {
+    return dynamic_cast<const T*>(this);
+  }
+
   /// Returns a copy of this expression with input fields replaced according
   /// to specified 'mapping'. Fields specified in the 'mapping' are replaced
   /// by the corresponding expression in 'mapping'.
@@ -88,8 +143,9 @@ class ITypedExpr : public ISerializable {
   }
 
  private:
-  TypePtr type_;
-  std::vector<TypedExprPtr> inputs_;
+  const ExprKind kind_;
+  const TypePtr type_;
+  const std::vector<TypedExprPtr> inputs_;
 };
 
 } // namespace facebook::velox::core

velox/examples/ExpressionEval.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/memory/Memory.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/Udf.h"
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"

velox/examples/OpaqueType.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/memory/Memory.h"
+#include "velox/core/Expressions.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/Udf.h"
 #include "velox/type/Type.h"

velox/expression/CastExpr.h

@@ -90,6 +90,7 @@ class CastExpr : public SpecialForm {
       bool isTryCast,
       std::shared_ptr<CastHooks> hooks)
       : SpecialForm(
+            SpecialFormKind::kCast,
             type,
             std::vector<ExprPtr>({expr}),
             isTryCast ? kTryCast.data() : kCast.data(),

velox/expression/CoalesceExpr.cpp

@@ -22,6 +22,7 @@ CoalesceExpr::CoalesceExpr(
     std::vector<ExprPtr>&& inputs,
     bool inputsSupportFlatNoNullsFastPath)
     : SpecialForm(
+          SpecialFormKind::kCoalesce,
           std::move(type),
           std::move(inputs),
           kCoalesce,
@@ -39,7 +40,7 @@ CoalesceExpr::CoalesceExpr(
   auto expectedType = resolveType(inputTypes);
   VELOX_CHECK(
       *expectedType == *this->type(),
-      "Coalesce expression type different than its inputs. Expected {} but got Actual {}.",
+      "Coalesce expression type different than its inputs. Expected {}, but got {}.",
       expectedType->toString(),
       this->type()->toString());
 }