Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Reorg mapper and evaluator #1901

Merged
merged 1 commit into from
Aug 7, 2023
Merged

Reorg mapper and evaluator #1901

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
6 changes: 3 additions & 3 deletions src/expression_evaluator/base_evaluator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}
Expand Down
6 changes: 3 additions & 3 deletions src/expression_evaluator/case_evaluator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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() {
Expand Down Expand Up @@ -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());
Expand All @@ -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());
Expand Down
8 changes: 4 additions & 4 deletions src/expression_evaluator/function_evaluator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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());
}
Expand All @@ -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);
Expand Down
2 changes: 1 addition & 1 deletion src/expression_evaluator/node_rel_evaluator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down
4 changes: 2 additions & 2 deletions src/expression_evaluator/path_evaluator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down Expand Up @@ -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());
Expand Down
17 changes: 8 additions & 9 deletions src/include/expression_evaluator/base_evaluator.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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_; }

Expand All @@ -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
Expand Down
18 changes: 9 additions & 9 deletions src/include/expression_evaluator/case_evaluator.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand All @@ -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)} {}

Expand All @@ -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(
Expand Down Expand Up @@ -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;
};
Expand Down
8 changes: 4 additions & 4 deletions src/include/expression_evaluator/function_evaluator.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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(
Expand All @@ -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(
Expand Down
6 changes: 3 additions & 3 deletions src/include/expression_evaluator/literal_evaluator.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}

Expand Down
10 changes: 5 additions & 5 deletions src/include/expression_evaluator/node_rel_evaluator.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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());
}
Expand Down
10 changes: 5 additions & 5 deletions src/include/expression_evaluator/path_evaluator.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Expand All @@ -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());
}
Expand Down
6 changes: 3 additions & 3 deletions src/include/expression_evaluator/reference_evaluator.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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_);
}

Expand Down
18 changes: 9 additions & 9 deletions ...lude/processor/mapper/expression_mapper.h → src/include/processor/expression_mapper.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
};

Expand Down
2 changes: 1 addition & 1 deletion src/include/processor/operator/ddl/add_node_property.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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),
Expand Down
4 changes: 2 additions & 2 deletions src/include/processor/operator/ddl/add_property.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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},
Expand Down Expand Up @@ -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;
};

Expand Down
2 changes: 1 addition & 1 deletion src/include/processor/operator/ddl/add_rel_property.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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),
Expand Down