update

kuzudb · Jul 19, 2023 · fbc47c0 · fbc47c0
1 parent b736076
commit fbc47c0
Show file tree

Hide file tree

Showing 4 changed files with 41 additions and 25 deletions.
diff --git a/src/include/parser/expression/parsed_case_expression.h b/src/include/parser/expression/parsed_case_expression.h
@@ -25,7 +25,7 @@ struct ParsedCaseAlternative {
 // 2. CASE
 //    WHEN a.age = 20 THEN ...
 class ParsedCaseExpression : public ParsedExpression {
-    friend class ParsedExpressionCollector;
+    friend class ParsedExpressionChildrenSetter;
 
 public:
     explicit ParsedCaseExpression(std::string raw)

diff --git a/src/include/parser/expression/parsed_expression.h b/src/include/parser/expression/parsed_expression.h
@@ -10,13 +10,12 @@ namespace kuzu {
 namespace parser {
 
 class ParsedExpression;
-class ParsedExpressionVisitor;
-class ParsedExpressionCollector;
+class ParsedExpressionChildrenCollector;
 using parsed_expression_vector = std::vector<std::unique_ptr<ParsedExpression>>;
 
 class ParsedExpression {
-    friend class ParsedExpressionVisitor;
-    friend class ParsedExpressionCollector;
+    friend class ParsedExpressionChildrenCollector;
+    friend class ParsedExpressionChildrenSetter;
 
 public:
     ParsedExpression(

diff --git a/src/include/parser/parsed_expression_visitor.h b/src/include/parser/parsed_expression_visitor.h
@@ -7,16 +7,20 @@
 namespace kuzu {
 namespace parser {
 
-class ParsedExpressionCollector {
+class ParsedExpressionChildrenCollector {
 public:
     static std::vector<ParsedExpression*> collectChildren(const ParsedExpression& expression);
 
-    static inline void setChild(kuzu::parser::ParsedExpression& expression, uint64_t idx,
-        std::unique_ptr<ParsedExpression> expressionToSet);
-
 private:
     static std::vector<ParsedExpression*> collectCaseChildren(const ParsedExpression& expression);
+};
 
+class ParsedExpressionChildrenSetter {
+public:
+    static void setChild(kuzu::parser::ParsedExpression& expression, uint64_t idx,
+        std::unique_ptr<ParsedExpression> expressionToSet);
+
+private:
     static void setCaseChild(kuzu::parser::ParsedExpression& expression, uint64_t idx,
         std::unique_ptr<ParsedExpression> expressionToSet);
 };

diff --git a/src/parser/parsed_expression_visitor.cpp b/src/parser/parsed_expression_visitor.cpp
@@ -1,40 +1,35 @@
 #include "parser/parsed_expression_visitor.h"
 
+#include "common/exception.h"
 #include "parser/expression/parsed_case_expression.h"
 
 namespace kuzu {
 namespace parser {
 
-std::vector<ParsedExpression*> ParsedExpressionCollector::collectChildren(
+std::vector<ParsedExpression*> ParsedExpressionChildrenCollector::collectChildren(
     const kuzu::parser::ParsedExpression& expression) {
     switch (expression.getExpressionType()) {
     case common::ExpressionType::CASE_ELSE: {
         return collectCaseChildren(expression);
     }
-    default: {
+    case common::ExpressionType::FUNCTION:
+    case common::ExpressionType::LITERAL:
+    case common::ExpressionType::PROPERTY:
+    case common::ExpressionType::VARIABLE: {
         std::vector<ParsedExpression*> parsedExpressions;
         parsedExpressions.reserve(expression.getNumChildren());
         for (auto& child : expression.children) {
             parsedExpressions.push_back(child.get());
         }
         return parsedExpressions;
     }
-    }
-}
-
-void ParsedExpressionCollector::setChild(kuzu::parser::ParsedExpression& expression, uint64_t idx,
-    std::unique_ptr<ParsedExpression> expressionToSet) {
-    switch (expression.getExpressionType()) {
-    case common::ExpressionType::CASE_ELSE: {
-        return setCaseChild(expression, idx, std::move(expressionToSet));
-    }
     default: {
-        expression.children[idx] = std::move(expressionToSet);
+        throw common::NotImplementedException{"ParsedExpressionChildrenCollector::collectChildren"};
     }
     }
 }
 
-std::vector<ParsedExpression*> ParsedExpressionCollector::collectCaseChildren(
+std::vector<ParsedExpression*> ParsedExpressionChildrenCollector::collectCaseChildren(
     const ParsedExpression& expression) {
     std::vector<ParsedExpression*> children;
     auto& parsedCaseExpr = reinterpret_cast<const ParsedCaseExpression&>(expression);
@@ -48,7 +43,25 @@ std::vector<ParsedExpression*> ParsedExpressionCollector::collectCaseChildren(
     return children;
 }
 
-void ParsedExpressionCollector::setCaseChild(kuzu::parser::ParsedExpression& expression,
+void ParsedExpressionChildrenSetter::setChild(kuzu::parser::ParsedExpression& expression,
+    uint64_t idx, std::unique_ptr<ParsedExpression> expressionToSet) {
+    switch (expression.getExpressionType()) {
+    case common::ExpressionType::CASE_ELSE: {
+        setCaseChild(expression, idx, std::move(expressionToSet));
+    } break;
+    case common::ExpressionType::FUNCTION:
+    case common::ExpressionType::LITERAL:
+    case common::ExpressionType::PROPERTY:
+    case common::ExpressionType::VARIABLE: {
+        expression.children[idx] = std::move(expressionToSet);
+    } break;
+    default: {
+        throw common::NotImplementedException{"ParsedExpressionChildrenSetter::setChild"};
+    }
+    }
+}
+
+void ParsedExpressionChildrenSetter::setCaseChild(kuzu::parser::ParsedExpression& expression,
     uint64_t idx, std::unique_ptr<ParsedExpression> expressionToSet) {
     auto& parsedCaseExpr = reinterpret_cast<ParsedCaseExpression&>(expression);
     if (idx == 0) {
@@ -72,9 +85,9 @@ std::unique_ptr<ParsedExpression> ParsedExpressionVisitor::replaceMacroParameter
     if (expressionNamesToReplace.contains(macroExpression->getRawName())) {
         return expressionNamesToReplace.at(macroExpression->getRawName())->copy();
     }
-    auto children = ParsedExpressionCollector::collectChildren(*macroExpression);
+    auto children = ParsedExpressionChildrenCollector::collectChildren(*macroExpression);
     for (auto i = 0u; i < children.size(); i++) {
-        ParsedExpressionCollector::setChild(*macroExpression, i,
+        ParsedExpressionChildrenSetter::setChild(*macroExpression, i,
             replaceMacroParameters(children[i]->copy(), expressionNamesToReplace));
     }
     return macroExpression;