misc: Add XxxNodePtr aliases for all plan nodes (facebookincubator#13848)

Summary: Pull Request resolved: facebookincubator#13848

Reviewed By: xiaoxmeng, kKPulla

Differential Revision: D77148982

fbshipit-source-id: 824f073a54e0e760f1fa69aa7fee8528d8c9f9a1

Author: mbasmanova

velox/core/PlanNode.h

@@ -498,6 +498,8 @@ class ArrowStreamNode : public PlanNode {
   std::shared_ptr<ArrowArrayStream> arrowStream_;
 };
 
+using ArrowStreamNodePtr = std::shared_ptr<const ArrowStreamNode>;
+
 class TraceScanNode final : public PlanNode {
  public:
   TraceScanNode(
@@ -614,6 +616,8 @@ class TraceScanNode final : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using TraceScanNodePtr = std::shared_ptr<const TraceScanNode>;
+
 class FilterNode : public PlanNode {
  public:
   FilterNode(const PlanNodeId& id, TypedExprPtr filter, PlanNodePtr source)
@@ -706,6 +710,8 @@ class FilterNode : public PlanNode {
   const TypedExprPtr filter_;
 };
 
+using FilterNodePtr = std::shared_ptr<const FilterNode>;
+
 class AbstractProjectNode : public PlanNode {
  public:
   AbstractProjectNode(
@@ -876,6 +882,8 @@ class ProjectNode : public AbstractProjectNode {
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
 };
 
+using ProjectNodePtr = std::shared_ptr<const ProjectNode>;
+
 class TableScanNode : public PlanNode {
  public:
   TableScanNode(
@@ -1529,6 +1537,8 @@ class TableWriteNode : public PlanNode {
   const connector::CommitStrategy commitStrategy_;
 };
 
+using TableWriteNodePtr = std::shared_ptr<const TableWriteNode>;
+
 class TableWriteMergeNode : public PlanNode {
  public:
   /// 'outputType' specifies the type to store the metadata of table write
@@ -1632,6 +1642,8 @@ class TableWriteMergeNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using TableWriteMergeNodePtr = std::shared_ptr<const TableWriteMergeNode>;
+
 /// For each input row, generates N rows with M columns according to
 /// specified 'projections'. 'projections' is an N x M matrix of expressions:
 /// a vector of N rows each having M columns. Each expression is either a
@@ -1735,6 +1747,8 @@ class ExpandNode : public PlanNode {
   const std::vector<std::vector<TypedExprPtr>> projections_;
 };
 
+using ExpandNodePtr = std::shared_ptr<const ExpandNode>;
+
 /// Plan node used to implement aggregations over grouping sets. Duplicates
 /// the aggregation input for each set of grouping keys. The output contains
 /// one column for each grouping key, followed by aggregation inputs, followed
@@ -1903,6 +1917,8 @@ class GroupIdNode : public PlanNode {
   const std::string groupIdName_;
 };
 
+using GroupIdNodePtr = std::shared_ptr<const GroupIdNode>;
+
 class ExchangeNode : public PlanNode {
  public:
   ExchangeNode(
@@ -1989,6 +2005,8 @@ class ExchangeNode : public PlanNode {
   const VectorSerde::Kind serdeKind_;
 };
 
+using ExchangeNodePtr = std::shared_ptr<const ExchangeNode>;
+
 class MergeExchangeNode : public ExchangeNode {
  public:
   MergeExchangeNode(
@@ -2089,6 +2107,8 @@ class MergeExchangeNode : public ExchangeNode {
   const std::vector<SortOrder> sortingOrders_;
 };
 
+using MergeExchangeNodePtr = std::shared_ptr<const MergeExchangeNode>;
+
 class LocalMergeNode : public PlanNode {
  public:
   LocalMergeNode(
@@ -2195,6 +2215,8 @@ class LocalMergeNode : public PlanNode {
   const std::vector<SortOrder> sortingOrders_;
 };
 
+using LocalMergeNodePtr = std::shared_ptr<const LocalMergeNode>;
+
 /// Calculates partition number for each row of the specified vector.
 class PartitionFunction {
  public:
@@ -2418,6 +2440,8 @@ class LocalPartitionNode : public PlanNode {
   const PartitionFunctionSpecPtr partitionFunctionSpec_;
 };
 
+using LocalPartitionNodePtr = std::shared_ptr<const LocalPartitionNode>;
+
 class PartitionedOutputNode : public PlanNode {
  public:
   enum class Kind {
@@ -2647,6 +2671,8 @@ class PartitionedOutputNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using PartitionedOutputNodePtr = std::shared_ptr<const PartitionedOutputNode>;
+
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
     std::ostream& out,
     const PartitionedOutputNode::Kind kind) {
@@ -3062,6 +3088,8 @@ class HashJoinNode : public AbstractJoinNode {
   const bool nullAware_;
 };
 
+using HashJoinNodePtr = std::shared_ptr<const HashJoinNode>;
+
 /// Represents inner/outer/semi/anti merge joins. Translates to an
 /// exec::MergeJoin operator. Assumes that both left and right input data is
 /// sorted on the join keys. A separate pipeline that puts its output into
@@ -3132,6 +3160,8 @@ class MergeJoinNode : public AbstractJoinNode {
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
 };
 
+using MergeJoinNodePtr = std::shared_ptr<const MergeJoinNode>;
+
 struct IndexLookupCondition : public ISerializable {
   /// References to an index table column.
   FieldAccessTypedExprPtr key;
@@ -3151,6 +3181,7 @@ struct IndexLookupCondition : public ISerializable {
 
   virtual std::string toString() const = 0;
 };
+
 using IndexLookupConditionPtr = std::shared_ptr<IndexLookupCondition>;
 
 /// Represents IN-LIST index lookup condition: contains('list', 'key'). 'list'
@@ -3178,6 +3209,7 @@ struct InIndexLookupCondition : public IndexLookupCondition {
  private:
   void validate() const;
 };
+
 using InIndexLookupConditionPtr = std::shared_ptr<InIndexLookupCondition>;
 
 /// Represents BETWEEN index lookup condition: 'key' between 'lower' and
@@ -3213,6 +3245,7 @@ struct BetweenIndexLookupCondition : public IndexLookupCondition {
  private:
   void validate() const;
 };
+
 using BetweenIndexLookupConditionPtr =
     std::shared_ptr<BetweenIndexLookupCondition>;
 
@@ -3376,6 +3409,8 @@ class IndexLookupJoinNode : public AbstractJoinNode {
   const std::vector<IndexLookupConditionPtr> joinConditions_;
 };
 
+using IndexLookupJoinNodePtr = std::shared_ptr<const IndexLookupJoinNode>;
+
 /// Returns true if 'planNode' is index lookup join node.
 bool isIndexLookupJoin(const core::PlanNode* planNode);
 
@@ -3520,6 +3555,8 @@ class NestedLoopJoinNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using NestedLoopJoinNodePtr = std::shared_ptr<const NestedLoopJoinNode>;
+
 // Represents the 'SortBy' node in the plan.
 class OrderByNode : public PlanNode {
  public:
@@ -3661,6 +3698,8 @@ class OrderByNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
 };
 
+using OrderByNodePtr = std::shared_ptr<const OrderByNode>;
+
 class TopNNode : public PlanNode {
  public:
   TopNNode(
@@ -3788,6 +3827,8 @@ class TopNNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
 };
 
+using TopNNodePtr = std::shared_ptr<const TopNNode>;
+
 class LimitNode : public PlanNode {
  public:
   // @param isPartial Boolean indicating whether Limit node generates partial
@@ -3912,6 +3953,8 @@ class LimitNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
 };
 
+using LimitNodePtr = std::shared_ptr<const LimitNode>;
+
 /// Expands arrays and maps into separate columns. Arrays are expanded into a
 /// single column, and maps are expanded into two columns (key, value). Can be
 /// used to expand multiple columns. In this case will produce as many rows as
@@ -4069,6 +4112,8 @@ class UnnestNode : public PlanNode {
   RowTypePtr outputType_;
 };
 
+using UnnestNodePtr = std::shared_ptr<const UnnestNode>;
+
 /// Checks that input contains at most one row. Return that row as is. If
 /// input is empty, returns a single row with all values set to null. If input
 /// contains more than one row raises an exception.
@@ -4138,6 +4183,8 @@ class EnforceSingleRowNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
 };
 
+using EnforceSingleRowNodePtr = std::shared_ptr<const EnforceSingleRowNode>;
+
 /// Adds a new column named `idName` at the end of the input columns
 /// with unique int64_t value per input row.
 ///
@@ -4244,6 +4291,8 @@ class AssignUniqueIdNode : public PlanNode {
   std::shared_ptr<std::atomic_int64_t> uniqueIdCounter_;
 };
 
+using AssignUniqueIdNodePtr = std::shared_ptr<const AssignUniqueIdNode>;
+
 /// PlanNode used for evaluating Sql window functions.
 /// All window functions evaluated in the operator have the same
 /// window spec (partition keys + order columns).
@@ -4491,6 +4540,8 @@ class WindowNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using WindowNodePtr = std::shared_ptr<const WindowNode>;
+
 /// Optimized version of a WindowNode for a single row_number function with an
 /// optional limit and no sorting.
 /// The output of this node contains all input columns followed by an optional
@@ -4625,6 +4676,8 @@ class RowNumberNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using RowNumberNodePtr = std::shared_ptr<const RowNumberNode>;
+
 /// The MarkDistinct operator marks unique rows based on distinctKeys.
 /// The result is put in a new markerName column alongside the original input.
 /// @param markerName Name of the output mask channel.
@@ -4735,6 +4788,8 @@ class MarkDistinctNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using MarkDistinctNodePtr = std::shared_ptr<const MarkDistinctNode>;
+
 /// Optimized version of a WindowNode for a single row_number function with a
 /// limit over sorted partitions.
 /// The output of this node contains all input columns followed by an optional
@@ -4913,6 +4968,8 @@ class TopNRowNumberNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using TopNRowNumberNodePtr = std::shared_ptr<const TopNRowNumberNode>;
+
 class PlanNodeVisitorContext {
  public:
   virtual ~PlanNodeVisitorContext() = default;