Merge pull request #1901 from kuzudb/reorg-mapper

Reorg mapper and evaluator
kuzudb · Aug 7, 2023 · 315d7c7 · 315d7c7
2 parents 5370cdf + 08fdeb2
commit 315d7c7
Show file tree

Hide file tree

Showing 69 changed files with 146 additions and 149 deletions.
diff --git a/src/expression_evaluator/base_evaluator.cpp b/src/expression_evaluator/base_evaluator.cpp
@@ -3,16 +3,16 @@
 namespace kuzu {
 namespace evaluator {
 
-void BaseExpressionEvaluator::init(
+void ExpressionEvaluator::init(
     const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager) {
     for (auto& child : children) {
         child->init(resultSet, memoryManager);
     }
     resolveResultVector(resultSet, memoryManager);
 }
 
-void BaseExpressionEvaluator::resolveResultStateFromChildren(
-    const std::vector<BaseExpressionEvaluator*>& inputEvaluators) {
+void ExpressionEvaluator::resolveResultStateFromChildren(
+    const std::vector<ExpressionEvaluator*>& inputEvaluators) {
     if (resultVector->state != nullptr) {
         return;
     }

diff --git a/src/expression_evaluator/case_evaluator.cpp b/src/expression_evaluator/case_evaluator.cpp
@@ -19,7 +19,7 @@ void CaseExpressionEvaluator::init(const ResultSet& resultSet, MemoryManager* me
         alternativeEvaluator->init(resultSet, memoryManager);
     }
     elseEvaluator->init(resultSet, memoryManager);
-    BaseExpressionEvaluator::init(resultSet, memoryManager);
+    ExpressionEvaluator::init(resultSet, memoryManager);
 }
 
 void CaseExpressionEvaluator::evaluate() {
@@ -58,7 +58,7 @@ bool CaseExpressionEvaluator::select(SelectionVector& selVector) {
     return numSelectedValues > 0;
 }
 
-std::unique_ptr<BaseExpressionEvaluator> CaseExpressionEvaluator::clone() {
+std::unique_ptr<ExpressionEvaluator> CaseExpressionEvaluator::clone() {
     std::vector<std::unique_ptr<CaseAlternativeEvaluator>> clonedAlternativeEvaluators;
     for (auto& alternative : alternativeEvaluators) {
         clonedAlternativeEvaluators.push_back(alternative->clone());
@@ -70,7 +70,7 @@ std::unique_ptr<BaseExpressionEvaluator> CaseExpressionEvaluator::clone() {
 void CaseExpressionEvaluator::resolveResultVector(
     const ResultSet& resultSet, MemoryManager* memoryManager) {
     resultVector = std::make_shared<ValueVector>(expression->dataType, memoryManager);
-    std::vector<BaseExpressionEvaluator*> inputEvaluators;
+    std::vector<ExpressionEvaluator*> inputEvaluators;
     for (auto& alternative : alternativeEvaluators) {
         inputEvaluators.push_back(alternative->whenEvaluator.get());
         inputEvaluators.push_back(alternative->thenEvaluator.get());

diff --git a/src/expression_evaluator/function_evaluator.cpp b/src/expression_evaluator/function_evaluator.cpp
@@ -10,7 +10,7 @@ namespace kuzu {
 namespace evaluator {
 
 void FunctionExpressionEvaluator::init(const ResultSet& resultSet, MemoryManager* memoryManager) {
-    BaseExpressionEvaluator::init(resultSet, memoryManager);
+    ExpressionEvaluator::init(resultSet, memoryManager);
     execFunc = ((binder::ScalarFunctionExpression&)*expression).execFunc;
     if (expression->dataType.getLogicalTypeID() == LogicalTypeID::BOOL) {
         selectFunc = ((binder::ScalarFunctionExpression&)*expression).selectFunc;
@@ -48,8 +48,8 @@ bool FunctionExpressionEvaluator::select(SelectionVector& selVector) {
     return selectFunc(parameters, selVector);
 }
 
-std::unique_ptr<BaseExpressionEvaluator> FunctionExpressionEvaluator::clone() {
-    std::vector<std::unique_ptr<BaseExpressionEvaluator>> clonedChildren;
+std::unique_ptr<ExpressionEvaluator> FunctionExpressionEvaluator::clone() {
+    std::vector<std::unique_ptr<ExpressionEvaluator>> clonedChildren;
     for (auto& child : children) {
         clonedChildren.push_back(child->clone());
     }
@@ -59,7 +59,7 @@ std::unique_ptr<BaseExpressionEvaluator> FunctionExpressionEvaluator::clone() {
 void FunctionExpressionEvaluator::resolveResultVector(
     const ResultSet& resultSet, MemoryManager* memoryManager) {
     resultVector = std::make_shared<ValueVector>(expression->dataType, memoryManager);
-    std::vector<BaseExpressionEvaluator*> inputEvaluators;
+    std::vector<ExpressionEvaluator*> inputEvaluators;
     inputEvaluators.reserve(children.size());
     for (auto& child : children) {
         parameters.push_back(child->resultVector);

diff --git a/src/expression_evaluator/node_rel_evaluator.cpp b/src/expression_evaluator/node_rel_evaluator.cpp
@@ -19,7 +19,7 @@ void NodeRelExpressionEvaluator::evaluate() {
 void NodeRelExpressionEvaluator::resolveResultVector(
     const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager) {
     resultVector = std::make_shared<ValueVector>(nodeOrRel->getDataType(), memoryManager);
-    std::vector<BaseExpressionEvaluator*> inputEvaluators;
+    std::vector<ExpressionEvaluator*> inputEvaluators;
     inputEvaluators.reserve(children.size());
     for (auto& child : children) {
         parameters.push_back(child->resultVector);

diff --git a/src/expression_evaluator/path_evaluator.cpp b/src/expression_evaluator/path_evaluator.cpp
@@ -27,7 +27,7 @@ static std::vector<common::ValueVector*> getFieldVectors(
 
 void PathExpressionEvaluator::init(
     const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager) {
-    BaseExpressionEvaluator::init(resultSet, memoryManager);
+    ExpressionEvaluator::init(resultSet, memoryManager);
     auto resultNodesIdx = StructType::getFieldIdx(&resultVector->dataType, InternalKeyword::NODES);
     resultNodesVector = StructVector::getFieldVector(resultVector.get(), resultNodesIdx).get();
     auto resultNodesDataVector = ListVector::getDataVector(resultNodesVector);
@@ -207,7 +207,7 @@ void PathExpressionEvaluator::copyFieldVectors(common::offset_t inputVectorPos,
 void PathExpressionEvaluator::resolveResultVector(
     const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager) {
     resultVector = std::make_shared<ValueVector>(pathExpression->getDataType(), memoryManager);
-    std::vector<BaseExpressionEvaluator*> inputEvaluators;
+    std::vector<ExpressionEvaluator*> inputEvaluators;
     inputEvaluators.reserve(children.size());
     for (auto& child : children) {
         inputEvaluators.push_back(child.get());

diff --git a/src/include/expression_evaluator/base_evaluator.h b/src/include/expression_evaluator/base_evaluator.h
@@ -8,16 +8,16 @@
 namespace kuzu {
 namespace evaluator {
 
-class BaseExpressionEvaluator {
+class ExpressionEvaluator {
 public:
-    BaseExpressionEvaluator() = default;
+    ExpressionEvaluator() = default;
     // Leaf evaluators (reference or literal)
-    explicit BaseExpressionEvaluator(bool isResultFlat) : isResultFlat_{isResultFlat} {}
+    explicit ExpressionEvaluator(bool isResultFlat) : isResultFlat_{isResultFlat} {}
 
-    explicit BaseExpressionEvaluator(std::vector<std::unique_ptr<BaseExpressionEvaluator>> children)
+    explicit ExpressionEvaluator(std::vector<std::unique_ptr<ExpressionEvaluator>> children)
         : children{std::move(children)} {}
 
-    virtual ~BaseExpressionEvaluator() = default;
+    virtual ~ExpressionEvaluator() = default;
 
     inline bool isResultFlat() const { return isResultFlat_; }
 
@@ -27,21 +27,20 @@ class BaseExpressionEvaluator {
 
     virtual bool select(common::SelectionVector& selVector) = 0;
 
-    virtual std::unique_ptr<BaseExpressionEvaluator> clone() = 0;
+    virtual std::unique_ptr<ExpressionEvaluator> clone() = 0;
 
 protected:
     virtual void resolveResultVector(
         const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager) = 0;
 
-    void resolveResultStateFromChildren(
-        const std::vector<BaseExpressionEvaluator*>& inputEvaluators);
+    void resolveResultStateFromChildren(const std::vector<ExpressionEvaluator*>& inputEvaluators);
 
 public:
     std::shared_ptr<common::ValueVector> resultVector;
 
 protected:
     bool isResultFlat_ = true;
-    std::vector<std::unique_ptr<BaseExpressionEvaluator>> children;
+    std::vector<std::unique_ptr<ExpressionEvaluator>> children;
 };
 
 } // namespace evaluator

diff --git a/src/include/expression_evaluator/case_evaluator.h b/src/include/expression_evaluator/case_evaluator.h
@@ -9,12 +9,12 @@ namespace kuzu {
 namespace evaluator {
 
 struct CaseAlternativeEvaluator {
-    std::unique_ptr<BaseExpressionEvaluator> whenEvaluator;
-    std::unique_ptr<BaseExpressionEvaluator> thenEvaluator;
+    std::unique_ptr<ExpressionEvaluator> whenEvaluator;
+    std::unique_ptr<ExpressionEvaluator> thenEvaluator;
     std::unique_ptr<common::SelectionVector> whenSelVector;
 
-    CaseAlternativeEvaluator(std::unique_ptr<BaseExpressionEvaluator> whenEvaluator,
-        std::unique_ptr<BaseExpressionEvaluator> thenEvaluator)
+    CaseAlternativeEvaluator(std::unique_ptr<ExpressionEvaluator> whenEvaluator,
+        std::unique_ptr<ExpressionEvaluator> thenEvaluator)
         : whenEvaluator{std::move(whenEvaluator)}, thenEvaluator{std::move(thenEvaluator)} {}
 
     void init(const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager);
@@ -25,12 +25,12 @@ struct CaseAlternativeEvaluator {
     }
 };
 
-class CaseExpressionEvaluator : public BaseExpressionEvaluator {
+class CaseExpressionEvaluator : public ExpressionEvaluator {
 public:
     CaseExpressionEvaluator(std::shared_ptr<binder::Expression> expression,
         std::vector<std::unique_ptr<CaseAlternativeEvaluator>> alternativeEvaluators,
-        std::unique_ptr<BaseExpressionEvaluator> elseEvaluator)
-        : BaseExpressionEvaluator{}, expression{std::move(expression)},
+        std::unique_ptr<ExpressionEvaluator> elseEvaluator)
+        : ExpressionEvaluator{}, expression{std::move(expression)},
           alternativeEvaluators{std::move(alternativeEvaluators)}, elseEvaluator{
                                                                        std::move(elseEvaluator)} {}
 
@@ -41,7 +41,7 @@ class CaseExpressionEvaluator : public BaseExpressionEvaluator {
 
     bool select(common::SelectionVector& selVector) override;
 
-    std::unique_ptr<BaseExpressionEvaluator> clone() override;
+    std::unique_ptr<ExpressionEvaluator> clone() override;
 
 protected:
     void resolveResultVector(
@@ -77,7 +77,7 @@ class CaseExpressionEvaluator : public BaseExpressionEvaluator {
 private:
     std::shared_ptr<binder::Expression> expression;
     std::vector<std::unique_ptr<CaseAlternativeEvaluator>> alternativeEvaluators;
-    std::unique_ptr<BaseExpressionEvaluator> elseEvaluator;
+    std::unique_ptr<ExpressionEvaluator> elseEvaluator;
 
     std::bitset<common::DEFAULT_VECTOR_CAPACITY> filledMask;
 };

diff --git a/src/include/expression_evaluator/function_evaluator.h b/src/include/expression_evaluator/function_evaluator.h
@@ -6,11 +6,11 @@
 namespace kuzu {
 namespace evaluator {
 
-class FunctionExpressionEvaluator : public BaseExpressionEvaluator {
+class FunctionExpressionEvaluator : public ExpressionEvaluator {
 public:
     FunctionExpressionEvaluator(std::shared_ptr<binder::Expression> expression,
-        std::vector<std::unique_ptr<BaseExpressionEvaluator>> children)
-        : BaseExpressionEvaluator{std::move(children)},
+        std::vector<std::unique_ptr<ExpressionEvaluator>> children)
+        : ExpressionEvaluator{std::move(children)},
           expression{std::move(expression)}, execFunc{nullptr}, selectFunc{nullptr} {}
 
     void init(
@@ -20,7 +20,7 @@ class FunctionExpressionEvaluator : public BaseExpressionEvaluator {
 
     bool select(common::SelectionVector& selVector) override;
 
-    std::unique_ptr<BaseExpressionEvaluator> clone() override;
+    std::unique_ptr<ExpressionEvaluator> clone() override;
 
 protected:
     void resolveResultVector(

diff --git a/src/include/expression_evaluator/literal_evaluator.h b/src/include/expression_evaluator/literal_evaluator.h
@@ -5,18 +5,18 @@
 namespace kuzu {
 namespace evaluator {
 
-class LiteralExpressionEvaluator : public BaseExpressionEvaluator {
+class LiteralExpressionEvaluator : public ExpressionEvaluator {
 public:
     LiteralExpressionEvaluator(std::shared_ptr<common::Value> value)
-        : BaseExpressionEvaluator{true /* isResultFlat */}, value{std::move(value)} {}
+        : ExpressionEvaluator{true /* isResultFlat */}, value{std::move(value)} {}
 
     ~LiteralExpressionEvaluator() = default;
 
     inline void evaluate() override {}
 
     bool select(common::SelectionVector& selVector) override;
 
-    inline std::unique_ptr<BaseExpressionEvaluator> clone() override {
+    inline std::unique_ptr<ExpressionEvaluator> clone() override {
         return make_unique<LiteralExpressionEvaluator>(value);
     }
 

diff --git a/src/include/expression_evaluator/node_rel_evaluator.h b/src/include/expression_evaluator/node_rel_evaluator.h
@@ -6,20 +6,20 @@
 namespace kuzu {
 namespace evaluator {
 
-class NodeRelExpressionEvaluator : public BaseExpressionEvaluator {
+class NodeRelExpressionEvaluator : public ExpressionEvaluator {
 public:
     NodeRelExpressionEvaluator(std::shared_ptr<binder::Expression> nodeOrRel,
-        std::vector<std::unique_ptr<BaseExpressionEvaluator>> children)
-        : BaseExpressionEvaluator{std::move(children)}, nodeOrRel{std::move(nodeOrRel)} {}
+        std::vector<std::unique_ptr<ExpressionEvaluator>> children)
+        : ExpressionEvaluator{std::move(children)}, nodeOrRel{std::move(nodeOrRel)} {}
 
     void evaluate() final;
 
     bool select(common::SelectionVector& selVector) final {
         throw common::NotImplementedException("NodeExpressionEvaluator::select");
     }
 
-    inline std::unique_ptr<BaseExpressionEvaluator> clone() final {
-        std::vector<std::unique_ptr<BaseExpressionEvaluator>> clonedChildren;
+    inline std::unique_ptr<ExpressionEvaluator> clone() final {
+        std::vector<std::unique_ptr<ExpressionEvaluator>> clonedChildren;
         for (auto& child : children) {
             clonedChildren.push_back(child->clone());
         }

diff --git a/src/include/expression_evaluator/path_evaluator.h b/src/include/expression_evaluator/path_evaluator.h
@@ -6,11 +6,11 @@
 namespace kuzu {
 namespace evaluator {
 
-class PathExpressionEvaluator : public BaseExpressionEvaluator {
+class PathExpressionEvaluator : public ExpressionEvaluator {
 public:
     PathExpressionEvaluator(std::shared_ptr<binder::PathExpression> pathExpression,
-        std::vector<std::unique_ptr<BaseExpressionEvaluator>> children)
-        : BaseExpressionEvaluator{std::move(children)}, pathExpression{std::move(pathExpression)} {}
+        std::vector<std::unique_ptr<ExpressionEvaluator>> children)
+        : ExpressionEvaluator{std::move(children)}, pathExpression{std::move(pathExpression)} {}
 
     void init(const processor::ResultSet& resultSet, storage::MemoryManager* memoryManager) final;
 
@@ -20,8 +20,8 @@ class PathExpressionEvaluator : public BaseExpressionEvaluator {
         throw common::NotImplementedException("PathExpressionEvaluator::select");
     }
 
-    inline std::unique_ptr<BaseExpressionEvaluator> clone() final {
-        std::vector<std::unique_ptr<BaseExpressionEvaluator>> clonedChildren;
+    inline std::unique_ptr<ExpressionEvaluator> clone() final {
+        std::vector<std::unique_ptr<ExpressionEvaluator>> clonedChildren;
         for (auto& child : children) {
             clonedChildren.push_back(child->clone());
         }

diff --git a/src/include/expression_evaluator/reference_evaluator.h b/src/include/expression_evaluator/reference_evaluator.h
@@ -5,16 +5,16 @@
 namespace kuzu {
 namespace evaluator {
 
-class ReferenceExpressionEvaluator : public BaseExpressionEvaluator {
+class ReferenceExpressionEvaluator : public ExpressionEvaluator {
 public:
     explicit ReferenceExpressionEvaluator(const processor::DataPos& vectorPos, bool isResultFlat)
-        : BaseExpressionEvaluator{isResultFlat}, vectorPos{vectorPos} {}
+        : ExpressionEvaluator{isResultFlat}, vectorPos{vectorPos} {}
 
     inline void evaluate() override {}
 
     bool select(common::SelectionVector& selVector) override;
 
-    inline std::unique_ptr<BaseExpressionEvaluator> clone() override {
+    inline std::unique_ptr<ExpressionEvaluator> clone() override {
         return std::make_unique<ReferenceExpressionEvaluator>(vectorPos, isResultFlat_);
     }
 

diff --git a/...lude/processor/mapper/expression_mapper.h → src/include/processor/expression_mapper.h b/...lude/processor/mapper/expression_mapper.h → src/include/processor/expression_mapper.h
@@ -14,32 +14,32 @@ class PlanMapper;
 class ExpressionMapper {
 
 public:
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapExpression(
         const std::shared_ptr<binder::Expression>& expression, const planner::Schema& schema);
 
 private:
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapLiteralExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapLiteralExpression(
         const std::shared_ptr<binder::Expression>& expression);
 
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapParameterExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapParameterExpression(
         const std::shared_ptr<binder::Expression>& expression);
 
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapReferenceExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapReferenceExpression(
         const std::shared_ptr<binder::Expression>& expression, const planner::Schema& schema);
 
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapCaseExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapCaseExpression(
         const std::shared_ptr<binder::Expression>& expression, const planner::Schema& schema);
 
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapFunctionExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapFunctionExpression(
         const std::shared_ptr<binder::Expression>& expression, const planner::Schema& schema);
 
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapNodeExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapNodeExpression(
         const std::shared_ptr<binder::Expression>& expression, const planner::Schema& schema);
 
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapRelExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapRelExpression(
         const std::shared_ptr<binder::Expression>& expression, const planner::Schema& schema);
 
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> mapPathExpression(
+    std::unique_ptr<evaluator::ExpressionEvaluator> mapPathExpression(
         const std::shared_ptr<binder::Expression>& expression, const planner::Schema& schema);
 };
 

diff --git a/src/include/processor/operator/ddl/add_node_property.h b/src/include/processor/operator/ddl/add_node_property.h
@@ -9,7 +9,7 @@ class AddNodeProperty : public AddProperty {
 public:
     AddNodeProperty(catalog::Catalog* catalog, common::table_id_t tableID, std::string propertyName,
         std::unique_ptr<common::LogicalType> dataType,
-        std::unique_ptr<evaluator::BaseExpressionEvaluator> expressionEvaluator,
+        std::unique_ptr<evaluator::ExpressionEvaluator> expressionEvaluator,
         storage::StorageManager& storageManager, const DataPos& outputPos, uint32_t id,
         const std::string& paramsString)
         : AddProperty{catalog, tableID, std::move(propertyName), std::move(dataType),

diff --git a/src/include/processor/operator/ddl/add_property.h b/src/include/processor/operator/ddl/add_property.h
@@ -11,7 +11,7 @@ class AddProperty : public DDL {
 public:
     AddProperty(catalog::Catalog* catalog, common::table_id_t tableID, std::string propertyName,
         std::unique_ptr<common::LogicalType> dataType,
-        std::unique_ptr<evaluator::BaseExpressionEvaluator> expressionEvaluator,
+        std::unique_ptr<evaluator::ExpressionEvaluator> expressionEvaluator,
         storage::StorageManager& storageManager, const DataPos& outputPos, uint32_t id,
         const std::string& paramsString)
         : DDL{PhysicalOperatorType::ADD_PROPERTY, catalog, outputPos, id, paramsString},
@@ -39,7 +39,7 @@ class AddProperty : public DDL {
     common::table_id_t tableID;
     std::string propertyName;
     std::unique_ptr<common::LogicalType> dataType;
-    std::unique_ptr<evaluator::BaseExpressionEvaluator> expressionEvaluator;
+    std::unique_ptr<evaluator::ExpressionEvaluator> expressionEvaluator;
     storage::StorageManager& storageManager;
 };
 

diff --git a/src/include/processor/operator/ddl/add_rel_property.h b/src/include/processor/operator/ddl/add_rel_property.h
@@ -11,7 +11,7 @@ class AddRelProperty : public AddProperty {
 public:
     AddRelProperty(catalog::Catalog* catalog, common::table_id_t tableID, std::string propertyName,
         std::unique_ptr<common::LogicalType> dataType,
-        std::unique_ptr<evaluator::BaseExpressionEvaluator> expressionEvaluator,
+        std::unique_ptr<evaluator::ExpressionEvaluator> expressionEvaluator,
         storage::StorageManager& storageManager, const DataPos& outputPos, uint32_t id,
         const std::string& paramsString)
         : AddProperty(catalog, tableID, std::move(propertyName), std::move(dataType),