Implement expression evaluator library (#486)

.github/workflows/diff.yaml

@@ -130,7 +130,7 @@ jobs:
           source /opt/toolchain-v4/activate
 
           # Restrict clang-tidy results only to the modified parts
-          git diff -U0 ${{ env.BASE_BRANCH }}... -- src | ./tools/github/clang-tidy/clang-tidy-diff.py -p 1 -j $THREADS -path build | tee ./build/clang_tidy_output.txt
+          git diff -U0 ${{ env.BASE_BRANCH }}... -- src | ./tools/github/clang-tidy/clang-tidy-diff.py -p 1 -j $THREADS -extra-arg="-DMG_CLANG_TIDY_CHECK" -path build | tee ./build/clang_tidy_output.txt
 
           # Fail if any warning is reported
           ! cat ./build/clang_tidy_output.txt | ./tools/github/clang-tidy/grep_error_lines.sh > /dev/null

.github/workflows/full_clang_tidy.yaml

@@ -39,7 +39,7 @@ jobs:
           source /opt/toolchain-v4/activate
 
           # The results are also written to standard output in order to retain them in the logs
-          ./tools/github/clang-tidy/run-clang-tidy.py -p build -j $THREADS -clang-tidy-binary=/opt/toolchain-v4/bin/clang-tidy "$PWD/src/*" |
+          ./tools/github/clang-tidy/run-clang-tidy.py -p build -j $THREADS -extra-arg="-DMG_CLANG_TIDY_CHECK" -clang-tidy-binary=/opt/toolchain-v4/bin/clang-tidy "$PWD/src/*" |
             tee ./build/full_clang_tidy_output.txt
 
       - name: Summarize clang-tidy results

.gitignore

@@ -24,6 +24,7 @@ cmake/DownloadProject/
 dist/
 src/query/frontend/opencypher/generated/
 src/query/v2/frontend/opencypher/generated/
+src/parser/opencypher/generated
 tags
 ve/
 ve3/

src/CMakeLists.txt

@@ -18,6 +18,8 @@ add_subdirectory(query/v2)
 add_subdirectory(slk)
 add_subdirectory(rpc)
 add_subdirectory(auth)
+add_subdirectory(parser)
+add_subdirectory(expr)
 add_subdirectory(coordinator)
 
 if (MG_ENTERPRISE)

src/expr/CMakeLists.txt

@@ -0,0 +1,20 @@
+define_add_lcp(add_lcp_expr lcp_expr_cpp_files generated_lcp_expr_files)
+
+add_lcp_expr(semantic/symbol.lcp)
+
+add_custom_target(generate_lcp_expr DEPENDS ${generated_lcp_expr_files})
+
+set(mg_expr_sources
+    ${lcp_expr_cpp_files}
+    parsing.cpp)
+
+find_package(Boost REQUIRED)
+
+add_library(mg-expr STATIC ${mg_expr_sources})
+add_dependencies(mg-expr generate_lcp_expr)
+target_include_directories(mg-expr PUBLIC ${CMAKE_SOURCE_DIR}/include)
+target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/ast)
+target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/interpret)
+target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/semantic)
+target_link_libraries(mg-expr cppitertools Boost::headers mg-utils mg-parser)

src/expr/ast.hpp

@@ -0,0 +1,35 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#ifndef MG_AST_INCLUDE_PATH
+#ifdef MG_CLANG_TIDY_CHECK
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define MG_AST_INCLUDE_PATH "query/v2/frontend/ast/ast.hpp"
+#else
+#error Missing AST include path
+#endif
+#endif
+
+#ifndef MG_INJECTED_NAMESPACE_NAME
+#ifdef MG_CLANG_TIDY_CHECK
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define MG_INJECTED_NAMESPACE_NAME memgraph::query::v2
+#else
+#error Missing AST namespace
+#endif
+#endif
+
+#include MG_AST_INCLUDE_PATH
+
+namespace memgraph::expr {
+using namespace MG_INJECTED_NAMESPACE_NAME;  // NOLINT(google-build-using-namespace)
+}  // namespace memgraph::expr

src/expr/ast/ast_visitor.hpp

@@ -13,7 +13,7 @@
 
 #include "utils/visitor.hpp"
 
-namespace memgraph::query::v2 {
+namespace MG_INJECTED_NAMESPACE_NAME {
 
 // Forward declares for Tree visitors.
 class CypherQuery;
@@ -96,7 +96,7 @@ class VersionQuery;
 class Foreach;
 class SchemaQuery;
 
-using TreeCompositeVisitor = utils::CompositeVisitor<
+using TreeCompositeVisitor = memgraph::utils::CompositeVisitor<
     SingleQuery, CypherUnion, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
     SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
     LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
@@ -105,7 +105,7 @@ using TreeCompositeVisitor = utils::CompositeVisitor<
     Create, Match, Return, With, Pattern, NodeAtom, EdgeAtom, Delete, Where, SetProperty, SetProperties, SetLabels,
     RemoveProperty, RemoveLabels, Merge, Unwind, RegexMatch, LoadCsv, Foreach>;
 
-using TreeLeafVisitor = utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;
+using TreeLeafVisitor = memgraph::utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;
 
 class HierarchicalTreeVisitor : public TreeCompositeVisitor, public TreeLeafVisitor {
  public:
@@ -117,7 +117,7 @@ class HierarchicalTreeVisitor : public TreeCompositeVisitor, public TreeLeafVisi
 
 template <class TResult>
 class ExpressionVisitor
-    : public utils::Visitor<
+    : public memgraph::utils::Visitor<
           TResult, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
           SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
           LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
@@ -126,9 +126,10 @@ class ExpressionVisitor
           None, ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch> {};
 
 template <class TResult>
-class QueryVisitor : public utils::Visitor<TResult, CypherQuery, ExplainQuery, ProfileQuery, IndexQuery, AuthQuery,
-                                           InfoQuery, ConstraintQuery, DumpQuery, ReplicationQuery, LockPathQuery,
-                                           FreeMemoryQuery, TriggerQuery, IsolationLevelQuery, CreateSnapshotQuery,
-                                           StreamQuery, SettingQuery, VersionQuery, SchemaQuery> {};
+class QueryVisitor
+    : public memgraph::utils::Visitor<TResult, CypherQuery, ExplainQuery, ProfileQuery, IndexQuery, AuthQuery,
+                                      InfoQuery, ConstraintQuery, DumpQuery, ReplicationQuery, LockPathQuery,
+                                      FreeMemoryQuery, TriggerQuery, IsolationLevelQuery, CreateSnapshotQuery,
+                                      StreamQuery, SettingQuery, VersionQuery, SchemaQuery> {};
 
-}  // namespace memgraph::query::v2
+}  // namespace MG_INJECTED_NAMESPACE_NAME

src/expr/ast/pretty_print.hpp

@@ -0,0 +1,271 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include <iostream>
+#include <type_traits>
+
+#include "expr/ast.hpp"
+#include "expr/typed_value.hpp"
+#include "utils/algorithm.hpp"
+#include "utils/logging.hpp"
+#include "utils/string.hpp"
+
+namespace memgraph::expr {
+namespace detail {
+template <typename T>
+void PrintObject(std::ostream *out, const T &arg) {
+  static_assert(!std::is_convertible<T, Expression *>::value,
+                "This overload shouldn't be called with pointers convertible "
+                "to Expression *. This means your other PrintObject overloads aren't "
+                "being called for certain AST nodes when they should (or perhaps such "
+                "overloads don't exist yet).");
+  *out << arg;
+}
+
+inline void PrintObject(std::ostream *out, const std::string &str) { *out << utils::Escape(str); }
+
+inline void PrintObject(std::ostream *out, Aggregation::Op op) { *out << Aggregation::OpToString(op); }
+
+inline void PrintObject(std::ostream *out, Expression *expr);
+
+inline void PrintObject(std::ostream *out, Identifier *expr) { PrintObject(out, static_cast<Expression *>(expr)); }
+
+template <typename T>
+void PrintObject(std::ostream *out, const std::vector<T> &vec) {
+  *out << "[";
+  utils::PrintIterable(*out, vec, ", ", [](auto &stream, const auto &item) { PrintObject(&stream, item); });
+  *out << "]";
+}
+
+template <typename T>
+void PrintObject(std::ostream *out, const std::vector<T, utils::Allocator<T>> &vec) {
+  *out << "[";
+  utils::PrintIterable(*out, vec, ", ", [](auto &stream, const auto &item) { PrintObject(&stream, item); });
+  *out << "]";
+}
+
+template <typename K, typename V>
+void PrintObject(std::ostream *out, const std::map<K, V> &map) {
+  *out << "{";
+  utils::PrintIterable(*out, map, ", ", [](auto &stream, const auto &item) {
+    PrintObject(&stream, item.first);
+    stream << ": ";
+    PrintObject(&stream, item.second);
+  });
+  *out << "}";
+}
+
+template <typename T>
+void PrintObject(std::ostream *out, const utils::pmr::map<utils::pmr::string, T> &map) {
+  *out << "{";
+  utils::PrintIterable(*out, map, ", ", [](auto &stream, const auto &item) {
+    PrintObject(&stream, item.first);
+    stream << ": ";
+    PrintObject(&stream, item.second);
+  });
+  *out << "}";
+}
+
+template <typename T1, typename T2, typename T3>
+inline void PrintObject(std::ostream *out, const TypedValueT<T1, T2, T3> &value) {
+  using TypedValue = TypedValueT<T1, T2, T3>;
+  switch (value.type()) {
+    case TypedValue::Type::Null:
+      *out << "null";
+      break;
+    case TypedValue::Type::String:
+      PrintObject(out, value.ValueString());
+      break;
+    case TypedValue::Type::Bool:
+      *out << (value.ValueBool() ? "true" : "false");
+      break;
+    case TypedValue::Type::Int:
+      PrintObject(out, value.ValueInt());
+      break;
+    case TypedValue::Type::Double:
+      PrintObject(out, value.ValueDouble());
+      break;
+    case TypedValue::Type::List:
+      PrintObject(out, value.ValueList());
+      break;
+    case TypedValue::Type::Map:
+      PrintObject(out, value.ValueMap());
+      break;
+    case TypedValue::Type::Date:
+      PrintObject(out, value.ValueDate());
+      break;
+    case TypedValue::Type::Duration:
+      PrintObject(out, value.ValueDuration());
+      break;
+    case TypedValue::Type::LocalTime:
+      PrintObject(out, value.ValueLocalTime());
+      break;
+    case TypedValue::Type::LocalDateTime:
+      PrintObject(out, value.ValueLocalDateTime());
+      break;
+    default:
+      MG_ASSERT(false, "PrintObject(std::ostream *out, const TypedValue &value) should not reach here");
+  }
+}
+
+template <typename T>
+void PrintOperatorArgs(std::ostream *out, const T &arg) {
+  *out << " ";
+  PrintObject(out, arg);
+  *out << ")";
+}
+
+template <typename T, typename... Ts>
+void PrintOperatorArgs(std::ostream *out, const T &arg, const Ts &...args) {
+  *out << " ";
+  PrintObject(out, arg);
+  PrintOperatorArgs(out, args...);
+}
+
+template <typename... Ts>
+void PrintOperator(std::ostream *out, const std::string &name, const Ts &...args) {
+  *out << "(" << name;
+  PrintOperatorArgs(out, args...);
+}
+}  // namespace detail
+
+class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
+ public:
+  explicit ExpressionPrettyPrinter(std::ostream *out) : out_(out) {}
+
+  // Unary operators
+  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define UNARY_OPERATOR_VISIT(OP_NODE, OP_STR)      \
+  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
+  void Visit(OP_NODE &op) override { detail::PrintOperator(out_, OP_STR, op.expression_); }
+
+  UNARY_OPERATOR_VISIT(NotOperator, "Not");
+  UNARY_OPERATOR_VISIT(UnaryPlusOperator, "+");
+  UNARY_OPERATOR_VISIT(UnaryMinusOperator, "-");
+  UNARY_OPERATOR_VISIT(IsNullOperator, "IsNull");
+
+#undef UNARY_OPERATOR_VISIT
+
+  // Binary operators
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define BINARY_OPERATOR_VISIT(OP_NODE, OP_STR)     \
+  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
+  void Visit(OP_NODE &op) override { detail::PrintOperator(out_, OP_STR, op.expression1_, op.expression2_); }
+
+  BINARY_OPERATOR_VISIT(OrOperator, "Or");
+  BINARY_OPERATOR_VISIT(XorOperator, "Xor");
+  BINARY_OPERATOR_VISIT(AndOperator, "And");
+  BINARY_OPERATOR_VISIT(AdditionOperator, "+");
+  BINARY_OPERATOR_VISIT(SubtractionOperator, "-");
+  BINARY_OPERATOR_VISIT(MultiplicationOperator, "*");
+  BINARY_OPERATOR_VISIT(DivisionOperator, "/");
+  BINARY_OPERATOR_VISIT(ModOperator, "%");
+  BINARY_OPERATOR_VISIT(NotEqualOperator, "!=");
+  BINARY_OPERATOR_VISIT(EqualOperator, "==");
+  BINARY_OPERATOR_VISIT(LessOperator, "<");
+  BINARY_OPERATOR_VISIT(GreaterOperator, ">");
+  BINARY_OPERATOR_VISIT(LessEqualOperator, "<=");
+  BINARY_OPERATOR_VISIT(GreaterEqualOperator, ">=");
+  BINARY_OPERATOR_VISIT(InListOperator, "In");
+  BINARY_OPERATOR_VISIT(SubscriptOperator, "Subscript");
+
+#undef BINARY_OPERATOR_VISIT
+
+  // Other
+  void Visit(ListSlicingOperator &op) override {
+    detail::PrintOperator(out_, "ListSlicing", op.list_, op.lower_bound_, op.upper_bound_);
+  }
+
+  void Visit(IfOperator &op) override {
+    detail::PrintOperator(out_, "If", op.condition_, op.then_expression_, op.else_expression_);
+  }
+
+  void Visit(ListLiteral &op) override { detail::PrintOperator(out_, "ListLiteral", op.elements_); }
+
+  void Visit(MapLiteral &op) override {
+    std::map<std::string, Expression *> map;
+    for (const auto &kv : op.elements_) {
+      map[kv.first.name] = kv.second;
+    }
+    detail::PrintObject(out_, map);
+  }
+
+  void Visit(LabelsTest &op) override { detail::PrintOperator(out_, "LabelsTest", op.expression_); }
+
+  void Visit(Aggregation &op) override { detail::PrintOperator(out_, "Aggregation", op.op_); }
+
+  void Visit(Function &op) override { detail::PrintOperator(out_, "Function", op.function_name_, op.arguments_); }
+
+  void Visit(Reduce &op) override {
+    detail::PrintOperator(out_, "Reduce", op.accumulator_, op.initializer_, op.identifier_, op.list_, op.expression_);
+  }
+
+  void Visit(Coalesce &op) override { detail::PrintOperator(out_, "Coalesce", op.expressions_); }
+
+  void Visit(Extract &op) override { detail::PrintOperator(out_, "Extract", op.identifier_, op.list_, op.expression_); }
+
+  void Visit(All &op) override {
+    detail::PrintOperator(out_, "All", op.identifier_, op.list_expression_, op.where_->expression_);
+  }
+
+  void Visit(Single &op) override {
+    detail::PrintOperator(out_, "Single", op.identifier_, op.list_expression_, op.where_->expression_);
+  }
+
+  void Visit(Any &op) override {
+    detail::PrintOperator(out_, "Any", op.identifier_, op.list_expression_, op.where_->expression_);
+  }
+
+  void Visit(None &op) override {
+    detail::PrintOperator(out_, "None", op.identifier_, op.list_expression_, op.where_->expression_);
+  }
+
+  void Visit(Identifier &op) override { detail::PrintOperator(out_, "Identifier", op.name_); }
+
+  void Visit(PrimitiveLiteral &op) override { detail::PrintObject(out_, op.value_); }
+
+  void Visit(PropertyLookup &op) override {
+    detail::PrintOperator(out_, "PropertyLookup", op.expression_, op.property_.name);
+  }
+
+  void Visit(ParameterLookup &op) override { detail::PrintOperator(out_, "ParameterLookup", op.token_position_); }
+
+  void Visit(NamedExpression &op) override { detail::PrintOperator(out_, "NamedExpression", op.name_, op.expression_); }
+
+  void Visit(RegexMatch &op) override { detail::PrintOperator(out_, "=~", op.string_expr_, op.regex_); }
+
+ private:
+  std::ostream *out_;
+};
+
+namespace detail {
+inline void PrintObject(std::ostream *out, Expression *expr) {
+  if (expr) {
+    ExpressionPrettyPrinter printer{out};
+    expr->Accept(printer);
+  } else {
+    *out << "<null>";
+  }
+}
+}  // namespace detail
+
+inline void PrintExpression(Expression *expr, std::ostream *out) {
+  ExpressionPrettyPrinter printer{out};
+  expr->Accept(printer);
+}
+
+inline void PrintExpression(NamedExpression *expr, std::ostream *out) {
+  ExpressionPrettyPrinter printer{out};
+  expr->Accept(printer);
+}
+}  // namespace memgraph::expr

src/expr/exceptions.hpp

@@ -0,0 +1,35 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "utils/exceptions.hpp"
+
+namespace memgraph::expr {
+
+class SyntaxException : public utils::BasicException {
+ public:
+  using utils::BasicException::BasicException;
+  SyntaxException() : SyntaxException("") {}
+};
+
+class SemanticException : public utils::BasicException {
+ public:
+  using utils::BasicException::BasicException;
+  SemanticException() : BasicException("") {}
+};
+
+class ExpressionRuntimeException : public utils::BasicException {
+ public:
+  using utils::BasicException::BasicException;
+};
+
+}  // namespace memgraph::expr

src/expr/interpret/eval.hpp

@@ -19,22 +19,20 @@
 #include <regex>
 #include <vector>
 
-#include "query/v2/common.hpp"
-#include "query/v2/context.hpp"
-#include "query/v2/db_accessor.hpp"
-#include "query/v2/exceptions.hpp"
-#include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/semantic/symbol_table.hpp"
-#include "query/v2/interpret/frame.hpp"
-#include "query/v2/typed_value.hpp"
+#include "expr/ast.hpp"
+#include "expr/exceptions.hpp"
+#include "expr/interpret/frame.hpp"
+#include "expr/semantic/symbol_table.hpp"
 #include "utils/exceptions.hpp"
 
-namespace memgraph::query::v2 {
+namespace memgraph::expr {
 
+template <typename TypedValue, typename EvaluationContext, typename DbAccessor, typename StorageView, typename LabelId,
+          typename PropertyValue, typename ConvFunction, typename Error>
 class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
  public:
-  ExpressionEvaluator(Frame *frame, const SymbolTable &symbol_table, const EvaluationContext &ctx, DbAccessor *dba,
-                      storage::v3::View view)
+  ExpressionEvaluator(Frame<TypedValue> *frame, const SymbolTable &symbol_table, const EvaluationContext &ctx,
+                      DbAccessor *dba, StorageView view)
       : frame_(frame), symbol_table_(&symbol_table), ctx_(&ctx), dba_(dba), view_(view) {}
 
   using ExpressionVisitor<TypedValue>::Visit;
@@ -52,25 +50,29 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     return TypedValue(frame_->at(symbol_table_->at(ident)), ctx_->memory);
   }
 
-#define BINARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                                                    \
-  TypedValue Visit(OP_NODE &op) override {                                                                     \
-    auto val1 = op.expression1_->Accept(*this);                                                                \
-    auto val2 = op.expression2_->Accept(*this);                                                                \
-    try {                                                                                                      \
-      return val1 CPP_OP val2;                                                                                 \
-    } catch (const TypedValueException &) {                                                                    \
-      throw QueryRuntimeException("Invalid types: {} and {} for '{}'.", val1.type(), val2.type(), #CYPHER_OP); \
-    }                                                                                                          \
+  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define BINARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                                                         \
+  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                                                                  \
+  TypedValue Visit(OP_NODE &op) override {                                                                          \
+    auto val1 = op.expression1_->Accept(*this);                                                                     \
+    auto val2 = op.expression2_->Accept(*this);                                                                     \
+    try {                                                                                                           \
+      return val1 CPP_OP val2;                                                                                      \
+    } catch (const TypedValueException &) {                                                                         \
+      throw ExpressionRuntimeException("Invalid types: {} and {} for '{}'.", val1.type(), val2.type(), #CYPHER_OP); \
+    }                                                                                                               \
   }
 
-#define UNARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                              \
-  TypedValue Visit(OP_NODE &op) override {                                              \
-    auto val = op.expression_->Accept(*this);                                           \
-    try {                                                                               \
-      return CPP_OP val;                                                                \
-    } catch (const TypedValueException &) {                                             \
-      throw QueryRuntimeException("Invalid type {} for '{}'.", val.type(), #CYPHER_OP); \
-    }                                                                                   \
+  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define UNARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                                   \
+  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                                           \
+  TypedValue Visit(OP_NODE &op) override {                                                   \
+    auto val = op.expression_->Accept(*this);                                                \
+    try {                                                                                    \
+      return CPP_OP val;                                                                     \
+    } catch (const TypedValueException &) {                                                  \
+      throw ExpressionRuntimeException("Invalid type {} for '{}'.", val.type(), #CYPHER_OP); \
+    }                                                                                        \
   }
 
   BINARY_OPERATOR_VISITOR(OrOperator, ||, OR);
@@ -104,18 +106,18 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     try {
       return value1 && value2;
     } catch (const TypedValueException &) {
-      throw QueryRuntimeException("Invalid types: {} and {} for AND.", value1.type(), value2.type());
+      throw ExpressionRuntimeException("Invalid types: {} and {} for AND.", value1.type(), value2.type());
     }
   }
 
   TypedValue Visit(IfOperator &if_operator) override {
     auto condition = if_operator.condition_->Accept(*this);
     if (condition.IsNull()) {
-      return if_operator.then_expression_->Accept(*this);
+      return if_operator.else_expression_->Accept(*this);
     }
     if (condition.type() != TypedValue::Type::Bool) {
       // At the moment IfOperator is used only in CASE construct.
-      throw QueryRuntimeException("CASE expected boolean expression, got {}.", condition.type());
+      throw ExpressionRuntimeException("CASE expected boolean expression, got {}.", condition.type());
     }
     if (condition.ValueBool()) {
       return if_operator.then_expression_->Accept(*this);
@@ -132,7 +134,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     // Exceptions have higher priority than returning nulls when list expression
     // is not null.
     if (_list.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("IN expected a list, got {}.", _list.type());
+      throw ExpressionRuntimeException("IN expected a list, got {}.", _list.type());
     }
     const auto &list = _list.ValueList();
 
@@ -162,13 +164,14 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     auto lhs = list_indexing.expression1_->Accept(*this);
     auto index = list_indexing.expression2_->Accept(*this);
     if (!lhs.IsList() && !lhs.IsMap() && !lhs.IsVertex() && !lhs.IsEdge() && !lhs.IsNull())
-      throw QueryRuntimeException(
+      throw ExpressionRuntimeException(
           "Expected a list, a map, a node or an edge to index with '[]', got "
           "{}.",
           lhs.type());
     if (lhs.IsNull() || index.IsNull()) return TypedValue(ctx_->memory);
     if (lhs.IsList()) {
-      if (!index.IsInt()) throw QueryRuntimeException("Expected an integer as a list index, got {}.", index.type());
+      if (!index.IsInt())
+        throw ExpressionRuntimeException("Expected an integer as a list index, got {}.", index.type());
       auto index_int = index.ValueInt();
       // NOTE: Take non-const reference to list, so that we can move out the
       // indexed element as the result.
@@ -183,7 +186,8 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     }
 
     if (lhs.IsMap()) {
-      if (!index.IsString()) throw QueryRuntimeException("Expected a string as a map index, got {}.", index.type());
+      if (!index.IsString())
+        throw ExpressionRuntimeException("Expected a string as a map index, got {}.", index.type());
       // NOTE: Take non-const reference to map, so that we can move out the
       // looked-up element as the result.
       auto &map = lhs.ValueMap();
@@ -195,12 +199,14 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     }
 
     if (lhs.IsVertex()) {
-      if (!index.IsString()) throw QueryRuntimeException("Expected a string as a property name, got {}.", index.type());
+      if (!index.IsString())
+        throw ExpressionRuntimeException("Expected a string as a property name, got {}.", index.type());
       return TypedValue(GetProperty(lhs.ValueVertex(), index.ValueString()), ctx_->memory);
     }
 
     if (lhs.IsEdge()) {
-      if (!index.IsString()) throw QueryRuntimeException("Expected a string as a property name, got {}.", index.type());
+      if (!index.IsString())
+        throw ExpressionRuntimeException("Expected a string as a property name, got {}.", index.type());
       return TypedValue(GetProperty(lhs.ValueEdge(), index.ValueString()), ctx_->memory);
     }
 
@@ -218,7 +224,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (bound.type() == TypedValue::Type::Null) {
           is_null = true;
         } else if (bound.type() != TypedValue::Type::Int) {
-          throw QueryRuntimeException("Expected an integer for a bound in list slicing, got {}.", bound.type());
+          throw ExpressionRuntimeException("Expected an integer for a bound in list slicing, got {}.", bound.type());
         }
         return bound;
       }
@@ -231,7 +237,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     if (_list.type() == TypedValue::Type::Null) {
       is_null = true;
     } else if (_list.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("Expected a list to slice, got {}.", _list.type());
+      throw ExpressionRuntimeException("Expected a list to slice, got {}.", _list.type());
     }
 
     if (is_null) {
@@ -247,9 +253,10 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     auto lower_bound = normalise_bound(_lower_bound.ValueInt());
     auto upper_bound = normalise_bound(_upper_bound.ValueInt());
     if (upper_bound <= lower_bound) {
-      return TypedValue(TypedValue::TVector(ctx_->memory), ctx_->memory);
+      return TypedValue(typename TypedValue::TVector(ctx_->memory), ctx_->memory);
     }
-    return TypedValue(TypedValue::TVector(list.begin() + lower_bound, list.begin() + upper_bound, ctx_->memory));
+    return TypedValue(
+        typename TypedValue::TVector(list.begin() + lower_bound, list.begin() + upper_bound, ctx_->memory));
   }
 
   TypedValue Visit(IsNullOperator &is_null) override {
@@ -317,9 +324,9 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       case TypedValue::Type::Null:
         return TypedValue(ctx_->memory);
       case TypedValue::Type::Vertex:
-        return TypedValue(GetProperty(expression_result.ValueVertex(), property_lookup.property_), ctx_->memory);
+        return GetProperty(expression_result.ValueVertex(), property_lookup.property_);
       case TypedValue::Type::Edge:
-        return TypedValue(GetProperty(expression_result.ValueEdge(), property_lookup.property_), ctx_->memory);
+        return GetProperty(expression_result.ValueEdge(), property_lookup.property_);
       case TypedValue::Type::Map: {
         // NOTE: Take non-const reference to map, so that we can move out the
         // looked-up element as the result.
@@ -336,7 +343,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (auto dur_field = maybe_duration(dur, prop_name); dur_field) {
           return std::move(*dur_field);
         }
-        throw QueryRuntimeException("Invalid property name {} for Duration", prop_name);
+        throw ExpressionRuntimeException("Invalid property name {} for Duration", prop_name);
       }
       case TypedValue::Type::Date: {
         const auto &prop_name = property_lookup.property_.name;
@@ -344,7 +351,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (auto date_field = maybe_date(date, prop_name); date_field) {
           return std::move(*date_field);
         }
-        throw QueryRuntimeException("Invalid property name {} for Date", prop_name);
+        throw ExpressionRuntimeException("Invalid property name {} for Date", prop_name);
       }
       case TypedValue::Type::LocalTime: {
         const auto &prop_name = property_lookup.property_.name;
@@ -352,7 +359,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (auto lt_field = maybe_local_time(lt, prop_name); lt_field) {
           return std::move(*lt_field);
         }
-        throw QueryRuntimeException("Invalid property name {} for LocalTime", prop_name);
+        throw ExpressionRuntimeException("Invalid property name {} for LocalTime", prop_name);
       }
       case TypedValue::Type::LocalDateTime: {
         const auto &prop_name = property_lookup.property_.name;
@@ -363,10 +370,10 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (auto lt_field = maybe_local_time(ldt.local_time, prop_name); lt_field) {
           return std::move(*lt_field);
         }
-        throw QueryRuntimeException("Invalid property name {} for LocalDateTime", prop_name);
+        throw ExpressionRuntimeException("Invalid property name {} for LocalDateTime", prop_name);
       }
       default:
-        throw QueryRuntimeException("Only nodes, edges, maps and temporal types have properties to be looked-up.");
+        throw ExpressionRuntimeException("Only nodes, edges, maps and temporal types have properties to be looked-up.");
     }
   }
 
@@ -379,7 +386,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         const auto &vertex = expression_result.ValueVertex();
         for (const auto &label : labels_test.labels_) {
           auto has_label = vertex.HasLabel(view_, GetLabel(label));
-          if (has_label.HasError() && has_label.GetError() == storage::v3::Error::NONEXISTENT_OBJECT) {
+          if (has_label.HasError() && has_label.GetError() == Error::NONEXISTENT_OBJECT) {
             // This is a very nasty and temporary hack in order to make MERGE
             // work. The old storage had the following logic when returning an
             // `OLD` view: `return old ? old : new`. That means that if the
@@ -387,18 +394,18 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
             // we simulate that behavior.
             // TODO (mferencevic, teon.banek): Remove once MERGE is
             // reimplemented.
-            has_label = vertex.HasLabel(storage::v3::View::NEW, GetLabel(label));
+            has_label = vertex.HasLabel(StorageView::NEW, GetLabel(label));
           }
           if (has_label.HasError()) {
             switch (has_label.GetError()) {
-              case storage::v3::Error::DELETED_OBJECT:
-                throw QueryRuntimeException("Trying to access labels on a deleted node.");
-              case storage::v3::Error::NONEXISTENT_OBJECT:
-                throw query::v2::QueryRuntimeException("Trying to access labels from a node that doesn't exist.");
-              case storage::v3::Error::SERIALIZATION_ERROR:
-              case storage::v3::Error::VERTEX_HAS_EDGES:
-              case storage::v3::Error::PROPERTIES_DISABLED:
-                throw QueryRuntimeException("Unexpected error when accessing labels.");
+              case Error::DELETED_OBJECT:
+                throw ExpressionRuntimeException("Trying to access labels on a deleted node.");
+              case Error::NONEXISTENT_OBJECT:
+                throw ExpressionRuntimeException("Trying to access labels from a node that doesn't exist.");
+              case Error::SERIALIZATION_ERROR:
+              case Error::VERTEX_HAS_EDGES:
+              case Error::PROPERTIES_DISABLED:
+                throw ExpressionRuntimeException("Unexpected error when accessing labels.");
             }
           }
           if (!*has_label) {
@@ -408,7 +415,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         return TypedValue(true, ctx_->memory);
       }
       default:
-        throw QueryRuntimeException("Only nodes have labels.");
+        throw ExpressionRuntimeException("Only nodes have labels.");
     }
   }
 
@@ -419,14 +426,14 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   }
 
   TypedValue Visit(ListLiteral &literal) override {
-    TypedValue::TVector result(ctx_->memory);
+    typename TypedValue::TVector result(ctx_->memory);
     result.reserve(literal.elements_.size());
     for (const auto &expression : literal.elements_) result.emplace_back(expression->Accept(*this));
     return TypedValue(result, ctx_->memory);
   }
 
   TypedValue Visit(MapLiteral &literal) override {
-    TypedValue::TMap result(ctx_->memory);
+    typename TypedValue::TMap result(ctx_->memory);
     for (const auto &pair : literal.elements_) result.emplace(pair.first.name, pair.second->Accept(*this));
     return TypedValue(result, ctx_->memory);
   }
@@ -439,7 +446,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     auto &exprs = coalesce.expressions_;
 
     if (exprs.size() == 0) {
-      throw QueryRuntimeException("'coalesce' requires at least one argument.");
+      throw ExpressionRuntimeException("'coalesce' requires at least one argument.");
     }
 
     for (int64_t i = 0; i < exprs.size(); ++i) {
@@ -466,7 +473,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       MG_ASSERT(res.GetMemoryResource() == ctx_->memory);
       return res;
     } else {
-      TypedValue::TVector arguments(ctx_->memory);
+      typename TypedValue::TVector arguments(ctx_->memory);
       arguments.reserve(function.arguments_.size());
       for (const auto &argument : function.arguments_) {
         arguments.emplace_back(argument->Accept(*this));
@@ -483,7 +490,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("REDUCE expected a list, got {}.", list_value.type());
+      throw ExpressionRuntimeException("REDUCE expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &element_symbol = symbol_table_->at(*reduce.identifier_);
@@ -503,11 +510,11 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("EXTRACT expected a list, got {}.", list_value.type());
+      throw ExpressionRuntimeException("EXTRACT expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &element_symbol = symbol_table_->at(*extract.identifier_);
-    TypedValue::TVector result(ctx_->memory);
+    typename TypedValue::TVector result(ctx_->memory);
     result.reserve(list.size());
     for (const auto &element : list) {
       if (element.IsNull()) {
@@ -526,7 +533,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("ALL expected a list, got {}.", list_value.type());
+      throw ExpressionRuntimeException("ALL expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &symbol = symbol_table_->at(*all.identifier_);
@@ -536,7 +543,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       frame_->at(symbol) = element;
       auto result = all.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw QueryRuntimeException("Predicate of ALL must evaluate to boolean, got {}.", result.type());
+        throw ExpressionRuntimeException("Predicate of ALL must evaluate to boolean, got {}.", result.type());
       }
       if (!result.IsNull()) {
         has_value = true;
@@ -563,7 +570,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("SINGLE expected a list, got {}.", list_value.type());
+      throw ExpressionRuntimeException("SINGLE expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &symbol = symbol_table_->at(*single.identifier_);
@@ -573,7 +580,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       frame_->at(symbol) = element;
       auto result = single.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw QueryRuntimeException("Predicate of SINGLE must evaluate to boolean, got {}.", result.type());
+        throw ExpressionRuntimeException("Predicate of SINGLE must evaluate to boolean, got {}.", result.type());
       }
       if (result.type() == TypedValue::Type::Bool) {
         has_value = true;
@@ -601,7 +608,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("ANY expected a list, got {}.", list_value.type());
+      throw ExpressionRuntimeException("ANY expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &symbol = symbol_table_->at(*any.identifier_);
@@ -610,7 +617,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       frame_->at(symbol) = element;
       auto result = any.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw QueryRuntimeException("Predicate of ANY must evaluate to boolean, got {}.", result.type());
+        throw ExpressionRuntimeException("Predicate of ANY must evaluate to boolean, got {}.", result.type());
       }
       if (!result.IsNull()) {
         has_value = true;
@@ -633,7 +640,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("NONE expected a list, got {}.", list_value.type());
+      throw ExpressionRuntimeException("NONE expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &symbol = symbol_table_->at(*none.identifier_);
@@ -642,7 +649,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       frame_->at(symbol) = element;
       auto result = none.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw QueryRuntimeException("Predicate of NONE must evaluate to boolean, got {}.", result.type());
+        throw ExpressionRuntimeException("Predicate of NONE must evaluate to boolean, got {}.", result.type());
       }
       if (!result.IsNull()) {
         has_value = true;
@@ -660,7 +667,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   }
 
   TypedValue Visit(ParameterLookup &param_lookup) override {
-    return TypedValue(ctx_->parameters.AtTokenPosition(param_lookup.token_position_), ctx_->memory);
+    return TypedValue(conv_(ctx_->parameters.AtTokenPosition(param_lookup.token_position_)), ctx_->memory);
   }
 
   TypedValue Visit(RegexMatch &regex_match) override {
@@ -670,7 +677,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (regex_value.type() != TypedValue::Type::String) {
-      throw QueryRuntimeException("Regular expression must evaluate to a string, got {}.", regex_value.type());
+      throw ExpressionRuntimeException("Regular expression must evaluate to a string, got {}.", regex_value.type());
     }
     if (target_string_value.type() != TypedValue::Type::String) {
       // Instead of error, we return Null which makes it compatible in case we
@@ -683,42 +690,42 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       std::regex regex(regex_value.ValueString());
       return TypedValue(std::regex_match(target_string, regex), ctx_->memory);
     } catch (const std::regex_error &e) {
-      throw QueryRuntimeException("Regex error in '{}': {}", regex_value.ValueString(), e.what());
+      throw ExpressionRuntimeException("Regex error in '{}': {}", regex_value.ValueString(), e.what());
     }
   }
 
  private:
   template <class TRecordAccessor>
-  storage::v3::PropertyValue GetProperty(const TRecordAccessor &record_accessor, PropertyIx prop) {
+  TypedValue GetProperty(const TRecordAccessor &record_accessor, PropertyIx prop) {
     auto maybe_prop = record_accessor.GetProperty(view_, ctx_->properties[prop.ix]);
-    if (maybe_prop.HasError() && maybe_prop.GetError() == storage::v3::Error::NONEXISTENT_OBJECT) {
+    if (maybe_prop.HasError() && maybe_prop.GetError() == Error::NONEXISTENT_OBJECT) {
       // This is a very nasty and temporary hack in order to make MERGE work.
       // The old storage had the following logic when returning an `OLD` view:
       // `return old ? old : new`. That means that if the `OLD` view didn't
       // exist, it returned the NEW view. With this hack we simulate that
       // behavior.
       // TODO (mferencevic, teon.banek): Remove once MERGE is reimplemented.
-      maybe_prop = record_accessor.GetProperty(storage::v3::View::NEW, ctx_->properties[prop.ix]);
+      maybe_prop = record_accessor.GetProperty(StorageView::NEW, ctx_->properties[prop.ix]);
     }
     if (maybe_prop.HasError()) {
       switch (maybe_prop.GetError()) {
-        case storage::v3::Error::DELETED_OBJECT:
-          throw QueryRuntimeException("Trying to get a property from a deleted object.");
-        case storage::v3::Error::NONEXISTENT_OBJECT:
-          throw query::v2::QueryRuntimeException("Trying to get a property from an object that doesn't exist.");
-        case storage::v3::Error::SERIALIZATION_ERROR:
-        case storage::v3::Error::VERTEX_HAS_EDGES:
-        case storage::v3::Error::PROPERTIES_DISABLED:
-          throw QueryRuntimeException("Unexpected error when getting a property.");
+        case Error::DELETED_OBJECT:
+          throw ExpressionRuntimeException("Trying to get a property from a deleted object.");
+        case Error::NONEXISTENT_OBJECT:
+          throw ExpressionRuntimeException("Trying to get a property from an object that doesn't exist.");
+        case Error::SERIALIZATION_ERROR:
+        case Error::VERTEX_HAS_EDGES:
+        case Error::PROPERTIES_DISABLED:
+          throw ExpressionRuntimeException("Unexpected error when getting a property.");
       }
     }
-    return *maybe_prop;
+    return conv_(*maybe_prop);
   }
 
   template <class TRecordAccessor>
-  storage::v3::PropertyValue GetProperty(const TRecordAccessor &record_accessor, const std::string_view name) {
+  TypedValue GetProperty(const TRecordAccessor &record_accessor, const std::string_view name) {
     auto maybe_prop = record_accessor.GetProperty(view_, dba_->NameToProperty(name));
-    if (maybe_prop.HasError() && maybe_prop.GetError() == storage::v3::Error::NONEXISTENT_OBJECT) {
+    if (maybe_prop.HasError() && maybe_prop.GetError() == Error::NONEXISTENT_OBJECT) {
       // This is a very nasty and temporary hack in order to make MERGE work.
       // The old storage had the following logic when returning an `OLD` view:
       // `return old ? old : new`. That means that if the `OLD` view didn't
@@ -729,36 +736,55 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     }
     if (maybe_prop.HasError()) {
       switch (maybe_prop.GetError()) {
-        case storage::v3::Error::DELETED_OBJECT:
-          throw QueryRuntimeException("Trying to get a property from a deleted object.");
-        case storage::v3::Error::NONEXISTENT_OBJECT:
-          throw query::v2::QueryRuntimeException("Trying to get a property from an object that doesn't exist.");
-        case storage::v3::Error::SERIALIZATION_ERROR:
-        case storage::v3::Error::VERTEX_HAS_EDGES:
-        case storage::v3::Error::PROPERTIES_DISABLED:
-          throw QueryRuntimeException("Unexpected error when getting a property.");
+        case Error::DELETED_OBJECT:
+          throw ExpressionRuntimeException("Trying to get a property from a deleted object.");
+        case Error::NONEXISTENT_OBJECT:
+          throw ExpressionRuntimeException("Trying to get a property from an object that doesn't exist.");
+        case Error::SERIALIZATION_ERROR:
+        case Error::VERTEX_HAS_EDGES:
+        case Error::PROPERTIES_DISABLED:
+          throw ExpressionRuntimeException("Unexpected error when getting a property.");
       }
     }
-    return *maybe_prop;
+    return conv_(*maybe_prop);
   }
 
-  storage::v3::LabelId GetLabel(LabelIx label) { return ctx_->labels[label.ix]; }
+  LabelId GetLabel(LabelIx label) { return ctx_->labels[label.ix]; }
 
-  Frame *frame_;
+  Frame<TypedValue> *frame_;
   const SymbolTable *symbol_table_;
   const EvaluationContext *ctx_;
   DbAccessor *dba_;
   // which switching approach should be used when evaluating
-  storage::v3::View view_;
+  StorageView view_;
+  ConvFunction conv_;
 };
 
 /// A helper function for evaluating an expression that's an int.
 ///
 /// @param what - Name of what's getting evaluated. Used for user feedback (via
 ///               exception) when the evaluated value is not an int.
-/// @throw QueryRuntimeException if expression doesn't evaluate to an int.
-int64_t EvaluateInt(ExpressionEvaluator *evaluator, Expression *expr, const std::string &what);
+/// @throw ExpressionRuntimeException if expression doesn't evaluate to an int.
+template <typename ExpressionEvaluator>
+int64_t EvaluateInt(ExpressionEvaluator *evaluator, Expression *expr, const std::string &what) {
+  TypedValue value = expr->Accept(*evaluator);
+  try {
+    return value.ValueInt();
+  } catch (TypedValueException &e) {
+    throw ExpressionRuntimeException(what + " must be an int");
+  }
+}
 
-std::optional<size_t> EvaluateMemoryLimit(ExpressionEvaluator *eval, Expression *memory_limit, size_t memory_scale);
+template <typename ExpressionEvaluator>
+std::optional<size_t> EvaluateMemoryLimit(ExpressionEvaluator *eval, Expression *memory_limit, size_t memory_scale) {
+  if (!memory_limit) return std::nullopt;
+  auto limit_value = memory_limit->Accept(*eval);
+  if (!limit_value.IsInt() || limit_value.ValueInt() <= 0)
+    throw ExpressionRuntimeException("Memory limit must be a non-negative integer.");
+  size_t limit = limit_value.ValueInt();
+  if (std::numeric_limits<size_t>::max() / memory_scale < limit)
+    throw ExpressionRuntimeException("Memory limit overflow.");
+  return limit * memory_scale;
+}
 
-}  // namespace memgraph::query::v2
+}  // namespace memgraph::expr

src/expr/interpret/frame.hpp

@@ -13,14 +13,14 @@
 
 #include <vector>
 
-#include "query/v2/frontend/semantic/symbol_table.hpp"
-#include "query/v2/typed_value.hpp"
+#include "expr/semantic/symbol_table.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory.hpp"
 #include "utils/pmr/vector.hpp"
 
-namespace memgraph::query::v2 {
+namespace memgraph::expr {
 
+template <typename TypedValue>
 class Frame {
  public:
   /// Create a Frame of given size backed by a utils::NewDeleteResource()
@@ -42,4 +42,4 @@ class Frame {
   utils::pmr::vector<TypedValue> elems_;
 };
 
-}  // namespace memgraph::query::v2
+}  // namespace memgraph::expr

src/expr/parsing.cpp

@@ -9,18 +9,18 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-#include "query/v2/frontend/parsing.hpp"
+#include "expr/parsing.hpp"
 
 #include <cctype>
 #include <codecvt>
 #include <locale>
 #include <stdexcept>
 
-#include "query/v2/exceptions.hpp"
+#include "expr/exceptions.hpp"
 #include "utils/logging.hpp"
 #include "utils/string.hpp"
 
-namespace memgraph::query::v2::frontend {
+namespace memgraph::expr {
 
 int64_t ParseIntegerLiteral(const std::string &s) {
   try {
@@ -181,4 +181,4 @@ std::string ParseParameter(const std::string &s) {
   return out;
 }
 
-}  // namespace memgraph::query::v2::frontend
+}  // namespace memgraph::expr

src/expr/parsing.hpp

@@ -15,7 +15,7 @@
 #include <cstdint>
 #include <string>
 
-namespace memgraph::query::v2::frontend {
+namespace memgraph::expr {
 
 // These are the functions for parsing literals and parameter names from
 // opencypher query.
@@ -24,4 +24,4 @@ std::string ParseStringLiteral(const std::string &s);
 double ParseDoubleLiteral(const std::string &s);
 std::string ParseParameter(const std::string &s);
 
-}  // namespace memgraph::query::v2::frontend
+}  // namespace memgraph::expr

src/expr/semantic/symbol.lcp

@@ -18,8 +18,7 @@
 cpp<#
 
 (lcp:namespace memgraph)
-(lcp:namespace query)
-(lcp:namespace v2)
+(lcp:namespace expr)
 
 (lcp:define-class symbol ()
   ((name "std::string" :scope :public)
@@ -66,16 +65,15 @@ cpp<#
     cpp<#)
   (:serialize (:slk)))
 
-(lcp:pop-namespace) ;; v2
-(lcp:pop-namespace) ;; query
+(lcp:pop-namespace) ;; expr
 (lcp:pop-namespace) ;; memgraph
 
 #>cpp
 namespace std {
 
 template <>
-struct hash<memgraph::query::v2::Symbol> {
-  size_t operator()(const memgraph::query::v2::Symbol &symbol) const {
+struct hash<memgraph::expr::Symbol> {
+  size_t operator()(const memgraph::expr::Symbol &symbol) const {
     size_t prime = 265443599u;
     size_t hash = std::hash<int>{}(symbol.position());
     hash ^= prime * std::hash<std::string>{}(symbol.name());

src/expr/semantic/symbol_generator.hpp

@@ -0,0 +1,712 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+// Copyright 2017 Memgraph
+//
+// Created by Teon Banek on 11-03-2017
+
+#pragma once
+
+#include <algorithm>
+#include <optional>
+#include <ranges>
+#include <unordered_map>
+#include <unordered_set>
+#include <variant>
+#include <vector>
+
+#include "expr/ast.hpp"
+#include "expr/ast/ast_visitor.hpp"
+#include "expr/exceptions.hpp"
+#include "expr/semantic/symbol_table.hpp"
+
+namespace memgraph::expr {
+namespace detail {
+inline std::unordered_map<std::string, Identifier *> GeneratePredefinedIdentifierMap(
+    const std::vector<Identifier *> &predefined_identifiers) {
+  std::unordered_map<std::string, Identifier *> identifier_map;
+  for (const auto &identifier : predefined_identifiers) {
+    identifier_map.emplace(identifier->name_, identifier);
+  }
+
+  return identifier_map;
+}
+}  // namespace detail
+
+/// Visits the AST and generates symbols for variables.
+///
+/// During the process of symbol generation, simple semantic checks are
+/// performed. Such as, redeclaring a variable or conflicting expectations of
+/// variable types.
+class SymbolGenerator : public HierarchicalTreeVisitor {
+ public:
+  explicit SymbolGenerator(SymbolTable *symbol_table, const std::vector<Identifier *> &predefined_identifiers)
+      : symbol_table_(symbol_table),
+        predefined_identifiers_{detail::GeneratePredefinedIdentifierMap(predefined_identifiers)},
+        scopes_(1, Scope()) {}
+
+  using HierarchicalTreeVisitor::PostVisit;
+  using HierarchicalTreeVisitor::PreVisit;
+  using HierarchicalTreeVisitor::Visit;
+  using typename HierarchicalTreeVisitor::ReturnType;
+
+  // Query
+  bool PreVisit(SingleQuery & /*unused*/) override {
+    prev_return_names_ = curr_return_names_;
+    curr_return_names_.clear();
+    return true;
+  }
+
+  // Union
+  bool PreVisit(CypherUnion & /*unused*/) override {
+    scopes_.back() = Scope();
+    return true;
+  }
+
+  bool PostVisit(CypherUnion &cypher_union) override {
+    if (prev_return_names_ != curr_return_names_) {
+      throw SemanticException("All subqueries in an UNION must have the same column names.");
+    }
+
+    // create new symbols for the result of the union
+    for (const auto &name : curr_return_names_) {
+      auto symbol = CreateSymbol(name, false);
+      cypher_union.union_symbols_.push_back(symbol);
+    }
+
+    return true;
+  }
+
+  // Clauses
+  bool PreVisit(Create & /*unused*/) override {
+    scopes_.back().in_create = true;
+    return true;
+  }
+
+  bool PostVisit(Create & /*unused*/) override {
+    scopes_.back().in_create = false;
+    return true;
+  }
+
+  bool PreVisit(CallProcedure &call_proc) override {
+    for (auto *expr : call_proc.arguments_) {
+      expr->Accept(*this);
+    }
+    return false;
+  }
+
+  bool PostVisit(CallProcedure &call_proc) override {
+    for (auto *ident : call_proc.result_identifiers_) {
+      if (HasSymbolLocalScope(ident->name_)) {
+        throw RedeclareVariableError(ident->name_);
+      }
+      ident->MapTo(CreateSymbol(ident->name_, true));
+    }
+    return true;
+  }
+
+  bool PreVisit(LoadCsv & /*unused*/) override { return false; }
+
+  bool PostVisit(LoadCsv &load_csv) override {
+    if (HasSymbolLocalScope(load_csv.row_var_->name_)) {
+      throw RedeclareVariableError(load_csv.row_var_->name_);
+    }
+    load_csv.row_var_->MapTo(CreateSymbol(load_csv.row_var_->name_, true));
+    return true;
+  }
+
+  bool PreVisit(Return &ret) override {
+    auto &scope = scopes_.back();
+    scope.in_return = true;
+    VisitReturnBody(ret.body_);
+    scope.in_return = false;
+    return false;  // We handled the traversal ourselves.
+  }
+
+  bool PostVisit(Return & /*unused*/) override {
+    for (const auto &name_symbol : scopes_.back().symbols) curr_return_names_.insert(name_symbol.first);
+    return true;
+  }
+
+  bool PreVisit(With &with) override {
+    auto &scope = scopes_.back();
+    scope.in_with = true;
+    VisitReturnBody(with.body_, with.where_);
+    scope.in_with = false;
+    return false;  // We handled the traversal ourselves.
+  }
+
+  bool PreVisit(Where & /*unused*/) override {
+    scopes_.back().in_where = true;
+    return true;
+  }
+
+  bool PostVisit(Where & /*unused*/) override {
+    scopes_.back().in_where = false;
+    return true;
+  }
+
+  bool PreVisit(Merge & /*unused*/) override {
+    scopes_.back().in_merge = true;
+    return true;
+  }
+
+  bool PostVisit(Merge & /*unused*/) override {
+    scopes_.back().in_merge = false;
+    return true;
+  }
+
+  bool PostVisit(Unwind &unwind) override {
+    const auto &name = unwind.named_expression_->name_;
+    if (HasSymbolLocalScope(name)) {
+      throw RedeclareVariableError(name);
+    }
+    unwind.named_expression_->MapTo(CreateSymbol(name, true));
+    return true;
+  }
+
+  bool PreVisit(Match & /*unused*/) override {
+    scopes_.back().in_match = true;
+    return true;
+  }
+
+  bool PostVisit(Match & /*unused*/) override {
+    auto &scope = scopes_.back();
+    scope.in_match = false;
+    // Check variables in property maps after visiting Match, so that they can
+    // reference symbols out of bind order.
+    for (auto &ident : scope.identifiers_in_match) {
+      if (!HasSymbolLocalScope(ident->name_) && !ConsumePredefinedIdentifier(ident->name_))
+        throw UnboundVariableError(ident->name_);
+      ident->MapTo(scope.symbols[ident->name_]);
+    }
+    scope.identifiers_in_match.clear();
+    return true;
+  }
+
+  bool PreVisit(Foreach &for_each) override {
+    const auto &name = for_each.named_expression_->name_;
+    scopes_.emplace_back(Scope());
+    scopes_.back().in_foreach = true;
+    for_each.named_expression_->MapTo(
+        CreateSymbol(name, true, Symbol::Type::ANY, for_each.named_expression_->token_position_));
+    return true;
+  }
+
+  bool PostVisit(Foreach & /*unused*/) override {
+    scopes_.pop_back();
+    return true;
+  }
+
+  // Expressions
+  ReturnType Visit(Identifier &ident) override {
+    auto &scope = scopes_.back();
+    if (scope.in_skip || scope.in_limit) {
+      throw SemanticException("Variables are not allowed in {}.", scope.in_skip ? "SKIP" : "LIMIT");
+    }
+    Symbol symbol;
+    if (scope.in_pattern && !(scope.in_node_atom || scope.visiting_edge)) {
+      // If we are in the pattern, and outside of a node or an edge, the
+      // identifier is the pattern name.
+      symbol = GetOrCreateSymbolLocalScope(ident.name_, ident.user_declared_, Symbol::Type::PATH);
+    } else if (scope.in_pattern && scope.in_pattern_atom_identifier) {
+      //  Patterns used to create nodes and edges cannot redeclare already
+      //  established bindings. Declaration only happens in single node
+      //  patterns and in edge patterns. OpenCypher example,
+      //  `MATCH (n) CREATE (n)` should throw an error that `n` is already
+      //  declared. While `MATCH (n) CREATE (n) -[:R]-> (n)` is allowed,
+      //  since `n` now references the bound node instead of declaring it.
+      if ((scope.in_create_node || scope.in_create_edge) && HasSymbolLocalScope(ident.name_)) {
+        throw RedeclareVariableError(ident.name_);
+      }
+      auto type = Symbol::Type::VERTEX;
+      if (scope.visiting_edge) {
+        // Edge referencing is not allowed (like in Neo4j):
+        // `MATCH (n) - [r] -> (n) - [r] -> (n) RETURN r` is not allowed.
+        if (HasSymbolLocalScope(ident.name_)) {
+          throw RedeclareVariableError(ident.name_);
+        }
+        type = scope.visiting_edge->IsVariable() ? Symbol::Type::EDGE_LIST : Symbol::Type::EDGE;
+      }
+      symbol = GetOrCreateSymbolLocalScope(ident.name_, ident.user_declared_, type);
+    } else if (scope.in_pattern && !scope.in_pattern_atom_identifier && scope.in_match) {
+      if (scope.in_edge_range && scope.visiting_edge->identifier_->name_ == ident.name_) {
+        // Prevent variable path bounds to reference the identifier which is bound
+        // by the variable path itself.
+        throw UnboundVariableError(ident.name_);
+      }
+      // Variables in property maps or bounds of variable length path during MATCH
+      // can reference symbols bound later in the same MATCH. We collect them
+      // here, so that they can be checked after visiting Match.
+      scope.identifiers_in_match.emplace_back(&ident);
+    } else {
+      // Everything else references a bound symbol.
+      if (!HasSymbol(ident.name_) && !ConsumePredefinedIdentifier(ident.name_)) throw UnboundVariableError(ident.name_);
+      symbol = GetOrCreateSymbol(ident.name_, ident.user_declared_, Symbol::Type::ANY);
+    }
+    ident.MapTo(symbol);
+    return true;
+  }
+
+  ReturnType Visit(PrimitiveLiteral & /*unused*/) override { return true; }
+
+  ReturnType Visit(ParameterLookup & /*unused*/) override { return true; }
+
+  bool PreVisit(Aggregation &aggr) override {
+    auto &scope = scopes_.back();
+    // Check if the aggregation can be used in this context. This check should
+    // probably move to a separate phase, which checks if the query is well
+    // formed.
+    if ((!scope.in_return && !scope.in_with) || scope.in_order_by || scope.in_skip || scope.in_limit ||
+        scope.in_where) {
+      throw SemanticException("Aggregation functions are only allowed in WITH and RETURN.");
+    }
+    if (scope.in_aggregation) {
+      throw SemanticException(
+          "Using aggregation functions inside aggregation functions is not "
+          "allowed.");
+    }
+    if (scope.num_if_operators) {
+      // Neo allows aggregations here and produces very interesting behaviors.
+      // To simplify implementation at this moment we decided to completely
+      // disallow aggregations inside of the CASE.
+      // However, in some cases aggregation makes perfect sense, for example:
+      //    CASE count(n) WHEN 10 THEN "YES" ELSE "NO" END.
+      // TODO: Rethink of allowing aggregations in some parts of the CASE
+      // construct.
+      throw SemanticException("Using aggregation functions inside of CASE is not allowed.");
+    }
+    // Create a virtual symbol for aggregation result.
+    // Currently, we only have aggregation operators which return numbers.
+    auto aggr_name = Aggregation::OpToString(aggr.op_) + std::to_string(aggr.symbol_pos_);
+    aggr.MapTo(CreateSymbol(aggr_name, false, Symbol::Type::NUMBER));
+    scope.in_aggregation = true;
+    scope.has_aggregation = true;
+    return true;
+  }
+
+  bool PostVisit(Aggregation & /*unused*/) override {
+    scopes_.back().in_aggregation = false;
+    return true;
+  }
+
+  bool PreVisit(IfOperator & /*unused*/) override {
+    ++scopes_.back().num_if_operators;
+    return true;
+  }
+
+  bool PostVisit(IfOperator & /*unused*/) override {
+    --scopes_.back().num_if_operators;
+    return true;
+  }
+
+  bool PreVisit(All &all) override {
+    all.list_expression_->Accept(*this);
+    VisitWithIdentifiers(all.where_->expression_, {all.identifier_});
+    return false;
+  }
+
+  bool PreVisit(Single &single) override {
+    single.list_expression_->Accept(*this);
+    VisitWithIdentifiers(single.where_->expression_, {single.identifier_});
+    return false;
+  }
+
+  bool PreVisit(Any &any) override {
+    any.list_expression_->Accept(*this);
+    VisitWithIdentifiers(any.where_->expression_, {any.identifier_});
+    return false;
+  }
+
+  bool PreVisit(None &none) override {
+    none.list_expression_->Accept(*this);
+    VisitWithIdentifiers(none.where_->expression_, {none.identifier_});
+    return false;
+  }
+
+  bool PreVisit(Reduce &reduce) override {
+    reduce.initializer_->Accept(*this);
+    reduce.list_->Accept(*this);
+    VisitWithIdentifiers(reduce.expression_, {reduce.accumulator_, reduce.identifier_});
+    return false;
+  }
+
+  bool PreVisit(Extract &extract) override {
+    extract.list_->Accept(*this);
+    VisitWithIdentifiers(extract.expression_, {extract.identifier_});
+    return false;
+  }
+
+  // Pattern and its subparts.
+  bool PreVisit(Pattern &pattern) override {
+    auto &scope = scopes_.back();
+    scope.in_pattern = true;
+    if ((scope.in_create || scope.in_merge) && pattern.atoms_.size() == 1U) {
+      MG_ASSERT(utils::IsSubtype(*pattern.atoms_[0], NodeAtom::kType), "Expected a single NodeAtom in Pattern");
+      scope.in_create_node = true;
+    }
+    return true;
+  }
+
+  bool PostVisit(Pattern & /*unused*/) override {
+    auto &scope = scopes_.back();
+    scope.in_pattern = false;
+    scope.in_create_node = false;
+    return true;
+  }
+
+  bool PreVisit(NodeAtom &node_atom) override {
+    auto &scope = scopes_.back();
+    auto check_node_semantic = [&node_atom, &scope, this](const bool props_or_labels) {
+      const auto &node_name = node_atom.identifier_->name_;
+      if ((scope.in_create || scope.in_merge) && props_or_labels && HasSymbolLocalScope(node_name)) {
+        throw SemanticException("Cannot create node '" + node_name +
+                                "' with labels or properties, because it is already declared.");
+      }
+      scope.in_pattern_atom_identifier = true;
+      node_atom.identifier_->Accept(*this);
+      scope.in_pattern_atom_identifier = false;
+    };
+
+    scope.in_node_atom = true;
+    if (auto *properties = std::get_if<std::unordered_map<PropertyIx, Expression *>>(&node_atom.properties_)) {
+      bool props_or_labels = !properties->empty() || !node_atom.labels_.empty();
+
+      check_node_semantic(props_or_labels);
+      for (auto kv : *properties) {
+        kv.second->Accept(*this);
+      }
+
+      return false;
+    }
+    auto &properties_parameter = std::get<ParameterLookup *>(node_atom.properties_);
+    bool props_or_labels = !properties_parameter || !node_atom.labels_.empty();
+
+    check_node_semantic(props_or_labels);
+    properties_parameter->Accept(*this);
+    return false;
+  }
+
+  bool PostVisit(NodeAtom & /*unused*/) override {
+    scopes_.back().in_node_atom = false;
+    return true;
+  }
+
+  bool PreVisit(EdgeAtom &edge_atom) override {
+    auto &scope = scopes_.back();
+    scope.visiting_edge = &edge_atom;
+    if (scope.in_create || scope.in_merge) {
+      scope.in_create_edge = true;
+      if (edge_atom.edge_types_.size() != 1U) {
+        throw SemanticException(
+            "A single relationship type must be specified "
+            "when creating an edge.");
+      }
+      if (scope.in_create &&  // Merge allows bidirectionality
+          edge_atom.direction_ == EdgeAtom::Direction::BOTH) {
+        throw SemanticException(
+            "Bidirectional relationship are not supported "
+            "when creating an edge");
+      }
+      if (edge_atom.IsVariable()) {
+        throw SemanticException(
+            "Variable length relationships are not supported when creating an "
+            "edge.");
+      }
+    }
+    if (auto *properties = std::get_if<std::unordered_map<PropertyIx, Expression *>>(&edge_atom.properties_)) {
+      for (auto kv : *properties) {
+        kv.second->Accept(*this);
+      }
+    } else {
+      std::get<ParameterLookup *>(edge_atom.properties_)->Accept(*this);
+    }
+    if (edge_atom.IsVariable()) {
+      scope.in_edge_range = true;
+      if (edge_atom.lower_bound_) {
+        edge_atom.lower_bound_->Accept(*this);
+      }
+      if (edge_atom.upper_bound_) {
+        edge_atom.upper_bound_->Accept(*this);
+      }
+      scope.in_edge_range = false;
+      scope.in_pattern = false;
+      if (edge_atom.filter_lambda_.expression) {
+        VisitWithIdentifiers(edge_atom.filter_lambda_.expression,
+                             {edge_atom.filter_lambda_.inner_edge, edge_atom.filter_lambda_.inner_node});
+      } else {
+        // Create inner symbols, but don't bind them in scope, since they are to
+        // be used in the missing filter expression.
+        auto *inner_edge = edge_atom.filter_lambda_.inner_edge;
+        inner_edge->MapTo(
+            symbol_table_->CreateSymbol(inner_edge->name_, inner_edge->user_declared_, Symbol::Type::EDGE));
+        auto *inner_node = edge_atom.filter_lambda_.inner_node;
+        inner_node->MapTo(
+            symbol_table_->CreateSymbol(inner_node->name_, inner_node->user_declared_, Symbol::Type::VERTEX));
+      }
+      if (edge_atom.weight_lambda_.expression) {
+        VisitWithIdentifiers(edge_atom.weight_lambda_.expression,
+                             {edge_atom.weight_lambda_.inner_edge, edge_atom.weight_lambda_.inner_node});
+      }
+      scope.in_pattern = true;
+    }
+    scope.in_pattern_atom_identifier = true;
+    edge_atom.identifier_->Accept(*this);
+    scope.in_pattern_atom_identifier = false;
+    if (edge_atom.total_weight_) {
+      if (HasSymbolLocalScope(edge_atom.total_weight_->name_)) {
+        throw RedeclareVariableError(edge_atom.total_weight_->name_);
+      }
+      edge_atom.total_weight_->MapTo(GetOrCreateSymbolLocalScope(
+          edge_atom.total_weight_->name_, edge_atom.total_weight_->user_declared_, Symbol::Type::NUMBER));
+    }
+    return false;
+  }
+
+  bool PostVisit(EdgeAtom & /*unused*/) override {
+    auto &scope = scopes_.back();
+    scope.visiting_edge = nullptr;
+    scope.in_create_edge = false;
+    return true;
+  }
+
+ private:
+  // Scope stores the state of where we are when visiting the AST and a map of
+  // names to symbols.
+  struct Scope {
+    bool in_pattern{false};
+    bool in_merge{false};
+    bool in_create{false};
+    // in_create_node is true if we are creating or merging *only* a node.
+    // Therefore, it is *not* equivalent to (in_create || in_merge) &&
+    // in_node_atom.
+    bool in_create_node{false};
+    // True if creating an edge;
+    // shortcut for (in_create || in_merge) && visiting_edge.
+    bool in_create_edge{false};
+    bool in_node_atom{false};
+    EdgeAtom *visiting_edge{nullptr};
+    bool in_aggregation{false};
+    bool in_return{false};
+    bool in_with{false};
+    bool in_skip{false};
+    bool in_limit{false};
+    bool in_order_by{false};
+    bool in_where{false};
+    bool in_match{false};
+    bool in_foreach{false};
+    // True when visiting a pattern atom (node or edge) identifier, which can be
+    // reused or created in the pattern itself.
+    bool in_pattern_atom_identifier{false};
+    // True when visiting range bounds of a variable path.
+    bool in_edge_range{false};
+    // True if the return/with contains an aggregation in any named expression.
+    bool has_aggregation{false};
+    // Map from variable names to symbols.
+    std::map<std::string, Symbol> symbols;
+    // Identifiers found in property maps of patterns or as variable length path
+    // bounds in a single Match clause. They need to be checked after visiting
+    // Match. Identifiers created by naming vertices, edges and paths are *not*
+    // stored in here.
+    std::vector<Identifier *> identifiers_in_match;
+    // Number of nested IfOperators.
+    int num_if_operators{0};
+  };
+
+  inline static std::optional<Symbol> FindSymbolInScope(const std::string &name, const Scope &scope,
+                                                        Symbol::Type type) {
+    if (auto it = scope.symbols.find(name); it != scope.symbols.end()) {
+      const auto &symbol = it->second;
+      // Unless we have `ANY` type, check that types match.
+      if (type != Symbol::Type::ANY && symbol.type() != Symbol::Type::ANY && type != symbol.type()) {
+        throw TypeMismatchError(name, Symbol::TypeToString(symbol.type()), Symbol::TypeToString(type));
+      }
+      return symbol;
+    }
+    return std::nullopt;
+  }
+
+  bool HasSymbol(const std::string &name) const {
+    return std::ranges::any_of(scopes_, [&name](const auto &scope) { return scope.symbols.contains(name); });
+  }
+
+  bool HasSymbolLocalScope(const std::string &name) const { return scopes_.back().symbols.contains(name); }
+
+  // @return true if it added a predefined identifier with that name
+  bool ConsumePredefinedIdentifier(const std::string &name) {
+    auto it = predefined_identifiers_.find(name);
+
+    if (it == predefined_identifiers_.end()) {
+      return false;
+    }
+
+    // we can only use the predefined identifier in a single scope so we remove it after creating
+    // a symbol for it
+    auto &identifier = it->second;
+    MG_ASSERT(!identifier->user_declared_, "Predefined symbols cannot be user declared!");
+    identifier->MapTo(CreateSymbol(identifier->name_, identifier->user_declared_));
+    predefined_identifiers_.erase(it);
+    return true;
+  }
+
+  // Returns a freshly generated symbol. Previous mapping of the same name to a
+  // different symbol is replaced with the new one.
+  Symbol CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY,
+                      int token_position = -1) {
+    auto symbol = symbol_table_->CreateSymbol(name, user_declared, type, token_position);
+    scopes_.back().symbols[name] = symbol;
+    return symbol;
+  }
+
+  Symbol GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY) {
+    // NOLINTNEXTLINE
+    for (auto scope = scopes_.rbegin(); scope != scopes_.rend(); ++scope) {
+      if (auto maybe_symbol = FindSymbolInScope(name, *scope, type); maybe_symbol) {
+        return *maybe_symbol;
+      }
+    }
+    return CreateSymbol(name, user_declared, type);
+  }
+
+  // Returns the symbol by name. If the mapping already exists, checks if the
+  // types match. Otherwise, returns a new symbol.
+  Symbol GetOrCreateSymbolLocalScope(const std::string &name, bool user_declared,
+                                     Symbol::Type type = Symbol::Type::ANY) {
+    auto &scope = scopes_.back();
+    if (auto maybe_symbol = FindSymbolInScope(name, scope, type); maybe_symbol) {
+      return *maybe_symbol;
+    }
+    return CreateSymbol(name, user_declared, type);
+  }
+
+  void VisitReturnBody(ReturnBody &body, Where *where = nullptr) {
+    auto &scope = scopes_.back();
+    for (auto &expr : body.named_expressions) {
+      expr->Accept(*this);
+    }
+    std::vector<Symbol> user_symbols;
+    if (body.all_identifiers) {
+      // Carry over user symbols because '*' appeared.
+      for (const auto &sym_pair : scope.symbols) {
+        if (!sym_pair.second.user_declared()) {
+          continue;
+        }
+        user_symbols.emplace_back(sym_pair.second);
+      }
+      if (user_symbols.empty()) {
+        throw SemanticException("There are no variables in scope to use for '*'.");
+      }
+    }
+    // WITH/RETURN clause removes declarations of all the previous variables and
+    // declares only those established through named expressions. New declarations
+    // must not be visible inside named expressions themselves.
+    bool removed_old_names = false;
+    if ((!where && body.order_by.empty()) || scope.has_aggregation) {
+      // WHERE and ORDER BY need to see both the old and new symbols, unless we
+      // have an aggregation. Therefore, we can clear the symbols immediately if
+      // there is neither ORDER BY nor WHERE, or we have an aggregation.
+      scope.symbols.clear();
+      removed_old_names = true;
+    }
+    // Create symbols for named expressions.
+    std::unordered_set<std::string> new_names;
+    for (const auto &user_sym : user_symbols) {
+      new_names.insert(user_sym.name());
+      scope.symbols[user_sym.name()] = user_sym;
+    }
+    for (auto &named_expr : body.named_expressions) {
+      const auto &name = named_expr->name_;
+      if (!new_names.insert(name).second) {
+        throw SemanticException("Multiple results with the same name '{}' are not allowed.", name);
+      }
+      // An improvement would be to infer the type of the expression, so that the
+      // new symbol would have a more specific type.
+      named_expr->MapTo(CreateSymbol(name, true, Symbol::Type::ANY, named_expr->token_position_));
+    }
+    scope.in_order_by = true;
+    for (const auto &order_pair : body.order_by) {
+      order_pair.expression->Accept(*this);
+    }
+    scope.in_order_by = false;
+    if (body.skip) {
+      scope.in_skip = true;
+      body.skip->Accept(*this);
+      scope.in_skip = false;
+    }
+    if (body.limit) {
+      scope.in_limit = true;
+      body.limit->Accept(*this);
+      scope.in_limit = false;
+    }
+    if (where) where->Accept(*this);
+    if (!removed_old_names) {
+      // We have an ORDER BY or WHERE, but no aggregation, which means we didn't
+      // clear the old symbols, so do it now. We cannot just call clear, because
+      // we've added new symbols.
+      for (auto sym_it = scope.symbols.begin(); sym_it != scope.symbols.end();) {
+        if (new_names.find(sym_it->first) == new_names.end()) {
+          sym_it = scope.symbols.erase(sym_it);
+        } else {
+          sym_it++;
+        }
+      }
+    }
+    scopes_.back().has_aggregation = false;
+  }
+
+  void VisitWithIdentifiers(Expression *expr, const std::vector<Identifier *> &identifiers) {
+    auto &scope = scopes_.back();
+    std::vector<std::pair<std::optional<Symbol>, Identifier *>> prev_symbols;
+    // Collect previous symbols if they exist.
+    for (const auto &identifier : identifiers) {
+      std::optional<Symbol> prev_symbol;
+      auto prev_symbol_it = scope.symbols.find(identifier->name_);
+      if (prev_symbol_it != scope.symbols.end()) {
+        prev_symbol = prev_symbol_it->second;
+      }
+      identifier->MapTo(CreateSymbol(identifier->name_, identifier->user_declared_));
+      prev_symbols.emplace_back(prev_symbol, identifier);
+    }
+    // Visit the expression with the new symbols bound.
+    expr->Accept(*this);
+    // Restore back to previous symbols.
+    for (const auto &prev : prev_symbols) {
+      const auto &prev_symbol = prev.first;
+      const auto &identifier = prev.second;
+      if (prev_symbol) {
+        scope.symbols[identifier->name_] = *prev_symbol;
+      } else {
+        scope.symbols.erase(identifier->name_);
+      }
+    }
+  }
+
+  SymbolTable *symbol_table_;
+
+  // Identifiers which are injected from outside the query. Each identifier
+  // is mapped by its name.
+  std::unordered_map<std::string, Identifier *> predefined_identifiers_;
+  std::vector<Scope> scopes_;
+  std::unordered_set<std::string> prev_return_names_;
+  std::unordered_set<std::string> curr_return_names_;
+};
+
+inline SymbolTable MakeSymbolTable(CypherQuery *query, const std::vector<Identifier *> &predefined_identifiers = {}) {
+  SymbolTable symbol_table;
+  SymbolGenerator symbol_generator(&symbol_table, predefined_identifiers);
+  query->single_query_->Accept(symbol_generator);
+  for (auto *cypher_union : query->cypher_unions_) {
+    cypher_union->Accept(symbol_generator);
+  }
+  return symbol_table;
+}
+
+}  // namespace memgraph::expr

src/expr/semantic/symbol_table.hpp

@@ -14,11 +14,11 @@
 #include <map>
 #include <string>
 
-#include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/semantic/symbol.hpp"
+#include "expr/ast.hpp"
+#include "expr/semantic/symbol.hpp"
 #include "utils/logging.hpp"
 
-namespace memgraph::query::v2 {
+namespace memgraph::expr {
 
 class SymbolTable final {
  public:
@@ -61,4 +61,4 @@ class SymbolTable final {
   std::map<int32_t, Symbol> table_;
 };
 
-}  // namespace memgraph::query::v2
+}  // namespace memgraph::expr

src/glue/v2/communication.hpp

@@ -13,7 +13,7 @@
 #pragma once
 
 #include "communication/bolt/v1/value.hpp"
-#include "query/v2/typed_value.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/result.hpp"
 #include "storage/v3/view.hpp"

src/parser/CMakeLists.txt

@@ -0,0 +1,41 @@
+## Generate Antlr openCypher parser
+
+set(opencypher_frontend ${CMAKE_CURRENT_SOURCE_DIR}/opencypher)
+set(opencypher_generated ${opencypher_frontend}/generated)
+set(opencypher_lexer_grammar ${opencypher_frontend}/grammar/MemgraphCypherLexer.g4)
+set(opencypher_parser_grammar ${opencypher_frontend}/grammar/MemgraphCypher.g4)
+
+set(antlr_opencypher_generated_src
+    ${opencypher_generated}/MemgraphCypherLexer.cpp
+    ${opencypher_generated}/MemgraphCypher.cpp
+    ${opencypher_generated}/MemgraphCypherBaseVisitor.cpp
+    ${opencypher_generated}/MemgraphCypherVisitor.cpp
+)
+set(antlr_opencypher_generated_include
+    ${opencypher_generated}/MemgraphCypherLexer.h
+    ${opencypher_generated}/MemgraphCypher.h
+    ${opencypher_generated}/MemgraphCypherBaseVisitor.h
+    ${opencypher_generated}/MemgraphCypherVisitor.h
+)
+
+add_custom_command(
+    OUTPUT ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include}
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${opencypher_generated}
+    COMMAND
+        java -jar ${CMAKE_SOURCE_DIR}/libs/antlr-4.10.1-complete.jar
+            -Dlanguage=Cpp -visitor -package antlropencypher
+            -o ${opencypher_generated}
+            ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
+    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+    DEPENDS
+        ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
+        ${opencypher_frontend}/grammar/CypherLexer.g4
+        ${opencypher_frontend}/grammar/Cypher.g4)
+
+add_custom_target(generated_opencypher_parser
+    DEPENDS ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include})
+
+add_library(mg-parser STATIC ${antlr_opencypher_generated_src})
+add_dependencies(mg-parser generated_opencypher_parser)
+target_include_directories(mg-parser PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(mg-parser antlr4)

src/parser/opencypher/grammar/CypherLexer.g4

@@ -1,6 +1,6 @@
 /*
  * When changing this grammar make sure to update constants in
- * src/query/frontend/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
+ * src/parser/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
  * and bitsets) if needed.
  */
 

src/parser/opencypher/grammar/MemgraphCypherLexer.g4

@@ -15,7 +15,7 @@
 
 /*
  * When changing this grammar make sure to update constants in
- * src/query/frontend/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
+ * src/parser/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
  * and bitsets) if needed.
  */
 

src/parser/opencypher/parser.hpp

@@ -14,17 +14,29 @@
 #include <string>
 
 #include "antlr4-runtime.h"
-#include "query/v2/exceptions.hpp"
-#include "query/v2/frontend/opencypher/generated/MemgraphCypher.h"
-#include "query/v2/frontend/opencypher/generated/MemgraphCypherLexer.h"
+#include "utils/exceptions.hpp"
+#include "parser/opencypher/generated/MemgraphCypher.h"
+#include "parser/opencypher/generated/MemgraphCypherLexer.h"
+#include "utils/concepts.hpp"
 
-namespace memgraph::query::v2::frontend::opencypher {
+namespace memgraph::frontend::opencypher {
+
+class SyntaxException : public utils::BasicException {
+ public:
+  using utils::BasicException::BasicException;
+  SyntaxException() : SyntaxException("") {}
+};
 
 /**
  * Generates openCypher AST
  * This thing must me a class since parser.cypher() returns pointer and there is
  * no way for us to get ownership over the object.
  */
+enum class ParserOpTag : uint8_t {
+  CYPHER, EXPRESSION
+};
+
+template<ParserOpTag Tag = ParserOpTag::CYPHER>
 class Parser {
  public:
   /**
@@ -34,9 +46,14 @@ class Parser {
   Parser(const std::string query) : query_(std::move(query)) {
     parser_.removeErrorListeners();
     parser_.addErrorListener(&error_listener_);
-    tree_ = parser_.cypher();
+    if constexpr(Tag == ParserOpTag::CYPHER) {
+      tree_ = parser_.cypher();
+    }
+    else {
+      tree_ = parser_.expression();
+    }
     if (parser_.getNumberOfSyntaxErrors()) {
-      throw query::v2::SyntaxException(error_listener_.error_);
+      throw SyntaxException(error_listener_.error_);
     }
   }
 
@@ -65,4 +82,4 @@ class Parser {
   antlropencypher::MemgraphCypher parser_{&tokens_};
   antlr4::tree::ParseTree *tree_ = nullptr;
 };
-}  // namespace memgraph::query::v2::frontend::opencypher
+}  // namespace memgraph::frontend::opencypher

src/parser/stripped_lexer_constants.hpp

@@ -17,7 +17,7 @@
 #include <unordered_set>
 #include <vector>
 
-namespace memgraph::query::v2 {
+namespace parser {
 namespace lexer_constants {
 
 namespace trie {
@@ -2922,4 +2922,4 @@ const trie::Trie kSpecialTokens = {";",
                                    "\xEF\xB9\xA3",   // u8"\ufe63"
                                    "\xEF\xBC\x8D"};  // u8"\uff0d"
 }  // namespace lexer_constants
-}  // namespace memgraph::query::v2
+}  // namespace parser

src/query/v2/CMakeLists.txt

@@ -1,7 +1,6 @@
 define_add_lcp(add_lcp_query lcp_query_v2_cpp_files generated_lcp_query_v2_files)
 
 add_lcp_query(frontend/ast/ast.lcp)
-add_lcp_query(frontend/semantic/symbol.lcp)
 add_lcp_query(plan/operator.lcp)
 
 add_custom_target(generate_lcp_query_v2 DEPENDS ${generated_lcp_query_v2_files})
@@ -11,14 +10,9 @@ set(mg_query_v2_sources
     common.cpp
     cypher_query_interpreter.cpp
     dump.cpp
-    frontend/ast/cypher_main_visitor.cpp
-    frontend/ast/pretty_print.cpp
-    frontend/parsing.cpp
     frontend/semantic/required_privileges.cpp
-    frontend/semantic/symbol_generator.cpp
     frontend/stripped.cpp
     interpret/awesome_memgraph_functions.cpp
-    interpret/eval.cpp
     interpreter.cpp
     metadata.cpp
     plan/operator.cpp
@@ -39,15 +33,17 @@ set(mg_query_v2_sources
     stream/common.cpp
     trigger.cpp
     trigger_context.cpp
-    typed_value.cpp)
+    bindings/typed_value.cpp)
 
 find_package(Boost REQUIRED)
 
 add_library(mg-query-v2 STATIC ${mg_query_v2_sources})
 add_dependencies(mg-query-v2 generate_lcp_query_v2)
 target_include_directories(mg-query-v2 PUBLIC ${CMAKE_SOURCE_DIR}/include)
+target_include_directories(mg-query-v2 PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/bindings)
 target_link_libraries(mg-query-v2 dl cppitertools Boost::headers)
 target_link_libraries(mg-query-v2 mg-integrations-pulsar mg-integrations-kafka mg-storage-v3 mg-license mg-utils mg-kvstore mg-memory)
+target_link_libraries(mg-query-v2 mg-expr)
 
 if(NOT "${MG_PYTHON_PATH}" STREQUAL "")
     set(Python3_ROOT_DIR "${MG_PYTHON_PATH}")
@@ -60,45 +56,3 @@ else()
 endif()
 
 target_link_libraries(mg-query-v2 Python3::Python)
-
-# Generate Antlr openCypher parser
-set(opencypher_frontend ${CMAKE_CURRENT_SOURCE_DIR}/frontend/opencypher)
-set(opencypher_generated ${opencypher_frontend}/generated)
-set(opencypher_lexer_grammar ${opencypher_frontend}/grammar/MemgraphCypherLexer.g4)
-set(opencypher_parser_grammar ${opencypher_frontend}/grammar/MemgraphCypher.g4)
-
-set(antlr_opencypher_generated_src
-    ${opencypher_generated}/MemgraphCypherLexer.cpp
-    ${opencypher_generated}/MemgraphCypher.cpp
-    ${opencypher_generated}/MemgraphCypherBaseVisitor.cpp
-    ${opencypher_generated}/MemgraphCypherVisitor.cpp
-)
-set(antlr_opencypher_generated_include
-    ${opencypher_generated}/MemgraphCypherLexer.h
-    ${opencypher_generated}/MemgraphCypher.h
-    ${opencypher_generated}/MemgraphCypherBaseVisitor.h
-    ${opencypher_generated}/MemgraphCypherVisitor.h
-)
-
-add_custom_command(
-    OUTPUT ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include}
-    COMMAND ${CMAKE_COMMAND} -E make_directory ${opencypher_generated}
-    COMMAND
-    java -jar ${CMAKE_SOURCE_DIR}/libs/antlr-4.10.1-complete.jar
-    -Dlanguage=Cpp -visitor -package antlropencypher
-    -o ${opencypher_generated}
-    ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
-    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
-    DEPENDS
-    ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
-    ${opencypher_frontend}/grammar/CypherLexer.g4
-    ${opencypher_frontend}/grammar/Cypher.g4)
-
-add_custom_target(generate_opencypher_parser_v2
-    DEPENDS ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include})
-
-add_library(antlr_opencypher_parser_lib_v2 STATIC ${antlr_opencypher_generated_src})
-add_dependencies(antlr_opencypher_parser_lib_v2 generate_opencypher_parser_v2)
-target_link_libraries(antlr_opencypher_parser_lib_v2 antlr4)
-
-target_link_libraries(mg-query-v2 antlr_opencypher_parser_lib_v2)

src/query/v2/bindings/ast_visitor.hpp

@@ -0,0 +1,16 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "query/v2/bindings/bindings.hpp"
+
+#include "expr/ast/ast_visitor.hpp"

src/query/v2/bindings/bindings.hpp

@@ -0,0 +1,15 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#define MG_AST_INCLUDE_PATH "query/v2/frontend/ast/ast.hpp"  // NOLINT(cppcoreguidelines-macro-usage)
+#define MG_INJECTED_NAMESPACE_NAME memgraph::query::v2       // NOLINT(cppcoreguidelines-macro-usage)

src/query/v2/bindings/cypher_main_visitor.hpp

@@ -0,0 +1,20 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "query/v2/bindings/bindings.hpp"
+
+#include "expr/ast/cypher_main_visitor.hpp"
+
+namespace memgraph::query::v2 {
+using CypherMainVisitor = memgraph::expr::CypherMainVisitor;
+}  // namespace memgraph::query::v2

src/query/v2/bindings/eval.hpp

@@ -0,0 +1,34 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "query/v2/bindings/bindings.hpp"
+
+#include "expr/interpret/eval.hpp"
+#include "query/v2/bindings/typed_value.hpp"
+#include "query/v2/context.hpp"
+#include "query/v2/db_accessor.hpp"
+#include "storage/v3/id_types.hpp"
+#include "storage/v3/property_store.hpp"
+#include "storage/v3/view.hpp"
+#include "storage/v3/conversions.hpp"
+
+namespace memgraph::query::v2 {
+
+inline const auto lam = [](const auto &val) { return memgraph::storage::v3::PropertyToTypedValue<TypedValue>(val); };
+
+using ExpressionEvaluator =
+    memgraph::expr::ExpressionEvaluator<TypedValue, EvaluationContext, DbAccessor, storage::v3::View,
+                                        storage::v3::LabelId, storage::v3::PropertyStore, decltype(lam),
+                                        memgraph::storage::v3::Error>;
+
+}  // namespace memgraph::query::v2

src/query/v2/bindings/frame.hpp

@@ -0,0 +1,21 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "query/v2/bindings/bindings.hpp"
+
+#include "query/v2/bindings/typed_value.hpp"
+#include "expr/interpret/frame.hpp"
+
+namespace memgraph::query::v2 {
+using Frame = memgraph::expr::Frame<TypedValue>;
+} // namespace memgraph::query::v2

src/query/v2/bindings/pretty_print.hpp

@@ -11,13 +11,9 @@
 
 #pragma once
 
-#include <iostream>
+#include "query/v2/bindings/bindings.hpp"
 
-#include "query/v2/frontend/ast/ast.hpp"
+#include "expr/ast/pretty_print.hpp"
 
 namespace memgraph::query::v2 {
-
-void PrintExpression(Expression *expr, std::ostream *out);
-void PrintExpression(NamedExpression *expr, std::ostream *out);
-
 }  // namespace memgraph::query::v2

src/query/v2/bindings/symbol.hpp

@@ -0,0 +1,20 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "query/v2/bindings/bindings.hpp"
+
+#include "expr/semantic/symbol.hpp"
+
+namespace memgraph::query::v2 {
+using Symbol = memgraph::expr::Symbol;
+} // namespace memgraph::query::v2

src/query/v2/bindings/symbol_generator.hpp

@@ -0,0 +1,16 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "query/v2/bindings/bindings.hpp"
+
+#include "expr/semantic/symbol_generator.hpp"

src/query/v2/bindings/symbol_table.hpp

@@ -0,0 +1,20 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "query/v2/bindings/bindings.hpp"
+
+#include "expr/semantic/symbol_table.hpp"
+
+namespace memgraph::query::v2 {
+using SymbolTable = memgraph::expr::SymbolTable;
+} // namespace memgraph::query::v2

src/query/v2/bindings/typed_value.cpp

@@ -0,0 +1,19 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "expr/typed_value.hpp"
+#include "query/v2/db_accessor.hpp"
+#include "query/v2/path.hpp"
+
+namespace memgraph::expr {
+namespace v2 = memgraph::query::v2;
+template class TypedValueT<v2::VertexAccessor, v2::EdgeAccessor, v2::Path>;
+}  // namespace memgraph::expr

src/query/v2/bindings/typed_value.hpp

@@ -0,0 +1,26 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "query/v2/bindings/bindings.hpp"
+
+#include "expr/typed_value.hpp"
+#include "query/v2/db_accessor.hpp"
+#include "query/v2/path.hpp"
+
+namespace memgraph::expr {
+namespace v2 = memgraph::query::v2;
+extern template class memgraph::expr::TypedValueT<v2::VertexAccessor, v2::EdgeAccessor, v2::Path>;
+}  // namespace memgraph::expr
+namespace memgraph::query::v2 {
+using TypedValue = memgraph::expr::TypedValueT<VertexAccessor, EdgeAccessor, Path>;
+}  // namespace memgraph::query::v2

src/query/v2/common.hpp

@@ -18,11 +18,13 @@
 #include <string_view>
 #include <type_traits>
 
+#include "query/v2/bindings/symbol.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/semantic/symbol.hpp"
-#include "query/v2/typed_value.hpp"
+#include "query/v2/path.hpp"
+#include "storage/v3/conversions.hpp"
 #include "storage/v3/id_types.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/result.hpp"
@@ -142,7 +144,7 @@ storage::v3::PropertyValue PropsSetChecked(T *record, const DbAccessor &dba, con
                                            const TypedValue &value) {
   try {
     if constexpr (std::is_same_v<T, VertexAccessor>) {
-      const auto maybe_old_value = record->SetPropertyAndValidate(key, storage::v3::PropertyValue(value));
+      const auto maybe_old_value = record->SetPropertyAndValidate(key, storage::v3::TypedToPropertyValue(value));
       if (maybe_old_value.HasError()) {
         std::visit(utils::Overloaded{[](const storage::v3::Error error) { HandleErrorOnPropertyUpdate(error); },
                                      [&dba](const storage::v3::SchemaViolation &schema_violation) {
@@ -153,13 +155,13 @@ storage::v3::PropertyValue PropsSetChecked(T *record, const DbAccessor &dba, con
       return std::move(*maybe_old_value);
     } else {
       // No validation on edge properties
-      const auto maybe_old_value = record->SetProperty(key, storage::v3::PropertyValue(value));
+      const auto maybe_old_value = record->SetProperty(key, storage::v3::TypedToPropertyValue(value));
       if (maybe_old_value.HasError()) {
         HandleErrorOnPropertyUpdate(maybe_old_value.GetError());
       }
       return std::move(*maybe_old_value);
     }
-  } catch (const TypedValueException &) {
+  } catch (const expr::TypedValueException &) {
     throw QueryRuntimeException("'{}' cannot be used as a property value.", value.type());
   }
 }

src/query/v2/context.hpp

@@ -13,8 +13,8 @@
 
 #include <type_traits>
 
+#include "query/v2/bindings/symbol_table.hpp"
 #include "query/v2/common.hpp"
-#include "query/v2/frontend/semantic/symbol_table.hpp"
 #include "query/v2/metadata.hpp"
 #include "query/v2/parameters.hpp"
 #include "query/v2/plan/profile.hpp"

src/query/v2/cypher_query_interpreter.cpp

@@ -10,6 +10,7 @@
 // licenses/APL.txt.
 
 #include "query/v2/cypher_query_interpreter.hpp"
+#include "query/v2/bindings/symbol_generator.hpp"
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_HIDDEN_bool(query_cost_planner, true, "Use the cost-estimating query planner.");
@@ -46,7 +47,7 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
   auto hash = stripped_query.hash();
   auto accessor = cache->access();
   auto it = accessor.find(hash);
-  std::unique_ptr<frontend::opencypher::Parser> parser;
+  std::unique_ptr<memgraph::frontend::opencypher::Parser<>> parser;
 
   // Return a copy of both the AST storage and the query.
   CachedQuery result;
@@ -63,11 +64,11 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
 
   if (it == accessor.end()) {
     try {
-      parser = std::make_unique<frontend::opencypher::Parser>(stripped_query.query());
+      parser = std::make_unique<memgraph::frontend::opencypher::Parser<>>(stripped_query.query());
     } catch (const SyntaxException &e) {
       // There is a syntax exception in the stripped query. Re-run the parser
       // on the original query to get an appropriate error messsage.
-      parser = std::make_unique<frontend::opencypher::Parser>(query_string);
+      parser = std::make_unique<memgraph::frontend::opencypher::Parser<>>(query_string);
 
       // If an exception was not thrown here, the stripper messed something
       // up.
@@ -76,8 +77,8 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
 
     // Convert the ANTLR4 parse tree into an AST.
     AstStorage ast_storage;
-    frontend::ParsingContext context{true};
-    frontend::CypherMainVisitor visitor(context, &ast_storage);
+    expr::ParsingContext context{true};
+    memgraph::expr::CypherMainVisitor visitor(context, &ast_storage);
 
     visitor.visit(parser->tree());
 
@@ -119,7 +120,7 @@ std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery
                                              DbAccessor *db_accessor,
                                              const std::vector<Identifier *> &predefined_identifiers) {
   auto vertex_counts = plan::MakeVertexCountCache(db_accessor);
-  auto symbol_table = MakeSymbolTable(query, predefined_identifiers);
+  auto symbol_table = expr::MakeSymbolTable(query, predefined_identifiers);
   auto planning_context = plan::MakePlanningContext(&ast_storage, &symbol_table, query, &vertex_counts);
   auto [root, cost] = plan::MakeLogicalPlan(&planning_context, parameters, FLAGS_query_cost_planner);
   return std::make_unique<SingleNodeLogicalPlan>(std::move(root), cost, std::move(ast_storage),

src/query/v2/cypher_query_interpreter.hpp

@@ -11,11 +11,11 @@
 
 #pragma once
 
+#include "parser/opencypher/parser.hpp"
+#include "query/v2/bindings/cypher_main_visitor.hpp"
+#include "query/v2/bindings/symbol_table.hpp"
 #include "query/v2/config.hpp"
-#include "query/v2/frontend/ast/cypher_main_visitor.hpp"
-#include "query/v2/frontend/opencypher/parser.hpp"
 #include "query/v2/frontend/semantic/required_privileges.hpp"
-#include "query/v2/frontend/semantic/symbol_generator.hpp"
 #include "query/v2/frontend/stripped.hpp"
 #include "query/v2/plan/planner.hpp"
 #include "utils/flag_validation.hpp"

src/query/v2/discard_value_stream.hpp

@@ -13,7 +13,7 @@
 
 #include <vector>
 
-#include "query/v2/typed_value.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 
 namespace memgraph::query::v2 {
 struct DiscardValueResultStream final {

src/query/v2/dump.cpp

@@ -21,10 +21,10 @@
 
 #include <fmt/format.h>
 
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/stream.hpp"
-#include "query/v2/typed_value.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/storage.hpp"
 #include "utils/algorithm.hpp"

src/query/v2/frontend/ast/ast.lcp

@@ -17,11 +17,12 @@
 #include <variant>
 #include <vector>
 
-#include "query/v2/frontend/ast/ast_visitor.hpp"
-#include "query/v2/frontend/semantic/symbol.hpp"
+#include "query/v2/bindings/ast_visitor.hpp"
+#include "query/v2/bindings/symbol.hpp"
 #include "query/v2/interpret/awesome_memgraph_functions.hpp"
-#include "query/v2/typed_value.hpp"
-#include "storage/v3/property_value.hpp"
+#include "query/v2/bindings/typed_value.hpp"
+#include "query/v2/db_accessor.hpp"
+#include "query/v2/path.hpp"
 #include "utils/typeinfo.hpp"
 
 cpp<#
@@ -630,7 +631,7 @@ cpp<#
   (:clone))
 
 (lcp:define-class primitive-literal (base-literal)
-  ((value "::storage::v3::PropertyValue" :scope :public)
+  ((value "TypedValue" :scope :public)
    (token-position :int32_t :scope :public :initval -1
                    :documentation "This field contains token position of literal used to create PrimitiveLiteral object. If PrimitiveLiteral object is not created from query, leave its value at -1."))
   (:public

src/query/v2/frontend/ast/cypher_main_visitor.hpp

@@ -1,921 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <string>
-#include <unordered_set>
-#include <utility>
-
-#include <antlr4-runtime.h>
-
-#include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/opencypher/generated/MemgraphCypherBaseVisitor.h"
-#include "utils/exceptions.hpp"
-#include "utils/logging.hpp"
-
-namespace memgraph::query::v2::frontend {
-
-using antlropencypher::MemgraphCypher;
-
-struct ParsingContext {
-  bool is_query_cached = false;
-};
-
-class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
- public:
-  explicit CypherMainVisitor(ParsingContext context, AstStorage *storage) : context_(context), storage_(storage) {}
-
- private:
-  Expression *CreateBinaryOperatorByToken(size_t token, Expression *e1, Expression *e2) {
-    switch (token) {
-      case MemgraphCypher::OR:
-        return storage_->Create<OrOperator>(e1, e2);
-      case MemgraphCypher::XOR:
-        return storage_->Create<XorOperator>(e1, e2);
-      case MemgraphCypher::AND:
-        return storage_->Create<AndOperator>(e1, e2);
-      case MemgraphCypher::PLUS:
-        return storage_->Create<AdditionOperator>(e1, e2);
-      case MemgraphCypher::MINUS:
-        return storage_->Create<SubtractionOperator>(e1, e2);
-      case MemgraphCypher::ASTERISK:
-        return storage_->Create<MultiplicationOperator>(e1, e2);
-      case MemgraphCypher::SLASH:
-        return storage_->Create<DivisionOperator>(e1, e2);
-      case MemgraphCypher::PERCENT:
-        return storage_->Create<ModOperator>(e1, e2);
-      case MemgraphCypher::EQ:
-        return storage_->Create<EqualOperator>(e1, e2);
-      case MemgraphCypher::NEQ1:
-      case MemgraphCypher::NEQ2:
-        return storage_->Create<NotEqualOperator>(e1, e2);
-      case MemgraphCypher::LT:
-        return storage_->Create<LessOperator>(e1, e2);
-      case MemgraphCypher::GT:
-        return storage_->Create<GreaterOperator>(e1, e2);
-      case MemgraphCypher::LTE:
-        return storage_->Create<LessEqualOperator>(e1, e2);
-      case MemgraphCypher::GTE:
-        return storage_->Create<GreaterEqualOperator>(e1, e2);
-      default:
-        throw utils::NotYetImplemented("binary operator");
-    }
-  }
-
-  Expression *CreateUnaryOperatorByToken(size_t token, Expression *e) {
-    switch (token) {
-      case MemgraphCypher::NOT:
-        return storage_->Create<NotOperator>(e);
-      case MemgraphCypher::PLUS:
-        return storage_->Create<UnaryPlusOperator>(e);
-      case MemgraphCypher::MINUS:
-        return storage_->Create<UnaryMinusOperator>(e);
-      default:
-        throw utils::NotYetImplemented("unary operator");
-    }
-  }
-
-  auto ExtractOperators(std::vector<antlr4::tree::ParseTree *> &all_children,
-                        const std::vector<size_t> &allowed_operators) {
-    std::vector<size_t> operators;
-    for (auto *child : all_children) {
-      antlr4::tree::TerminalNode *operator_node = nullptr;
-      if ((operator_node = dynamic_cast<antlr4::tree::TerminalNode *>(child))) {
-        if (std::find(allowed_operators.begin(), allowed_operators.end(), operator_node->getSymbol()->getType()) !=
-            allowed_operators.end()) {
-          operators.push_back(operator_node->getSymbol()->getType());
-        }
-      }
-    }
-    return operators;
-  }
-
-  /**
-   * Convert opencypher's n-ary production to ast binary operators.
-   *
-   * @param _expressions Subexpressions of child for which we construct ast
-   * operators, for example expression6 if we want to create ast nodes for
-   * expression7.
-   */
-  template <typename TExpression>
-  Expression *LeftAssociativeOperatorExpression(std::vector<TExpression *> _expressions,
-                                                std::vector<antlr4::tree::ParseTree *> all_children,
-                                                const std::vector<size_t> &allowed_operators) {
-    DMG_ASSERT(_expressions.size(), "can't happen");
-    std::vector<Expression *> expressions;
-    auto operators = ExtractOperators(all_children, allowed_operators);
-
-    for (auto *expression : _expressions) {
-      expressions.push_back(std::any_cast<Expression *>(expression->accept(this)));
-    }
-
-    Expression *first_operand = expressions[0];
-    for (int i = 1; i < (int)expressions.size(); ++i) {
-      first_operand = CreateBinaryOperatorByToken(operators[i - 1], first_operand, expressions[i]);
-    }
-    return first_operand;
-  }
-
-  template <typename TExpression>
-  Expression *PrefixUnaryOperator(TExpression *_expression, std::vector<antlr4::tree::ParseTree *> all_children,
-                                  const std::vector<size_t> &allowed_operators) {
-    DMG_ASSERT(_expression, "can't happen");
-    auto operators = ExtractOperators(all_children, allowed_operators);
-
-    Expression *expression = std::any_cast<Expression *>(_expression->accept(this));
-    for (int i = (int)operators.size() - 1; i >= 0; --i) {
-      expression = CreateUnaryOperatorByToken(operators[i], expression);
-    }
-    return expression;
-  }
-
-  /**
-   * @return CypherQuery*
-   */
-  antlrcpp::Any visitCypherQuery(MemgraphCypher::CypherQueryContext *ctx) override;
-
-  /**
-   * @return IndexQuery*
-   */
-  antlrcpp::Any visitIndexQuery(MemgraphCypher::IndexQueryContext *ctx) override;
-
-  /**
-   * @return ExplainQuery*
-   */
-  antlrcpp::Any visitExplainQuery(MemgraphCypher::ExplainQueryContext *ctx) override;
-
-  /**
-   * @return ProfileQuery*
-   */
-  antlrcpp::Any visitProfileQuery(MemgraphCypher::ProfileQueryContext *ctx) override;
-
-  /**
-   * @return InfoQuery*
-   */
-  antlrcpp::Any visitInfoQuery(MemgraphCypher::InfoQueryContext *ctx) override;
-
-  /**
-   * @return Constraint
-   */
-  antlrcpp::Any visitConstraint(MemgraphCypher::ConstraintContext *ctx) override;
-
-  /**
-   * @return ConstraintQuery*
-   */
-  antlrcpp::Any visitConstraintQuery(MemgraphCypher::ConstraintQueryContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitAuthQuery(MemgraphCypher::AuthQueryContext *ctx) override;
-
-  /**
-   * @return DumpQuery*
-   */
-  antlrcpp::Any visitDumpQuery(MemgraphCypher::DumpQueryContext *ctx) override;
-
-  /**
-   * @return ReplicationQuery*
-   */
-  antlrcpp::Any visitReplicationQuery(MemgraphCypher::ReplicationQueryContext *ctx) override;
-
-  /**
-   * @return ReplicationQuery*
-   */
-  antlrcpp::Any visitSetReplicationRole(MemgraphCypher::SetReplicationRoleContext *ctx) override;
-
-  /**
-   * @return ReplicationQuery*
-   */
-  antlrcpp::Any visitShowReplicationRole(MemgraphCypher::ShowReplicationRoleContext *ctx) override;
-
-  /**
-   * @return ReplicationQuery*
-   */
-  antlrcpp::Any visitRegisterReplica(MemgraphCypher::RegisterReplicaContext *ctx) override;
-
-  /**
-   * @return ReplicationQuery*
-   */
-  antlrcpp::Any visitDropReplica(MemgraphCypher::DropReplicaContext *ctx) override;
-
-  /**
-   * @return ReplicationQuery*
-   */
-  antlrcpp::Any visitShowReplicas(MemgraphCypher::ShowReplicasContext *ctx) override;
-
-  /**
-   * @return LockPathQuery*
-   */
-  antlrcpp::Any visitLockPathQuery(MemgraphCypher::LockPathQueryContext *ctx) override;
-
-  /**
-   * @return LoadCsvQuery*
-   */
-  antlrcpp::Any visitLoadCsv(MemgraphCypher::LoadCsvContext *ctx) override;
-
-  /**
-   * @return FreeMemoryQuery*
-   */
-  antlrcpp::Any visitFreeMemoryQuery(MemgraphCypher::FreeMemoryQueryContext *ctx) override;
-
-  /**
-   * @return TriggerQuery*
-   */
-  antlrcpp::Any visitTriggerQuery(MemgraphCypher::TriggerQueryContext *ctx) override;
-
-  /**
-   * @return CreateTrigger*
-   */
-  antlrcpp::Any visitCreateTrigger(MemgraphCypher::CreateTriggerContext *ctx) override;
-
-  /**
-   * @return DropTrigger*
-   */
-  antlrcpp::Any visitDropTrigger(MemgraphCypher::DropTriggerContext *ctx) override;
-
-  /**
-   * @return ShowTriggers*
-   */
-  antlrcpp::Any visitShowTriggers(MemgraphCypher::ShowTriggersContext *ctx) override;
-
-  /**
-   * @return IsolationLevelQuery*
-   */
-  antlrcpp::Any visitIsolationLevelQuery(MemgraphCypher::IsolationLevelQueryContext *ctx) override;
-
-  /**
-   * @return CreateSnapshotQuery*
-   */
-  antlrcpp::Any visitCreateSnapshotQuery(MemgraphCypher::CreateSnapshotQueryContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitStreamQuery(MemgraphCypher::StreamQueryContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitCreateStream(MemgraphCypher::CreateStreamContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitConfigKeyValuePair(MemgraphCypher::ConfigKeyValuePairContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitConfigMap(MemgraphCypher::ConfigMapContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitKafkaCreateStream(MemgraphCypher::KafkaCreateStreamContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitKafkaCreateStreamConfig(MemgraphCypher::KafkaCreateStreamConfigContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitPulsarCreateStreamConfig(MemgraphCypher::PulsarCreateStreamConfigContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitPulsarCreateStream(MemgraphCypher::PulsarCreateStreamContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitCommonCreateStreamConfig(MemgraphCypher::CommonCreateStreamConfigContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitDropStream(MemgraphCypher::DropStreamContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitStartStream(MemgraphCypher::StartStreamContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitStartAllStreams(MemgraphCypher::StartAllStreamsContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitStopStream(MemgraphCypher::StopStreamContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitStopAllStreams(MemgraphCypher::StopAllStreamsContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitShowStreams(MemgraphCypher::ShowStreamsContext *ctx) override;
-
-  /**
-   * @return StreamQuery*
-   */
-  antlrcpp::Any visitCheckStream(MemgraphCypher::CheckStreamContext *ctx) override;
-
-  /**
-   * @return SettingQuery*
-   */
-  antlrcpp::Any visitSettingQuery(MemgraphCypher::SettingQueryContext *ctx) override;
-
-  /**
-   * @return SetSetting*
-   */
-  antlrcpp::Any visitSetSetting(MemgraphCypher::SetSettingContext *ctx) override;
-
-  /**
-   * @return ShowSetting*
-   */
-  antlrcpp::Any visitShowSetting(MemgraphCypher::ShowSettingContext *ctx) override;
-
-  /**
-   * @return ShowSettings*
-   */
-  antlrcpp::Any visitShowSettings(MemgraphCypher::ShowSettingsContext *ctx) override;
-
-  /**
-   * @return VersionQuery*
-   */
-  antlrcpp::Any visitVersionQuery(MemgraphCypher::VersionQueryContext *ctx) override;
-
-  /**
-   * @return CypherUnion*
-   */
-  antlrcpp::Any visitCypherUnion(MemgraphCypher::CypherUnionContext *ctx) override;
-
-  /**
-   * @return SingleQuery*
-   */
-  antlrcpp::Any visitSingleQuery(MemgraphCypher::SingleQueryContext *ctx) override;
-
-  /**
-   * @return Clause* or vector<Clause*>!!!
-   */
-  antlrcpp::Any visitClause(MemgraphCypher::ClauseContext *ctx) override;
-
-  /**
-   * @return Match*
-   */
-  antlrcpp::Any visitCypherMatch(MemgraphCypher::CypherMatchContext *ctx) override;
-
-  /**
-   * @return Create*
-   */
-  antlrcpp::Any visitCreate(MemgraphCypher::CreateContext *ctx) override;
-
-  /**
-   * @return CallProcedure*
-   */
-  antlrcpp::Any visitCallProcedure(MemgraphCypher::CallProcedureContext *ctx) override;
-
-  /**
-   * @return std::string
-   */
-  antlrcpp::Any visitUserOrRoleName(MemgraphCypher::UserOrRoleNameContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitCreateRole(MemgraphCypher::CreateRoleContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitDropRole(MemgraphCypher::DropRoleContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitShowRoles(MemgraphCypher::ShowRolesContext *ctx) override;
-
-  /**
-   * @return IndexQuery*
-   */
-  antlrcpp::Any visitCreateIndex(MemgraphCypher::CreateIndexContext *ctx) override;
-
-  /**
-   * @return DropIndex*
-   */
-  antlrcpp::Any visitDropIndex(MemgraphCypher::DropIndexContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitCreateUser(MemgraphCypher::CreateUserContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitSetPassword(MemgraphCypher::SetPasswordContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitDropUser(MemgraphCypher::DropUserContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitShowUsers(MemgraphCypher::ShowUsersContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitSetRole(MemgraphCypher::SetRoleContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitClearRole(MemgraphCypher::ClearRoleContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitGrantPrivilege(MemgraphCypher::GrantPrivilegeContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitDenyPrivilege(MemgraphCypher::DenyPrivilegeContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitRevokePrivilege(MemgraphCypher::RevokePrivilegeContext *ctx) override;
-
-  /**
-   * @return AuthQuery::Privilege
-   */
-  antlrcpp::Any visitPrivilege(MemgraphCypher::PrivilegeContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitShowPrivileges(MemgraphCypher::ShowPrivilegesContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitShowRoleForUser(MemgraphCypher::ShowRoleForUserContext *ctx) override;
-
-  /**
-   * @return AuthQuery*
-   */
-  antlrcpp::Any visitShowUsersForRole(MemgraphCypher::ShowUsersForRoleContext *ctx) override;
-
-  /**
-   * @return Return*
-   */
-  antlrcpp::Any visitCypherReturn(MemgraphCypher::CypherReturnContext *ctx) override;
-
-  /**
-   * @return Return*
-   */
-  antlrcpp::Any visitReturnBody(MemgraphCypher::ReturnBodyContext *ctx) override;
-
-  /**
-   * @return pair<bool, vector<NamedExpression*>> first member is true if
-   * asterisk was found in return
-   * expressions.
-   */
-  antlrcpp::Any visitReturnItems(MemgraphCypher::ReturnItemsContext *ctx) override;
-
-  /**
-   * @return vector<NamedExpression*>
-   */
-  antlrcpp::Any visitReturnItem(MemgraphCypher::ReturnItemContext *ctx) override;
-
-  /**
-   * @return vector<SortItem>
-   */
-  antlrcpp::Any visitOrder(MemgraphCypher::OrderContext *ctx) override;
-
-  /**
-   * @return SortItem
-   */
-  antlrcpp::Any visitSortItem(MemgraphCypher::SortItemContext *ctx) override;
-
-  /**
-   * @return NodeAtom*
-   */
-  antlrcpp::Any visitNodePattern(MemgraphCypher::NodePatternContext *ctx) override;
-
-  /**
-   * @return vector<LabelIx>
-   */
-  antlrcpp::Any visitNodeLabels(MemgraphCypher::NodeLabelsContext *ctx) override;
-
-  /**
-   * @return unordered_map<PropertyIx, Expression*>
-   */
-  antlrcpp::Any visitProperties(MemgraphCypher::PropertiesContext *ctx) override;
-
-  /**
-   * @return map<std::string, Expression*>
-   */
-  antlrcpp::Any visitMapLiteral(MemgraphCypher::MapLiteralContext *ctx) override;
-
-  /**
-   * @return vector<Expression*>
-   */
-  antlrcpp::Any visitListLiteral(MemgraphCypher::ListLiteralContext *ctx) override;
-
-  /**
-   * @return PropertyIx
-   */
-  antlrcpp::Any visitPropertyKeyName(MemgraphCypher::PropertyKeyNameContext *ctx) override;
-
-  /**
-   * @return string
-   */
-  antlrcpp::Any visitSymbolicName(MemgraphCypher::SymbolicNameContext *ctx) override;
-
-  /**
-   * @return vector<Pattern*>
-   */
-  antlrcpp::Any visitPattern(MemgraphCypher::PatternContext *ctx) override;
-
-  /**
-   * @return Pattern*
-   */
-  antlrcpp::Any visitPatternPart(MemgraphCypher::PatternPartContext *ctx) override;
-
-  /**
-   * @return Pattern*
-   */
-  antlrcpp::Any visitPatternElement(MemgraphCypher::PatternElementContext *ctx) override;
-
-  /**
-   * @return vector<pair<EdgeAtom*, NodeAtom*>>
-   */
-  antlrcpp::Any visitPatternElementChain(MemgraphCypher::PatternElementChainContext *ctx) override;
-
-  /**
-   *@return EdgeAtom*
-   */
-  antlrcpp::Any visitRelationshipPattern(MemgraphCypher::RelationshipPatternContext *ctx) override;
-
-  /**
-   * This should never be called. Everything is done directly in
-   * visitRelationshipPattern.
-   */
-  antlrcpp::Any visitRelationshipDetail(MemgraphCypher::RelationshipDetailContext *ctx) override;
-
-  /**
-   * This should never be called. Everything is done directly in
-   * visitRelationshipPattern.
-   */
-  antlrcpp::Any visitRelationshipLambda(MemgraphCypher::RelationshipLambdaContext *ctx) override;
-
-  /**
-   * @return vector<EdgeTypeIx>
-   */
-  antlrcpp::Any visitRelationshipTypes(MemgraphCypher::RelationshipTypesContext *ctx) override;
-
-  /**
-   * @return std::tuple<EdgeAtom::Type, int64_t, int64_t>.
-   */
-  antlrcpp::Any visitVariableExpansion(MemgraphCypher::VariableExpansionContext *ctx) override;
-
-  /**
-   * Top level expression, does nothing.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression(MemgraphCypher::ExpressionContext *ctx) override;
-
-  /**
-   * OR.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression12(MemgraphCypher::Expression12Context *ctx) override;
-
-  /**
-   * XOR.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression11(MemgraphCypher::Expression11Context *ctx) override;
-
-  /**
-   * AND.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression10(MemgraphCypher::Expression10Context *ctx) override;
-
-  /**
-   * NOT.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression9(MemgraphCypher::Expression9Context *ctx) override;
-
-  /**
-   * Comparisons.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression8(MemgraphCypher::Expression8Context *ctx) override;
-
-  /**
-   * Never call this. Everything related to generating code for comparison
-   * operators should be done in visitExpression8.
-   */
-  antlrcpp::Any visitPartialComparisonExpression(MemgraphCypher::PartialComparisonExpressionContext *ctx) override;
-
-  /**
-   * Addition and subtraction.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression7(MemgraphCypher::Expression7Context *ctx) override;
-
-  /**
-   * Multiplication, division, modding.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression6(MemgraphCypher::Expression6Context *ctx) override;
-
-  /**
-   * Power.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression5(MemgraphCypher::Expression5Context *ctx) override;
-
-  /**
-   * Unary minus and plus.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression4(MemgraphCypher::Expression4Context *ctx) override;
-
-  /**
-   * IS NULL, IS NOT NULL, STARTS WITH, END WITH, =~, ...
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression3a(MemgraphCypher::Expression3aContext *ctx) override;
-
-  /**
-   * Does nothing, everything is done in visitExpression3a.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitStringAndNullOperators(MemgraphCypher::StringAndNullOperatorsContext *ctx) override;
-
-  /**
-   * List indexing and slicing.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression3b(MemgraphCypher::Expression3bContext *ctx) override;
-
-  /**
-   * Does nothing, everything is done in visitExpression3b.
-   */
-  antlrcpp::Any visitListIndexingOrSlicing(MemgraphCypher::ListIndexingOrSlicingContext *ctx) override;
-
-  /**
-   * Node labels test.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression2a(MemgraphCypher::Expression2aContext *ctx) override;
-
-  /**
-   * Property lookup.
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitExpression2b(MemgraphCypher::Expression2bContext *ctx) override;
-
-  /**
-   * Literals, params, list comprehension...
-   *
-   * @return Expression*
-   */
-  antlrcpp::Any visitAtom(MemgraphCypher::AtomContext *ctx) override;
-
-  /**
-   * @return ParameterLookup*
-   */
-  antlrcpp::Any visitParameter(MemgraphCypher::ParameterContext *ctx) override;
-
-  /**
-   * @return Expression*
-   */
-  antlrcpp::Any visitParenthesizedExpression(MemgraphCypher::ParenthesizedExpressionContext *ctx) override;
-
-  /**
-   * @return Expression*
-   */
-  antlrcpp::Any visitFunctionInvocation(MemgraphCypher::FunctionInvocationContext *ctx) override;
-
-  /**
-   * @return string - uppercased
-   */
-  antlrcpp::Any visitFunctionName(MemgraphCypher::FunctionNameContext *ctx) override;
-
-  /**
-   * @return Expression*
-   */
-  antlrcpp::Any visitLiteral(MemgraphCypher::LiteralContext *ctx) override;
-
-  /**
-   * Convert escaped string from a query to unescaped utf8 string.
-   *
-   * @return string
-   */
-  antlrcpp::Any visitStringLiteral(const std::string &escaped);
-
-  /**
-   * @return bool
-   */
-  antlrcpp::Any visitBooleanLiteral(MemgraphCypher::BooleanLiteralContext *ctx) override;
-
-  /**
-   * @return TypedValue with either double or int
-   */
-  antlrcpp::Any visitNumberLiteral(MemgraphCypher::NumberLiteralContext *ctx) override;
-
-  /**
-   * @return int64_t
-   */
-  antlrcpp::Any visitIntegerLiteral(MemgraphCypher::IntegerLiteralContext *ctx) override;
-
-  /**
-   * @return double
-   */
-  antlrcpp::Any visitDoubleLiteral(MemgraphCypher::DoubleLiteralContext *ctx) override;
-
-  /**
-   * @return Delete*
-   */
-  antlrcpp::Any visitCypherDelete(MemgraphCypher::CypherDeleteContext *ctx) override;
-
-  /**
-   * @return Where*
-   */
-  antlrcpp::Any visitWhere(MemgraphCypher::WhereContext *ctx) override;
-
-  /**
-   * return vector<Clause*>
-   */
-  antlrcpp::Any visitSet(MemgraphCypher::SetContext *ctx) override;
-
-  /**
-   * @return Clause*
-   */
-  antlrcpp::Any visitSetItem(MemgraphCypher::SetItemContext *ctx) override;
-
-  /**
-   * return vector<Clause*>
-   */
-  antlrcpp::Any visitRemove(MemgraphCypher::RemoveContext *ctx) override;
-
-  /**
-   * @return Clause*
-   */
-  antlrcpp::Any visitRemoveItem(MemgraphCypher::RemoveItemContext *ctx) override;
-
-  /**
-   * @return PropertyLookup*
-   */
-  antlrcpp::Any visitPropertyExpression(MemgraphCypher::PropertyExpressionContext *ctx) override;
-
-  /**
-   * @return IfOperator*
-   */
-  antlrcpp::Any visitCaseExpression(MemgraphCypher::CaseExpressionContext *ctx) override;
-
-  /**
-   * Never call this. Ast generation for this production is done in
-   * @c visitCaseExpression.
-   */
-  antlrcpp::Any visitCaseAlternatives(MemgraphCypher::CaseAlternativesContext *ctx) override;
-
-  /**
-   * @return With*
-   */
-  antlrcpp::Any visitWith(MemgraphCypher::WithContext *ctx) override;
-
-  /**
-   * @return Merge*
-   */
-  antlrcpp::Any visitMerge(MemgraphCypher::MergeContext *ctx) override;
-
-  /**
-   * @return Unwind*
-   */
-  antlrcpp::Any visitUnwind(MemgraphCypher::UnwindContext *ctx) override;
-
-  /**
-   * Never call this. Ast generation for these expressions should be done by
-   * explicitly visiting the members of @c FilterExpressionContext.
-   */
-  antlrcpp::Any visitFilterExpression(MemgraphCypher::FilterExpressionContext *) override;
-
-  /**
-   * @return Foreach*
-   */
-  antlrcpp::Any visitForeach(MemgraphCypher::ForeachContext *ctx) override;
-
-  /**
-   * @return Schema*
-   */
-  antlrcpp::Any visitPropertyType(MemgraphCypher::PropertyTypeContext *ctx) override;
-
-  /**
-   * @return Schema*
-   */
-  antlrcpp::Any visitSchemaPropertyMap(MemgraphCypher::SchemaPropertyMapContext *ctx) override;
-
-  /**
-   * @return Schema*
-   */
-  antlrcpp::Any visitSchemaQuery(MemgraphCypher::SchemaQueryContext *ctx) override;
-
-  /**
-   * @return Schema*
-   */
-  antlrcpp::Any visitShowSchema(MemgraphCypher::ShowSchemaContext *ctx) override;
-
-  /**
-   * @return Schema*
-   */
-  antlrcpp::Any visitShowSchemas(MemgraphCypher::ShowSchemasContext *ctx) override;
-
-  /**
-   * @return Schema*
-   */
-  antlrcpp::Any visitCreateSchema(MemgraphCypher::CreateSchemaContext *ctx) override;
-
-  /**
-   * @return Schema*
-   */
-  antlrcpp::Any visitDropSchema(MemgraphCypher::DropSchemaContext *ctx) override;
-
- public:
-  Query *query() { return query_; }
-  const static std::string kAnonPrefix;
-
-  struct QueryInfo {
-    bool is_cacheable{true};
-    bool has_load_csv{false};
-  };
-
-  const auto &GetQueryInfo() const { return query_info_; }
-
- private:
-  LabelIx AddLabel(const std::string &name);
-  PropertyIx AddProperty(const std::string &name);
-  EdgeTypeIx AddEdgeType(const std::string &name);
-
-  ParsingContext context_;
-  AstStorage *storage_;
-
-  std::unordered_map<uint8_t, std::variant<Expression *, std::string, std::vector<std::string>,
-                                           std::unordered_map<Expression *, Expression *>>>
-      memory_;
-  // Set of identifiers from queries.
-  std::unordered_set<std::string> users_identifiers;
-  // Identifiers that user didn't name.
-  std::vector<Identifier **> anonymous_identifiers;
-  Query *query_ = nullptr;
-  // All return items which are not variables must be aliased in with.
-  // We use this variable in visitReturnItem to check if we are in with or
-  // return.
-  bool in_with_ = false;
-
-  QueryInfo query_info_;
-};
-}  // namespace memgraph::query::v2::frontend

src/query/v2/frontend/ast/pretty_print.cpp

@@ -1,311 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "query/v2/frontend/ast/pretty_print.hpp"
-
-#include <type_traits>
-
-#include "query/v2/frontend/ast/ast.hpp"
-#include "utils/algorithm.hpp"
-#include "utils/string.hpp"
-
-namespace memgraph::query::v2 {
-
-namespace {
-
-class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
- public:
-  explicit ExpressionPrettyPrinter(std::ostream *out);
-
-  // Unary operators
-  void Visit(NotOperator &op) override;
-  void Visit(UnaryPlusOperator &op) override;
-  void Visit(UnaryMinusOperator &op) override;
-  void Visit(IsNullOperator &op) override;
-
-  // Binary operators
-  void Visit(OrOperator &op) override;
-  void Visit(XorOperator &op) override;
-  void Visit(AndOperator &op) override;
-  void Visit(AdditionOperator &op) override;
-  void Visit(SubtractionOperator &op) override;
-  void Visit(MultiplicationOperator &op) override;
-  void Visit(DivisionOperator &op) override;
-  void Visit(ModOperator &op) override;
-  void Visit(NotEqualOperator &op) override;
-  void Visit(EqualOperator &op) override;
-  void Visit(LessOperator &op) override;
-  void Visit(GreaterOperator &op) override;
-  void Visit(LessEqualOperator &op) override;
-  void Visit(GreaterEqualOperator &op) override;
-  void Visit(InListOperator &op) override;
-  void Visit(SubscriptOperator &op) override;
-
-  // Other
-  void Visit(ListSlicingOperator &op) override;
-  void Visit(IfOperator &op) override;
-  void Visit(ListLiteral &op) override;
-  void Visit(MapLiteral &op) override;
-  void Visit(LabelsTest &op) override;
-  void Visit(Aggregation &op) override;
-  void Visit(Function &op) override;
-  void Visit(Reduce &op) override;
-  void Visit(Coalesce &op) override;
-  void Visit(Extract &op) override;
-  void Visit(All &op) override;
-  void Visit(Single &op) override;
-  void Visit(Any &op) override;
-  void Visit(None &op) override;
-  void Visit(Identifier &op) override;
-  void Visit(PrimitiveLiteral &op) override;
-  void Visit(PropertyLookup &op) override;
-  void Visit(ParameterLookup &op) override;
-  void Visit(NamedExpression &op) override;
-  void Visit(RegexMatch &op) override;
-
- private:
-  std::ostream *out_;
-};
-
-// Declare all of the different `PrintObject` overloads upfront since they're
-// mutually recursive. Without this, overload resolution depends on the ordering
-// of the overloads within the source, which is quite fragile.
-
-template <typename T>
-void PrintObject(std::ostream *out, const T &arg);
-
-void PrintObject(std::ostream *out, const std::string &str);
-
-void PrintObject(std::ostream *out, Aggregation::Op op);
-
-void PrintObject(std::ostream *out, Expression *expr);
-
-void PrintObject(std::ostream *out, Identifier *expr);
-
-void PrintObject(std::ostream *out, const storage::v3::PropertyValue &value);
-
-template <typename T>
-void PrintObject(std::ostream *out, const std::vector<T> &vec);
-
-template <typename K, typename V>
-void PrintObject(std::ostream *out, const std::map<K, V> &map);
-
-template <typename T>
-void PrintObject(std::ostream *out, const T &arg) {
-  static_assert(!std::is_convertible<T, Expression *>::value,
-                "This overload shouldn't be called with pointers convertible "
-                "to Expression *. This means your other PrintObject overloads aren't "
-                "being called for certain AST nodes when they should (or perhaps such "
-                "overloads don't exist yet).");
-  *out << arg;
-}
-
-void PrintObject(std::ostream *out, const std::string &str) { *out << utils::Escape(str); }
-
-void PrintObject(std::ostream *out, Aggregation::Op op) { *out << Aggregation::OpToString(op); }
-
-void PrintObject(std::ostream *out, Expression *expr) {
-  if (expr) {
-    ExpressionPrettyPrinter printer{out};
-    expr->Accept(printer);
-  } else {
-    *out << "<null>";
-  }
-}
-
-void PrintObject(std::ostream *out, Identifier *expr) { PrintObject(out, static_cast<Expression *>(expr)); }
-
-void PrintObject(std::ostream *out, const storage::v3::PropertyValue &value) {
-  switch (value.type()) {
-    case storage::v3::PropertyValue::Type::Null:
-      *out << "null";
-      break;
-
-    case storage::v3::PropertyValue::Type::String:
-      PrintObject(out, value.ValueString());
-      break;
-
-    case storage::v3::PropertyValue::Type::Bool:
-      *out << (value.ValueBool() ? "true" : "false");
-      break;
-
-    case storage::v3::PropertyValue::Type::Int:
-      PrintObject(out, value.ValueInt());
-      break;
-
-    case storage::v3::PropertyValue::Type::Double:
-      PrintObject(out, value.ValueDouble());
-      break;
-
-    case storage::v3::PropertyValue::Type::List:
-      PrintObject(out, value.ValueList());
-      break;
-
-    case storage::v3::PropertyValue::Type::Map:
-      PrintObject(out, value.ValueMap());
-      break;
-    case storage::v3::PropertyValue::Type::TemporalData:
-      PrintObject(out, value.ValueTemporalData());
-      break;
-  }
-}
-
-template <typename T>
-void PrintObject(std::ostream *out, const std::vector<T> &vec) {
-  *out << "[";
-  utils::PrintIterable(*out, vec, ", ", [](auto &stream, const auto &item) { PrintObject(&stream, item); });
-  *out << "]";
-}
-
-template <typename K, typename V>
-void PrintObject(std::ostream *out, const std::map<K, V> &map) {
-  *out << "{";
-  utils::PrintIterable(*out, map, ", ", [](auto &stream, const auto &item) {
-    PrintObject(&stream, item.first);
-    stream << ": ";
-    PrintObject(&stream, item.second);
-  });
-  *out << "}";
-}
-
-template <typename T>
-void PrintOperatorArgs(std::ostream *out, const T &arg) {
-  *out << " ";
-  PrintObject(out, arg);
-  *out << ")";
-}
-
-template <typename T, typename... Ts>
-void PrintOperatorArgs(std::ostream *out, const T &arg, const Ts &...args) {
-  *out << " ";
-  PrintObject(out, arg);
-  PrintOperatorArgs(out, args...);
-}
-
-template <typename... Ts>
-void PrintOperator(std::ostream *out, const std::string &name, const Ts &...args) {
-  *out << "(" << name;
-  PrintOperatorArgs(out, args...);
-}
-
-ExpressionPrettyPrinter::ExpressionPrettyPrinter(std::ostream *out) : out_(out) {}
-
-#define UNARY_OPERATOR_VISIT(OP_NODE, OP_STR) \
-  void ExpressionPrettyPrinter::Visit(OP_NODE &op) { PrintOperator(out_, OP_STR, op.expression_); }
-
-UNARY_OPERATOR_VISIT(NotOperator, "Not");
-UNARY_OPERATOR_VISIT(UnaryPlusOperator, "+");
-UNARY_OPERATOR_VISIT(UnaryMinusOperator, "-");
-UNARY_OPERATOR_VISIT(IsNullOperator, "IsNull");
-
-#undef UNARY_OPERATOR_VISIT
-
-#define BINARY_OPERATOR_VISIT(OP_NODE, OP_STR) \
-  void ExpressionPrettyPrinter::Visit(OP_NODE &op) { PrintOperator(out_, OP_STR, op.expression1_, op.expression2_); }
-
-BINARY_OPERATOR_VISIT(OrOperator, "Or");
-BINARY_OPERATOR_VISIT(XorOperator, "Xor");
-BINARY_OPERATOR_VISIT(AndOperator, "And");
-BINARY_OPERATOR_VISIT(AdditionOperator, "+");
-BINARY_OPERATOR_VISIT(SubtractionOperator, "-");
-BINARY_OPERATOR_VISIT(MultiplicationOperator, "*");
-BINARY_OPERATOR_VISIT(DivisionOperator, "/");
-BINARY_OPERATOR_VISIT(ModOperator, "%");
-BINARY_OPERATOR_VISIT(NotEqualOperator, "!=");
-BINARY_OPERATOR_VISIT(EqualOperator, "==");
-BINARY_OPERATOR_VISIT(LessOperator, "<");
-BINARY_OPERATOR_VISIT(GreaterOperator, ">");
-BINARY_OPERATOR_VISIT(LessEqualOperator, "<=");
-BINARY_OPERATOR_VISIT(GreaterEqualOperator, ">=");
-BINARY_OPERATOR_VISIT(InListOperator, "In");
-BINARY_OPERATOR_VISIT(SubscriptOperator, "Subscript");
-
-#undef BINARY_OPERATOR_VISIT
-
-void ExpressionPrettyPrinter::Visit(ListSlicingOperator &op) {
-  PrintOperator(out_, "ListSlicing", op.list_, op.lower_bound_, op.upper_bound_);
-}
-
-void ExpressionPrettyPrinter::Visit(IfOperator &op) {
-  PrintOperator(out_, "If", op.condition_, op.then_expression_, op.else_expression_);
-}
-
-void ExpressionPrettyPrinter::Visit(ListLiteral &op) { PrintOperator(out_, "ListLiteral", op.elements_); }
-
-void ExpressionPrettyPrinter::Visit(MapLiteral &op) {
-  std::map<std::string, Expression *> map;
-  for (const auto &kv : op.elements_) {
-    map[kv.first.name] = kv.second;
-  }
-  PrintObject(out_, map);
-}
-
-void ExpressionPrettyPrinter::Visit(LabelsTest &op) { PrintOperator(out_, "LabelsTest", op.expression_); }
-
-void ExpressionPrettyPrinter::Visit(Aggregation &op) { PrintOperator(out_, "Aggregation", op.op_); }
-
-void ExpressionPrettyPrinter::Visit(Function &op) { PrintOperator(out_, "Function", op.function_name_, op.arguments_); }
-
-void ExpressionPrettyPrinter::Visit(Reduce &op) {
-  PrintOperator(out_, "Reduce", op.accumulator_, op.initializer_, op.identifier_, op.list_, op.expression_);
-}
-
-void ExpressionPrettyPrinter::Visit(Coalesce &op) { PrintOperator(out_, "Coalesce", op.expressions_); }
-
-void ExpressionPrettyPrinter::Visit(Extract &op) {
-  PrintOperator(out_, "Extract", op.identifier_, op.list_, op.expression_);
-}
-
-void ExpressionPrettyPrinter::Visit(All &op) {
-  PrintOperator(out_, "All", op.identifier_, op.list_expression_, op.where_->expression_);
-}
-
-void ExpressionPrettyPrinter::Visit(Single &op) {
-  PrintOperator(out_, "Single", op.identifier_, op.list_expression_, op.where_->expression_);
-}
-
-void ExpressionPrettyPrinter::Visit(Any &op) {
-  PrintOperator(out_, "Any", op.identifier_, op.list_expression_, op.where_->expression_);
-}
-
-void ExpressionPrettyPrinter::Visit(None &op) {
-  PrintOperator(out_, "None", op.identifier_, op.list_expression_, op.where_->expression_);
-}
-
-void ExpressionPrettyPrinter::Visit(Identifier &op) { PrintOperator(out_, "Identifier", op.name_); }
-
-void ExpressionPrettyPrinter::Visit(PrimitiveLiteral &op) { PrintObject(out_, op.value_); }
-
-void ExpressionPrettyPrinter::Visit(PropertyLookup &op) {
-  PrintOperator(out_, "PropertyLookup", op.expression_, op.property_.name);
-}
-
-void ExpressionPrettyPrinter::Visit(ParameterLookup &op) { PrintOperator(out_, "ParameterLookup", op.token_position_); }
-
-void ExpressionPrettyPrinter::Visit(NamedExpression &op) {
-  PrintOperator(out_, "NamedExpression", op.name_, op.expression_);
-}
-
-void ExpressionPrettyPrinter::Visit(RegexMatch &op) { PrintOperator(out_, "=~", op.string_expr_, op.regex_); }
-
-}  // namespace
-
-void PrintExpression(Expression *expr, std::ostream *out) {
-  ExpressionPrettyPrinter printer{out};
-  expr->Accept(printer);
-}
-
-void PrintExpression(NamedExpression *expr, std::ostream *out) {
-  ExpressionPrettyPrinter printer{out};
-  expr->Accept(printer);
-}
-
-}  // namespace memgraph::query::v2

src/query/v2/frontend/semantic/required_privileges.cpp

@@ -9,8 +9,8 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
+#include "query/v2/bindings/ast_visitor.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/ast/ast_visitor.hpp"
 #include "query/v2/procedure/module.hpp"
 #include "utils/memory.hpp"
 

src/query/v2/frontend/semantic/symbol_generator.cpp

@@ -1,625 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-// Copyright 2017 Memgraph
-//
-// Created by Teon Banek on 24-03-2017
-
-#include "query/v2/frontend/semantic/symbol_generator.hpp"
-
-#include <algorithm>
-#include <optional>
-#include <ranges>
-#include <unordered_set>
-#include <variant>
-
-#include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/ast/ast_visitor.hpp"
-#include "utils/algorithm.hpp"
-#include "utils/logging.hpp"
-
-namespace memgraph::query::v2 {
-
-namespace {
-std::unordered_map<std::string, Identifier *> GeneratePredefinedIdentifierMap(
-    const std::vector<Identifier *> &predefined_identifiers) {
-  std::unordered_map<std::string, Identifier *> identifier_map;
-  for (const auto &identifier : predefined_identifiers) {
-    identifier_map.emplace(identifier->name_, identifier);
-  }
-
-  return identifier_map;
-}
-}  // namespace
-
-SymbolGenerator::SymbolGenerator(SymbolTable *symbol_table, const std::vector<Identifier *> &predefined_identifiers)
-    : symbol_table_(symbol_table),
-      predefined_identifiers_{GeneratePredefinedIdentifierMap(predefined_identifiers)},
-      scopes_(1, Scope()) {}
-
-std::optional<Symbol> SymbolGenerator::FindSymbolInScope(const std::string &name, const Scope &scope,
-                                                         Symbol::Type type) {
-  if (auto it = scope.symbols.find(name); it != scope.symbols.end()) {
-    const auto &symbol = it->second;
-    // Unless we have `ANY` type, check that types match.
-    if (type != Symbol::Type::ANY && symbol.type() != Symbol::Type::ANY && type != symbol.type()) {
-      throw TypeMismatchError(name, Symbol::TypeToString(symbol.type()), Symbol::TypeToString(type));
-    }
-    return symbol;
-  }
-  return std::nullopt;
-}
-
-auto SymbolGenerator::CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type, int token_position) {
-  auto symbol = symbol_table_->CreateSymbol(name, user_declared, type, token_position);
-  scopes_.back().symbols[name] = symbol;
-  return symbol;
-}
-
-auto SymbolGenerator::GetOrCreateSymbolLocalScope(const std::string &name, bool user_declared, Symbol::Type type) {
-  auto &scope = scopes_.back();
-  if (auto maybe_symbol = FindSymbolInScope(name, scope, type); maybe_symbol) {
-    return *maybe_symbol;
-  }
-  return CreateSymbol(name, user_declared, type);
-}
-
-auto SymbolGenerator::GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type) {
-  // NOLINTNEXTLINE
-  for (auto scope = scopes_.rbegin(); scope != scopes_.rend(); ++scope) {
-    if (auto maybe_symbol = FindSymbolInScope(name, *scope, type); maybe_symbol) {
-      return *maybe_symbol;
-    }
-  }
-  return CreateSymbol(name, user_declared, type);
-}
-
-void SymbolGenerator::VisitReturnBody(ReturnBody &body, Where *where) {
-  auto &scope = scopes_.back();
-  for (auto &expr : body.named_expressions) {
-    expr->Accept(*this);
-  }
-  std::vector<Symbol> user_symbols;
-  if (body.all_identifiers) {
-    // Carry over user symbols because '*' appeared.
-    for (const auto &sym_pair : scope.symbols) {
-      if (!sym_pair.second.user_declared()) {
-        continue;
-      }
-      user_symbols.emplace_back(sym_pair.second);
-    }
-    if (user_symbols.empty()) {
-      throw SemanticException("There are no variables in scope to use for '*'.");
-    }
-  }
-  // WITH/RETURN clause removes declarations of all the previous variables and
-  // declares only those established through named expressions. New declarations
-  // must not be visible inside named expressions themselves.
-  bool removed_old_names = false;
-  if ((!where && body.order_by.empty()) || scope.has_aggregation) {
-    // WHERE and ORDER BY need to see both the old and new symbols, unless we
-    // have an aggregation. Therefore, we can clear the symbols immediately if
-    // there is neither ORDER BY nor WHERE, or we have an aggregation.
-    scope.symbols.clear();
-    removed_old_names = true;
-  }
-  // Create symbols for named expressions.
-  std::unordered_set<std::string> new_names;
-  for (const auto &user_sym : user_symbols) {
-    new_names.insert(user_sym.name());
-    scope.symbols[user_sym.name()] = user_sym;
-  }
-  for (auto &named_expr : body.named_expressions) {
-    const auto &name = named_expr->name_;
-    if (!new_names.insert(name).second) {
-      throw SemanticException("Multiple results with the same name '{}' are not allowed.", name);
-    }
-    // An improvement would be to infer the type of the expression, so that the
-    // new symbol would have a more specific type.
-    named_expr->MapTo(CreateSymbol(name, true, Symbol::Type::ANY, named_expr->token_position_));
-  }
-  scope.in_order_by = true;
-  for (const auto &order_pair : body.order_by) {
-    order_pair.expression->Accept(*this);
-  }
-  scope.in_order_by = false;
-  if (body.skip) {
-    scope.in_skip = true;
-    body.skip->Accept(*this);
-    scope.in_skip = false;
-  }
-  if (body.limit) {
-    scope.in_limit = true;
-    body.limit->Accept(*this);
-    scope.in_limit = false;
-  }
-  if (where) where->Accept(*this);
-  if (!removed_old_names) {
-    // We have an ORDER BY or WHERE, but no aggregation, which means we didn't
-    // clear the old symbols, so do it now. We cannot just call clear, because
-    // we've added new symbols.
-    for (auto sym_it = scope.symbols.begin(); sym_it != scope.symbols.end();) {
-      if (new_names.find(sym_it->first) == new_names.end()) {
-        sym_it = scope.symbols.erase(sym_it);
-      } else {
-        sym_it++;
-      }
-    }
-  }
-  scopes_.back().has_aggregation = false;
-}
-
-// Query
-
-bool SymbolGenerator::PreVisit(SingleQuery &) {
-  prev_return_names_ = curr_return_names_;
-  curr_return_names_.clear();
-  return true;
-}
-
-// Union
-
-bool SymbolGenerator::PreVisit(CypherUnion &) {
-  scopes_.back() = Scope();
-  return true;
-}
-
-bool SymbolGenerator::PostVisit(CypherUnion &cypher_union) {
-  if (prev_return_names_ != curr_return_names_) {
-    throw SemanticException("All subqueries in an UNION must have the same column names.");
-  }
-
-  // create new symbols for the result of the union
-  for (const auto &name : curr_return_names_) {
-    auto symbol = CreateSymbol(name, false);
-    cypher_union.union_symbols_.push_back(symbol);
-  }
-
-  return true;
-}
-
-// Clauses
-
-bool SymbolGenerator::PreVisit(Create &) {
-  scopes_.back().in_create = true;
-  return true;
-}
-bool SymbolGenerator::PostVisit(Create &) {
-  scopes_.back().in_create = false;
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(CallProcedure &call_proc) {
-  for (auto *expr : call_proc.arguments_) {
-    expr->Accept(*this);
-  }
-  return false;
-}
-
-bool SymbolGenerator::PostVisit(CallProcedure &call_proc) {
-  for (auto *ident : call_proc.result_identifiers_) {
-    if (HasSymbolLocalScope(ident->name_)) {
-      throw RedeclareVariableError(ident->name_);
-    }
-    ident->MapTo(CreateSymbol(ident->name_, true));
-  }
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(LoadCsv &load_csv) { return false; }
-
-bool SymbolGenerator::PostVisit(LoadCsv &load_csv) {
-  if (HasSymbolLocalScope(load_csv.row_var_->name_)) {
-    throw RedeclareVariableError(load_csv.row_var_->name_);
-  }
-  load_csv.row_var_->MapTo(CreateSymbol(load_csv.row_var_->name_, true));
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(Return &ret) {
-  auto &scope = scopes_.back();
-  scope.in_return = true;
-  VisitReturnBody(ret.body_);
-  scope.in_return = false;
-  return false;  // We handled the traversal ourselves.
-}
-
-bool SymbolGenerator::PostVisit(Return &) {
-  for (const auto &name_symbol : scopes_.back().symbols) curr_return_names_.insert(name_symbol.first);
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(With &with) {
-  auto &scope = scopes_.back();
-  scope.in_with = true;
-  VisitReturnBody(with.body_, with.where_);
-  scope.in_with = false;
-  return false;  // We handled the traversal ourselves.
-}
-
-bool SymbolGenerator::PreVisit(Where &) {
-  scopes_.back().in_where = true;
-  return true;
-}
-bool SymbolGenerator::PostVisit(Where &) {
-  scopes_.back().in_where = false;
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(Merge &) {
-  scopes_.back().in_merge = true;
-  return true;
-}
-bool SymbolGenerator::PostVisit(Merge &) {
-  scopes_.back().in_merge = false;
-  return true;
-}
-
-bool SymbolGenerator::PostVisit(Unwind &unwind) {
-  const auto &name = unwind.named_expression_->name_;
-  if (HasSymbolLocalScope(name)) {
-    throw RedeclareVariableError(name);
-  }
-  unwind.named_expression_->MapTo(CreateSymbol(name, true));
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(Match &) {
-  scopes_.back().in_match = true;
-  return true;
-}
-bool SymbolGenerator::PostVisit(Match &) {
-  auto &scope = scopes_.back();
-  scope.in_match = false;
-  // Check variables in property maps after visiting Match, so that they can
-  // reference symbols out of bind order.
-  for (auto &ident : scope.identifiers_in_match) {
-    if (!HasSymbolLocalScope(ident->name_) && !ConsumePredefinedIdentifier(ident->name_))
-      throw UnboundVariableError(ident->name_);
-    ident->MapTo(scope.symbols[ident->name_]);
-  }
-  scope.identifiers_in_match.clear();
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(Foreach &for_each) {
-  const auto &name = for_each.named_expression_->name_;
-  scopes_.emplace_back(Scope());
-  scopes_.back().in_foreach = true;
-  for_each.named_expression_->MapTo(
-      CreateSymbol(name, true, Symbol::Type::ANY, for_each.named_expression_->token_position_));
-  return true;
-}
-bool SymbolGenerator::PostVisit([[maybe_unused]] Foreach &for_each) {
-  scopes_.pop_back();
-  return true;
-}
-
-// Expressions
-
-SymbolGenerator::ReturnType SymbolGenerator::Visit(Identifier &ident) {
-  auto &scope = scopes_.back();
-  if (scope.in_skip || scope.in_limit) {
-    throw SemanticException("Variables are not allowed in {}.", scope.in_skip ? "SKIP" : "LIMIT");
-  }
-  Symbol symbol;
-  if (scope.in_pattern && !(scope.in_node_atom || scope.visiting_edge)) {
-    // If we are in the pattern, and outside of a node or an edge, the
-    // identifier is the pattern name.
-    symbol = GetOrCreateSymbolLocalScope(ident.name_, ident.user_declared_, Symbol::Type::PATH);
-  } else if (scope.in_pattern && scope.in_pattern_atom_identifier) {
-    //  Patterns used to create nodes and edges cannot redeclare already
-    //  established bindings. Declaration only happens in single node
-    //  patterns and in edge patterns. OpenCypher example,
-    //  `MATCH (n) CREATE (n)` should throw an error that `n` is already
-    //  declared. While `MATCH (n) CREATE (n) -[:R]-> (n)` is allowed,
-    //  since `n` now references the bound node instead of declaring it.
-    if ((scope.in_create_node || scope.in_create_edge) && HasSymbolLocalScope(ident.name_)) {
-      throw RedeclareVariableError(ident.name_);
-    }
-    auto type = Symbol::Type::VERTEX;
-    if (scope.visiting_edge) {
-      // Edge referencing is not allowed (like in Neo4j):
-      // `MATCH (n) - [r] -> (n) - [r] -> (n) RETURN r` is not allowed.
-      if (HasSymbolLocalScope(ident.name_)) {
-        throw RedeclareVariableError(ident.name_);
-      }
-      type = scope.visiting_edge->IsVariable() ? Symbol::Type::EDGE_LIST : Symbol::Type::EDGE;
-    }
-    symbol = GetOrCreateSymbolLocalScope(ident.name_, ident.user_declared_, type);
-  } else if (scope.in_pattern && !scope.in_pattern_atom_identifier && scope.in_match) {
-    if (scope.in_edge_range && scope.visiting_edge->identifier_->name_ == ident.name_) {
-      // Prevent variable path bounds to reference the identifier which is bound
-      // by the variable path itself.
-      throw UnboundVariableError(ident.name_);
-    }
-    // Variables in property maps or bounds of variable length path during MATCH
-    // can reference symbols bound later in the same MATCH. We collect them
-    // here, so that they can be checked after visiting Match.
-    scope.identifiers_in_match.emplace_back(&ident);
-  } else {
-    // Everything else references a bound symbol.
-    if (!HasSymbol(ident.name_) && !ConsumePredefinedIdentifier(ident.name_)) throw UnboundVariableError(ident.name_);
-    symbol = GetOrCreateSymbol(ident.name_, ident.user_declared_, Symbol::Type::ANY);
-  }
-  ident.MapTo(symbol);
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(Aggregation &aggr) {
-  auto &scope = scopes_.back();
-  // Check if the aggregation can be used in this context. This check should
-  // probably move to a separate phase, which checks if the query is well
-  // formed.
-  if ((!scope.in_return && !scope.in_with) || scope.in_order_by || scope.in_skip || scope.in_limit || scope.in_where) {
-    throw SemanticException("Aggregation functions are only allowed in WITH and RETURN.");
-  }
-  if (scope.in_aggregation) {
-    throw SemanticException(
-        "Using aggregation functions inside aggregation functions is not "
-        "allowed.");
-  }
-  if (scope.num_if_operators) {
-    // Neo allows aggregations here and produces very interesting behaviors.
-    // To simplify implementation at this moment we decided to completely
-    // disallow aggregations inside of the CASE.
-    // However, in some cases aggregation makes perfect sense, for example:
-    //    CASE count(n) WHEN 10 THEN "YES" ELSE "NO" END.
-    // TODO: Rethink of allowing aggregations in some parts of the CASE
-    // construct.
-    throw SemanticException("Using aggregation functions inside of CASE is not allowed.");
-  }
-  // Create a virtual symbol for aggregation result.
-  // Currently, we only have aggregation operators which return numbers.
-  auto aggr_name = Aggregation::OpToString(aggr.op_) + std::to_string(aggr.symbol_pos_);
-  aggr.MapTo(CreateSymbol(aggr_name, false, Symbol::Type::NUMBER));
-  scope.in_aggregation = true;
-  scope.has_aggregation = true;
-  return true;
-}
-
-bool SymbolGenerator::PostVisit(Aggregation &) {
-  scopes_.back().in_aggregation = false;
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(IfOperator &) {
-  ++scopes_.back().num_if_operators;
-  return true;
-}
-
-bool SymbolGenerator::PostVisit(IfOperator &) {
-  --scopes_.back().num_if_operators;
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(All &all) {
-  all.list_expression_->Accept(*this);
-  VisitWithIdentifiers(all.where_->expression_, {all.identifier_});
-  return false;
-}
-
-bool SymbolGenerator::PreVisit(Single &single) {
-  single.list_expression_->Accept(*this);
-  VisitWithIdentifiers(single.where_->expression_, {single.identifier_});
-  return false;
-}
-
-bool SymbolGenerator::PreVisit(Any &any) {
-  any.list_expression_->Accept(*this);
-  VisitWithIdentifiers(any.where_->expression_, {any.identifier_});
-  return false;
-}
-
-bool SymbolGenerator::PreVisit(None &none) {
-  none.list_expression_->Accept(*this);
-  VisitWithIdentifiers(none.where_->expression_, {none.identifier_});
-  return false;
-}
-
-bool SymbolGenerator::PreVisit(Reduce &reduce) {
-  reduce.initializer_->Accept(*this);
-  reduce.list_->Accept(*this);
-  VisitWithIdentifiers(reduce.expression_, {reduce.accumulator_, reduce.identifier_});
-  return false;
-}
-
-bool SymbolGenerator::PreVisit(Extract &extract) {
-  extract.list_->Accept(*this);
-  VisitWithIdentifiers(extract.expression_, {extract.identifier_});
-  return false;
-}
-
-// Pattern and its subparts.
-
-bool SymbolGenerator::PreVisit(Pattern &pattern) {
-  auto &scope = scopes_.back();
-  scope.in_pattern = true;
-  if ((scope.in_create || scope.in_merge) && pattern.atoms_.size() == 1U) {
-    MG_ASSERT(utils::IsSubtype(*pattern.atoms_[0], NodeAtom::kType), "Expected a single NodeAtom in Pattern");
-    scope.in_create_node = true;
-  }
-  return true;
-}
-
-bool SymbolGenerator::PostVisit(Pattern &) {
-  auto &scope = scopes_.back();
-  scope.in_pattern = false;
-  scope.in_create_node = false;
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(NodeAtom &node_atom) {
-  auto &scope = scopes_.back();
-  auto check_node_semantic = [&node_atom, &scope, this](const bool props_or_labels) {
-    const auto &node_name = node_atom.identifier_->name_;
-    if ((scope.in_create || scope.in_merge) && props_or_labels && HasSymbolLocalScope(node_name)) {
-      throw SemanticException("Cannot create node '" + node_name +
-                              "' with labels or properties, because it is already declared.");
-    }
-    scope.in_pattern_atom_identifier = true;
-    node_atom.identifier_->Accept(*this);
-    scope.in_pattern_atom_identifier = false;
-  };
-
-  scope.in_node_atom = true;
-  if (auto *properties = std::get_if<std::unordered_map<PropertyIx, Expression *>>(&node_atom.properties_)) {
-    bool props_or_labels = !properties->empty() || !node_atom.labels_.empty();
-
-    check_node_semantic(props_or_labels);
-    for (auto kv : *properties) {
-      kv.second->Accept(*this);
-    }
-
-    return false;
-  }
-  auto &properties_parameter = std::get<ParameterLookup *>(node_atom.properties_);
-  bool props_or_labels = !properties_parameter || !node_atom.labels_.empty();
-
-  check_node_semantic(props_or_labels);
-  properties_parameter->Accept(*this);
-  return false;
-}
-
-bool SymbolGenerator::PostVisit(NodeAtom &) {
-  scopes_.back().in_node_atom = false;
-  return true;
-}
-
-bool SymbolGenerator::PreVisit(EdgeAtom &edge_atom) {
-  auto &scope = scopes_.back();
-  scope.visiting_edge = &edge_atom;
-  if (scope.in_create || scope.in_merge) {
-    scope.in_create_edge = true;
-    if (edge_atom.edge_types_.size() != 1U) {
-      throw SemanticException(
-          "A single relationship type must be specified "
-          "when creating an edge.");
-    }
-    if (scope.in_create &&  // Merge allows bidirectionality
-        edge_atom.direction_ == EdgeAtom::Direction::BOTH) {
-      throw SemanticException(
-          "Bidirectional relationship are not supported "
-          "when creating an edge");
-    }
-    if (edge_atom.IsVariable()) {
-      throw SemanticException(
-          "Variable length relationships are not supported when creating an "
-          "edge.");
-    }
-  }
-  if (auto *properties = std::get_if<std::unordered_map<PropertyIx, Expression *>>(&edge_atom.properties_)) {
-    for (auto kv : *properties) {
-      kv.second->Accept(*this);
-    }
-  } else {
-    std::get<ParameterLookup *>(edge_atom.properties_)->Accept(*this);
-  }
-  if (edge_atom.IsVariable()) {
-    scope.in_edge_range = true;
-    if (edge_atom.lower_bound_) {
-      edge_atom.lower_bound_->Accept(*this);
-    }
-    if (edge_atom.upper_bound_) {
-      edge_atom.upper_bound_->Accept(*this);
-    }
-    scope.in_edge_range = false;
-    scope.in_pattern = false;
-    if (edge_atom.filter_lambda_.expression) {
-      VisitWithIdentifiers(edge_atom.filter_lambda_.expression,
-                           {edge_atom.filter_lambda_.inner_edge, edge_atom.filter_lambda_.inner_node});
-    } else {
-      // Create inner symbols, but don't bind them in scope, since they are to
-      // be used in the missing filter expression.
-      auto *inner_edge = edge_atom.filter_lambda_.inner_edge;
-      inner_edge->MapTo(symbol_table_->CreateSymbol(inner_edge->name_, inner_edge->user_declared_, Symbol::Type::EDGE));
-      auto *inner_node = edge_atom.filter_lambda_.inner_node;
-      inner_node->MapTo(
-          symbol_table_->CreateSymbol(inner_node->name_, inner_node->user_declared_, Symbol::Type::VERTEX));
-    }
-    if (edge_atom.weight_lambda_.expression) {
-      VisitWithIdentifiers(edge_atom.weight_lambda_.expression,
-                           {edge_atom.weight_lambda_.inner_edge, edge_atom.weight_lambda_.inner_node});
-    }
-    scope.in_pattern = true;
-  }
-  scope.in_pattern_atom_identifier = true;
-  edge_atom.identifier_->Accept(*this);
-  scope.in_pattern_atom_identifier = false;
-  if (edge_atom.total_weight_) {
-    if (HasSymbolLocalScope(edge_atom.total_weight_->name_)) {
-      throw RedeclareVariableError(edge_atom.total_weight_->name_);
-    }
-    edge_atom.total_weight_->MapTo(GetOrCreateSymbolLocalScope(
-        edge_atom.total_weight_->name_, edge_atom.total_weight_->user_declared_, Symbol::Type::NUMBER));
-  }
-  return false;
-}
-
-bool SymbolGenerator::PostVisit(EdgeAtom &) {
-  auto &scope = scopes_.back();
-  scope.visiting_edge = nullptr;
-  scope.in_create_edge = false;
-  return true;
-}
-
-void SymbolGenerator::VisitWithIdentifiers(Expression *expr, const std::vector<Identifier *> &identifiers) {
-  auto &scope = scopes_.back();
-  std::vector<std::pair<std::optional<Symbol>, Identifier *>> prev_symbols;
-  // Collect previous symbols if they exist.
-  for (const auto &identifier : identifiers) {
-    std::optional<Symbol> prev_symbol;
-    auto prev_symbol_it = scope.symbols.find(identifier->name_);
-    if (prev_symbol_it != scope.symbols.end()) {
-      prev_symbol = prev_symbol_it->second;
-    }
-    identifier->MapTo(CreateSymbol(identifier->name_, identifier->user_declared_));
-    prev_symbols.emplace_back(prev_symbol, identifier);
-  }
-  // Visit the expression with the new symbols bound.
-  expr->Accept(*this);
-  // Restore back to previous symbols.
-  for (const auto &prev : prev_symbols) {
-    const auto &prev_symbol = prev.first;
-    const auto &identifier = prev.second;
-    if (prev_symbol) {
-      scope.symbols[identifier->name_] = *prev_symbol;
-    } else {
-      scope.symbols.erase(identifier->name_);
-    }
-  }
-}
-
-bool SymbolGenerator::HasSymbol(const std::string &name) const {
-  return std::ranges::any_of(scopes_, [&name](const auto &scope) { return scope.symbols.contains(name); });
-}
-
-bool SymbolGenerator::HasSymbolLocalScope(const std::string &name) const {
-  return scopes_.back().symbols.contains(name);
-}
-
-bool SymbolGenerator::ConsumePredefinedIdentifier(const std::string &name) {
-  auto it = predefined_identifiers_.find(name);
-
-  if (it == predefined_identifiers_.end()) {
-    return false;
-  }
-
-  // we can only use the predefined identifier in a single scope so we remove it after creating
-  // a symbol for it
-  auto &identifier = it->second;
-  MG_ASSERT(!identifier->user_declared_, "Predefined symbols cannot be user declared!");
-  identifier->MapTo(CreateSymbol(identifier->name_, identifier->user_declared_));
-  predefined_identifiers_.erase(it);
-  return true;
-}
-
-}  // namespace memgraph::query::v2

src/query/v2/frontend/semantic/symbol_generator.hpp

@@ -1,176 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-// Copyright 2017 Memgraph
-//
-// Created by Teon Banek on 11-03-2017
-
-#pragma once
-
-#include <optional>
-#include <vector>
-
-#include "query/v2/exceptions.hpp"
-#include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/semantic/symbol_table.hpp"
-
-namespace memgraph::query::v2 {
-
-/// Visits the AST and generates symbols for variables.
-///
-/// During the process of symbol generation, simple semantic checks are
-/// performed. Such as, redeclaring a variable or conflicting expectations of
-/// variable types.
-class SymbolGenerator : public HierarchicalTreeVisitor {
- public:
-  explicit SymbolGenerator(SymbolTable *symbol_table, const std::vector<Identifier *> &predefined_identifiers);
-
-  using HierarchicalTreeVisitor::PostVisit;
-  using HierarchicalTreeVisitor::PreVisit;
-  using HierarchicalTreeVisitor::Visit;
-  using typename HierarchicalTreeVisitor::ReturnType;
-
-  // Query
-  bool PreVisit(SingleQuery &) override;
-
-  // Union
-  bool PreVisit(CypherUnion &) override;
-  bool PostVisit(CypherUnion &) override;
-
-  // Clauses
-  bool PreVisit(Create &) override;
-  bool PostVisit(Create &) override;
-  bool PreVisit(CallProcedure &) override;
-  bool PostVisit(CallProcedure &) override;
-  bool PreVisit(LoadCsv &) override;
-  bool PostVisit(LoadCsv &) override;
-  bool PreVisit(Return &) override;
-  bool PostVisit(Return &) override;
-  bool PreVisit(With &) override;
-  bool PreVisit(Where &) override;
-  bool PostVisit(Where &) override;
-  bool PreVisit(Merge &) override;
-  bool PostVisit(Merge &) override;
-  bool PostVisit(Unwind &) override;
-  bool PreVisit(Match &) override;
-  bool PostVisit(Match &) override;
-  bool PreVisit(Foreach &) override;
-  bool PostVisit(Foreach &) override;
-
-  // Expressions
-  ReturnType Visit(Identifier &) override;
-  ReturnType Visit(PrimitiveLiteral &) override { return true; }
-  ReturnType Visit(ParameterLookup &) override { return true; }
-  bool PreVisit(Aggregation &) override;
-  bool PostVisit(Aggregation &) override;
-  bool PreVisit(IfOperator &) override;
-  bool PostVisit(IfOperator &) override;
-  bool PreVisit(All &) override;
-  bool PreVisit(Single &) override;
-  bool PreVisit(Any &) override;
-  bool PreVisit(None &) override;
-  bool PreVisit(Reduce &) override;
-  bool PreVisit(Extract &) override;
-
-  // Pattern and its subparts.
-  bool PreVisit(Pattern &) override;
-  bool PostVisit(Pattern &) override;
-  bool PreVisit(NodeAtom &) override;
-  bool PostVisit(NodeAtom &) override;
-  bool PreVisit(EdgeAtom &) override;
-  bool PostVisit(EdgeAtom &) override;
-
- private:
-  // Scope stores the state of where we are when visiting the AST and a map of
-  // names to symbols.
-  struct Scope {
-    bool in_pattern{false};
-    bool in_merge{false};
-    bool in_create{false};
-    // in_create_node is true if we are creating or merging *only* a node.
-    // Therefore, it is *not* equivalent to (in_create || in_merge) &&
-    // in_node_atom.
-    bool in_create_node{false};
-    // True if creating an edge;
-    // shortcut for (in_create || in_merge) && visiting_edge.
-    bool in_create_edge{false};
-    bool in_node_atom{false};
-    EdgeAtom *visiting_edge{nullptr};
-    bool in_aggregation{false};
-    bool in_return{false};
-    bool in_with{false};
-    bool in_skip{false};
-    bool in_limit{false};
-    bool in_order_by{false};
-    bool in_where{false};
-    bool in_match{false};
-    bool in_foreach{false};
-    // True when visiting a pattern atom (node or edge) identifier, which can be
-    // reused or created in the pattern itself.
-    bool in_pattern_atom_identifier{false};
-    // True when visiting range bounds of a variable path.
-    bool in_edge_range{false};
-    // True if the return/with contains an aggregation in any named expression.
-    bool has_aggregation{false};
-    // Map from variable names to symbols.
-    std::map<std::string, Symbol> symbols;
-    // Identifiers found in property maps of patterns or as variable length path
-    // bounds in a single Match clause. They need to be checked after visiting
-    // Match. Identifiers created by naming vertices, edges and paths are *not*
-    // stored in here.
-    std::vector<Identifier *> identifiers_in_match;
-    // Number of nested IfOperators.
-    int num_if_operators{0};
-  };
-
-  static std::optional<Symbol> FindSymbolInScope(const std::string &name, const Scope &scope, Symbol::Type type);
-
-  bool HasSymbol(const std::string &name) const;
-  bool HasSymbolLocalScope(const std::string &name) const;
-
-  // @return true if it added a predefined identifier with that name
-  bool ConsumePredefinedIdentifier(const std::string &name);
-
-  // Returns a freshly generated symbol. Previous mapping of the same name to a
-  // different symbol is replaced with the new one.
-  auto CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY,
-                    int token_position = -1);
-
-  auto GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY);
-  // Returns the symbol by name. If the mapping already exists, checks if the
-  // types match. Otherwise, returns a new symbol.
-  auto GetOrCreateSymbolLocalScope(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY);
-
-  void VisitReturnBody(ReturnBody &body, Where *where = nullptr);
-
-  void VisitWithIdentifiers(Expression *, const std::vector<Identifier *> &);
-
-  SymbolTable *symbol_table_;
-
-  // Identifiers which are injected from outside the query. Each identifier
-  // is mapped by its name.
-  std::unordered_map<std::string, Identifier *> predefined_identifiers_;
-  std::vector<Scope> scopes_;
-  std::unordered_set<std::string> prev_return_names_;
-  std::unordered_set<std::string> curr_return_names_;
-};
-
-inline SymbolTable MakeSymbolTable(CypherQuery *query, const std::vector<Identifier *> &predefined_identifiers = {}) {
-  SymbolTable symbol_table;
-  SymbolGenerator symbol_generator(&symbol_table, predefined_identifiers);
-  query->single_query_->Accept(symbol_generator);
-  for (auto *cypher_union : query->cypher_unions_) {
-    cypher_union->Accept(symbol_generator);
-  }
-  return symbol_table;
-}
-
-}  // namespace memgraph::query::v2

src/query/v2/frontend/stripped.cpp

@@ -18,19 +18,19 @@
 #include <string>
 #include <vector>
 
+#include "expr/parsing.hpp"
+#include "parser/opencypher/generated/MemgraphCypher.h"
+#include "parser/opencypher/generated/MemgraphCypherBaseVisitor.h"
+#include "parser/opencypher/generated/MemgraphCypherLexer.h"
+#include "parser/stripped_lexer_constants.hpp"
 #include "query/v2/exceptions.hpp"
-#include "query/v2/frontend/opencypher/generated/MemgraphCypher.h"
-#include "query/v2/frontend/opencypher/generated/MemgraphCypherBaseVisitor.h"
-#include "query/v2/frontend/opencypher/generated/MemgraphCypherLexer.h"
-#include "query/v2/frontend/parsing.hpp"
-#include "query/v2/frontend/stripped_lexer_constants.hpp"
 #include "utils/fnv.hpp"
 #include "utils/logging.hpp"
 #include "utils/string.hpp"
 
 namespace memgraph::query::v2::frontend {
 
-using namespace lexer_constants;
+using namespace parser::lexer_constants;  // NOLINT(google-build-using-namespace)
 
 StrippedQuery::StrippedQuery(const std::string &query) : original_(query) {
   enum class Token {
@@ -134,13 +134,13 @@ StrippedQuery::StrippedQuery(const std::string &query) : original_(query) {
       case Token::SPACE:
         break;
       case Token::STRING:
-        replace_stripped(token_index, ParseStringLiteral(token.second), kStrippedStringToken);
+        replace_stripped(token_index, expr::ParseStringLiteral(token.second), kStrippedStringToken);
         break;
       case Token::INT:
-        replace_stripped(token_index, ParseIntegerLiteral(token.second), kStrippedIntToken);
+        replace_stripped(token_index, expr::ParseIntegerLiteral(token.second), kStrippedIntToken);
         break;
       case Token::REAL:
-        replace_stripped(token_index, ParseDoubleLiteral(token.second), kStrippedDoubleToken);
+        replace_stripped(token_index, expr::ParseDoubleLiteral(token.second), kStrippedDoubleToken);
         break;
       case Token::SPECIAL:
       case Token::ESCAPED_NAME:
@@ -148,7 +148,7 @@ StrippedQuery::StrippedQuery(const std::string &query) : original_(query) {
         token_strings.push_back(token.second);
         break;
       case Token::PARAMETER:
-        parameters_[token_index] = ParseParameter(token.second);
+        parameters_[token_index] = expr::ParseParameter(token.second);
         token_strings.push_back(token.second);
         break;
     }
@@ -462,13 +462,13 @@ int StrippedQuery::MatchEscapedName(int start) const {
 int StrippedQuery::MatchUnescapedName(int start) const {
   auto i = start;
   auto got = GetFirstUtf8SymbolCodepoint(original_.data() + i);
-  if (got.first >= lexer_constants::kBitsetSize || !kUnescapedNameAllowedStarts[got.first]) {
+  if (got.first >= parser::lexer_constants::kBitsetSize || !kUnescapedNameAllowedStarts[got.first]) {
     return 0;
   }
   i += got.second;
   while (i < static_cast<int>(original_.size())) {
     got = GetFirstUtf8SymbolCodepoint(original_.data() + i);
-    if (got.first >= lexer_constants::kBitsetSize || !kUnescapedNameAllowedParts[got.first]) {
+    if (got.first >= parser::lexer_constants::kBitsetSize || !kUnescapedNameAllowedParts[got.first]) {
       break;
     }
     i += got.second;
@@ -487,7 +487,7 @@ int StrippedQuery::MatchWhitespaceAndComments(int start) const {
   while (i < len) {
     if (state == State::OUT) {
       auto got = GetFirstUtf8SymbolCodepoint(original_.data() + i);
-      if (got.first < lexer_constants::kBitsetSize && kSpaceParts[got.first]) {
+      if (got.first < parser::lexer_constants::kBitsetSize && kSpaceParts[got.first]) {
         i += got.second;
       } else if (i + 1 < len && original_[i] == '/' && original_[i + 1] == '*') {
         comment_position = i;

src/query/v2/interpret/awesome_memgraph_functions.cpp

@@ -20,12 +20,13 @@
 #include <string_view>
 #include <type_traits>
 
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/procedure/cypher_types.hpp"
 #include "query/v2/procedure/mg_procedure_impl.hpp"
 #include "query/v2/procedure/module.hpp"
-#include "query/v2/typed_value.hpp"
+#include "storage/v3/conversions.hpp"
 #include "utils/string.hpp"
 #include "utils/temporal.hpp"
 
@@ -405,7 +406,8 @@ TypedValue Properties(const TypedValue *args, int64_t nargs, const FunctionConte
       }
     }
     for (const auto &property : *maybe_props) {
-      properties.emplace(dba->PropertyToName(property.first), property.second);
+      properties.emplace(dba->PropertyToName(property.first),
+                         storage::v3::PropertyToTypedValue<TypedValue>(property.second));
     }
     return TypedValue(std::move(properties));
   };
@@ -1189,9 +1191,6 @@ std::function<TypedValue(const TypedValue *, const int64_t, const FunctionContex
           "Function '{}' has been unloaded. Please check query modules to confirm that function is loaded in Memgraph.",
           fully_qualified_name);
     }
-    /// Explicit extraction of module pointer, to clearly state that the lock is aquired.
-    // NOLINTNEXTLINE(clang-diagnostic-unused-variable)
-    const auto &module_ptr = (*maybe_found).first;
 
     const auto &func_cb = func.cb;
     mgp_memory memory{ctx.memory};
@@ -1293,6 +1292,7 @@ std::function<TypedValue(const TypedValue *, int64_t, const FunctionContext &ctx
   if (function_name == kStartsWith) return StartsWith;
   if (function_name == "SUBSTRING") return Substring;
   if (function_name == "TOLOWER") return ToLower;
+  // TODO(kostasrim) fix function lookup here
   if (function_name == "TOSTRING") return ToString;
   if (function_name == "TOUPPER") return ToUpper;
   if (function_name == "TRIM") return Trim;

src/query/v2/interpret/awesome_memgraph_functions.hpp

@@ -15,13 +15,13 @@
 #include <string>
 #include <unordered_map>
 
+#include "query/v2/bindings/typed_value.hpp"
 #include "storage/v3/view.hpp"
 #include "utils/memory.hpp"
 
 namespace memgraph::query::v2 {
 
 class DbAccessor;
-class TypedValue;
 
 namespace {
 const char kStartsWith[] = "STARTSWITH";

src/query/v2/interpret/eval.cpp

@@ -1,35 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "query/v2/interpret/eval.hpp"
-
-namespace memgraph::query::v2 {
-
-int64_t EvaluateInt(ExpressionEvaluator *evaluator, Expression *expr, const std::string &what) {
-  TypedValue value = expr->Accept(*evaluator);
-  try {
-    return value.ValueInt();
-  } catch (TypedValueException &e) {
-    throw QueryRuntimeException(what + " must be an int");
-  }
-}
-
-std::optional<size_t> EvaluateMemoryLimit(ExpressionEvaluator *eval, Expression *memory_limit, size_t memory_scale) {
-  if (!memory_limit) return std::nullopt;
-  auto limit_value = memory_limit->Accept(*eval);
-  if (!limit_value.IsInt() || limit_value.ValueInt() <= 0)
-    throw QueryRuntimeException("Memory limit must be a non-negative integer.");
-  size_t limit = limit_value.ValueInt();
-  if (std::numeric_limits<size_t>::max() / memory_scale < limit) throw QueryRuntimeException("Memory limit overflow.");
-  return limit * memory_scale;
-}
-
-}  // namespace memgraph::query::v2

src/query/v2/interpreter.cpp

@@ -21,7 +21,14 @@
 #include <limits>
 #include <optional>
 
+#include "expr/ast/ast_visitor.hpp"
 #include "memory/memory_control.hpp"
+#include "parser/opencypher/parser.hpp"
+#include "query/v2/bindings/eval.hpp"
+#include "query/v2/bindings/frame.hpp"
+#include "query/v2/bindings/symbol_table.hpp"
+#include "query/v2/bindings/typed_value.hpp"
+#include "query/v2/common.hpp"
 #include "query/v2/constants.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/cypher_query_interpreter.hpp"
@@ -29,19 +36,13 @@
 #include "query/v2/dump.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/ast/ast_visitor.hpp"
-#include "query/v2/frontend/ast/cypher_main_visitor.hpp"
-#include "query/v2/frontend/opencypher/parser.hpp"
 #include "query/v2/frontend/semantic/required_privileges.hpp"
-#include "query/v2/frontend/semantic/symbol_generator.hpp"
-#include "query/v2/interpret/eval.hpp"
 #include "query/v2/metadata.hpp"
 #include "query/v2/plan/planner.hpp"
 #include "query/v2/plan/profile.hpp"
 #include "query/v2/plan/vertex_count_cache.hpp"
 #include "query/v2/stream/common.hpp"
 #include "query/v2/trigger.hpp"
-#include "query/v2/typed_value.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/storage.hpp"
 #include "utils/algorithm.hpp"
@@ -265,7 +266,7 @@ Callback HandleAuthQuery(AuthQuery *auth_query, AuthQueryHandler *auth, const Pa
   // Empty frame for evaluation of password expression. This is OK since
   // password should be either null or string literal and it's evaluation
   // should not depend on frame.
-  Frame frame(0);
+  expr::Frame<TypedValue> frame(0);
   SymbolTable symbol_table;
   EvaluationContext evaluation_context;
   // TODO: MemoryResource for EvaluationContext, it should probably be passed as
@@ -432,7 +433,7 @@ Callback HandleAuthQuery(AuthQuery *auth_query, AuthQueryHandler *auth, const Pa
 Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &parameters,
                                 InterpreterContext *interpreter_context, DbAccessor *db_accessor,
                                 std::vector<Notification> *notifications) {
-  Frame frame(0);
+  expr::Frame<TypedValue> frame(0);
   SymbolTable symbol_table;
   EvaluationContext evaluation_context;
   // TODO: MemoryResource for EvaluationContext, it should probably be passed as
@@ -663,7 +664,7 @@ Callback::CallbackFunction GetPulsarCreateCallback(StreamQuery *stream_query, Ex
 Callback HandleStreamQuery(StreamQuery *stream_query, const Parameters &parameters,
                            InterpreterContext *interpreter_context, DbAccessor *db_accessor,
                            const std::string *username, std::vector<Notification> *notifications) {
-  Frame frame(0);
+  expr::Frame<TypedValue> frame(0);
   SymbolTable symbol_table;
   EvaluationContext evaluation_context;
   // TODO: MemoryResource for EvaluationContext, it should probably be passed as
@@ -797,7 +798,7 @@ Callback HandleStreamQuery(StreamQuery *stream_query, const Parameters &paramete
 }
 
 Callback HandleSettingQuery(SettingQuery *setting_query, const Parameters &parameters, DbAccessor *db_accessor) {
-  Frame frame(0);
+  expr::Frame<TypedValue> frame(0);
   SymbolTable symbol_table;
   EvaluationContext evaluation_context;
   // TODO: MemoryResource for EvaluationContext, it should probably be passed as
@@ -1007,7 +1008,7 @@ struct PullPlan {
  private:
   std::shared_ptr<CachedPlan> plan_ = nullptr;
   plan::UniqueCursorPtr cursor_ = nullptr;
-  Frame frame_;
+  expr::Frame<TypedValue> frame_;
   ExecutionContext ctx_;
   std::optional<size_t> memory_limit_;
 
@@ -1214,13 +1215,14 @@ PreparedQuery PrepareCypherQuery(ParsedQuery parsed_query, std::map<std::string,
                                  TriggerContextCollector *trigger_context_collector = nullptr) {
   auto *cypher_query = utils::Downcast<CypherQuery>(parsed_query.query);
 
-  Frame frame(0);
+  expr::Frame<TypedValue> frame(0);
   SymbolTable symbol_table;
   EvaluationContext evaluation_context;
   evaluation_context.timestamp = QueryTimestamp();
   evaluation_context.parameters = parsed_query.parameters;
   ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, dba, storage::v3::View::OLD);
-  const auto memory_limit = EvaluateMemoryLimit(&evaluator, cypher_query->memory_limit_, cypher_query->memory_scale_);
+  const auto memory_limit =
+      expr::EvaluateMemoryLimit(&evaluator, cypher_query->memory_limit_, cypher_query->memory_scale_);
   if (memory_limit) {
     spdlog::info("Running query with memory limit of {}", utils::GetReadableSize(*memory_limit));
   }
@@ -1353,13 +1355,14 @@ PreparedQuery PrepareProfileQuery(ParsedQuery parsed_query, bool in_explicit_tra
 
   auto *cypher_query = utils::Downcast<CypherQuery>(parsed_inner_query.query);
   MG_ASSERT(cypher_query, "Cypher grammar should not allow other queries in PROFILE");
-  Frame frame(0);
+  expr::Frame<TypedValue> frame(0);
   SymbolTable symbol_table;
   EvaluationContext evaluation_context;
   evaluation_context.timestamp = QueryTimestamp();
   evaluation_context.parameters = parsed_inner_query.parameters;
   ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, dba, storage::v3::View::OLD);
-  const auto memory_limit = EvaluateMemoryLimit(&evaluator, cypher_query->memory_limit_, cypher_query->memory_scale_);
+  const auto memory_limit =
+      expr::EvaluateMemoryLimit(&evaluator, cypher_query->memory_limit_, cypher_query->memory_scale_);
 
   auto cypher_query_plan = CypherQueryToPlan(
       parsed_inner_query.stripped_query.hash(), std::move(parsed_inner_query.ast_storage), cypher_query,

src/query/v2/interpreter.hpp

@@ -14,22 +14,21 @@
 #include <gflags/gflags.h>
 
 #include "query/v2/auth_checker.hpp"
+#include "query/v2/bindings/cypher_main_visitor.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/config.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/cypher_query_interpreter.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/ast/cypher_main_visitor.hpp"
 #include "query/v2/frontend/stripped.hpp"
-#include "query/v2/interpret/frame.hpp"
 #include "query/v2/metadata.hpp"
 #include "query/v2/plan/operator.hpp"
 #include "query/v2/plan/read_write_type_checker.hpp"
 #include "query/v2/stream.hpp"
 #include "query/v2/stream/streams.hpp"
 #include "query/v2/trigger.hpp"
-#include "query/v2/typed_value.hpp"
 #include "storage/v3/isolation_level.hpp"
 #include "utils/event_counter.hpp"
 #include "utils/logging.hpp"

src/query/v2/metadata.hpp

@@ -17,7 +17,7 @@
 #include <string_view>
 #include <type_traits>
 
-#include "query/v2/typed_value.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 
 namespace memgraph::query::v2 {
 

src/query/v2/plan/cost_estimator.hpp

@@ -11,10 +11,11 @@
 
 #pragma once
 
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
 #include "query/v2/parameters.hpp"
 #include "query/v2/plan/operator.hpp"
-#include "query/v2/typed_value.hpp"
+#include "storage/v3/conversions.hpp"
 
 namespace memgraph::query::v2::plan {
 
@@ -248,7 +249,7 @@ class CostEstimator : public HierarchicalLogicalOperatorVisitor {
   // return nullopt.
   std::optional<storage::v3::PropertyValue> ConstPropertyValue(const Expression *expression) {
     if (auto *literal = utils::Downcast<const PrimitiveLiteral>(expression)) {
-      return literal->value_;
+      return storage::v3::TypedToPropertyValue(literal->value_);
     } else if (auto *param_lookup = utils::Downcast<const ParameterLookup>(expression)) {
       return parameters.AtTokenPosition(param_lookup->token_position_);
     }

src/query/v2/plan/operator.cpp

@@ -26,17 +26,18 @@
 #include <cppitertools/chain.hpp>
 #include <cppitertools/imap.hpp>
 
+#include "query/v2/bindings/eval.hpp"
+#include "query/v2/bindings/symbol_table.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/semantic/symbol_table.hpp"
-#include "query/v2/interpret/eval.hpp"
 #include "query/v2/path.hpp"
 #include "query/v2/plan/scoped_profile.hpp"
 #include "query/v2/procedure/cypher_types.hpp"
 #include "query/v2/procedure/mg_procedure_impl.hpp"
 #include "query/v2/procedure/module.hpp"
+#include "storage/v3/conversions.hpp"
 #include "storage/v3/property_value.hpp"
 #include "utils/algorithm.hpp"
 #include "utils/csv_parsing.hpp"
@@ -187,7 +188,7 @@ VertexAccessor &CreateLocalVertexAtomically(const NodeCreationInfo &node_info, F
   if (const auto *node_info_properties = std::get_if<PropertiesMapList>(&node_info.properties)) {
     properties.reserve(node_info_properties->size());
     for (const auto &[key, value_expression] : *node_info_properties) {
-      properties.emplace_back(key, storage::v3::PropertyValue(value_expression->Accept(evaluator)));
+      properties.emplace_back(key, storage::v3::TypedToPropertyValue(value_expression->Accept(evaluator)));
     }
   } else {
     auto property_map = evaluator.Visit(*std::get<ParameterLookup *>(node_info.properties)).ValueMap();
@@ -195,7 +196,7 @@ VertexAccessor &CreateLocalVertexAtomically(const NodeCreationInfo &node_info, F
 
     for (const auto &[key, value] : property_map) {
       auto property_id = dba.NameToProperty(key);
-      properties.emplace_back(property_id, value);
+      properties.emplace_back(property_id, storage::v3::TypedToPropertyValue(value));
     }
   }
 
@@ -510,7 +511,7 @@ UniqueCursorPtr ScanAllByLabelPropertyRange::MakeCursor(utils::MemoryResource *m
       if (!bound) return std::nullopt;
       const auto &value = bound->value()->Accept(evaluator);
       try {
-        const auto &property_value = storage::v3::PropertyValue(value);
+        const auto &property_value = storage::v3::TypedToPropertyValue(value);
         switch (property_value.type()) {
           case storage::v3::PropertyValue::Type::Bool:
           case storage::v3::PropertyValue::Type::List:
@@ -529,7 +530,7 @@ UniqueCursorPtr ScanAllByLabelPropertyRange::MakeCursor(utils::MemoryResource *m
             // yet.
             return std::make_optional(utils::Bound<storage::v3::PropertyValue>(property_value, bound->type()));
         }
-      } catch (const TypedValueException &) {
+      } catch (const expr::TypedValueException &) {
         throw QueryRuntimeException("'{}' cannot be used as a property value.", value.type());
       }
     };
@@ -570,10 +571,10 @@ UniqueCursorPtr ScanAllByLabelPropertyValue::MakeCursor(utils::MemoryResource *m
     ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.db_accessor, view_);
     auto value = expression_->Accept(evaluator);
     if (value.IsNull()) return std::nullopt;
-    if (!value.IsPropertyValue()) {
-      throw QueryRuntimeException("'{}' cannot be used as a property value.", value.type());
-    }
-    return std::make_optional(db->Vertices(view_, label_, property_, storage::v3::PropertyValue(value)));
+    //    if (!value.IsPropertyValue()) {
+    //      throw QueryRuntimeException("'{}' cannot be used as a property value.", value.type());
+    //    }
+    return std::make_optional(db->Vertices(view_, label_, property_, storage::v3::TypedToPropertyValue(value)));
   };
   return MakeUniqueCursorPtr<ScanAllCursor<decltype(vertices)>>(mem, output_symbol_, input_->MakeCursor(mem),
                                                                 std::move(vertices), "ScanAllByLabelPropertyValue");
@@ -946,7 +947,7 @@ class ExpandVariableCursor : public Cursor {
       ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.db_accessor,
                                     storage::v3::View::OLD);
       auto calc_bound = [&evaluator](auto &bound) {
-        auto value = EvaluateInt(&evaluator, bound, "Variable expansion bound");
+        auto value = expr::EvaluateInt(&evaluator, bound, "Variable expansion bound");
         if (value < 0) throw QueryRuntimeException("Variable expansion bound must be a non-negative integer.");
         return value;
       };
@@ -1098,10 +1099,11 @@ class STShortestPathCursor : public query::v2::plan::Cursor {
       const auto &sink = sink_tv.ValueVertex();
 
       int64_t lower_bound =
-          self_.lower_bound_ ? EvaluateInt(&evaluator, self_.lower_bound_, "Min depth in breadth-first expansion") : 1;
-      int64_t upper_bound = self_.upper_bound_
-                                ? EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in breadth-first expansion")
-                                : std::numeric_limits<int64_t>::max();
+          self_.lower_bound_ ? expr::EvaluateInt(&evaluator, self_.lower_bound_, "Min depth in breadth-first expansion")
+                             : 1;
+      int64_t upper_bound =
+          self_.upper_bound_ ? expr::EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in breadth-first expansion")
+                             : std::numeric_limits<int64_t>::max();
 
       if (upper_bound < 1 || lower_bound > upper_bound) continue;
 
@@ -1368,10 +1370,10 @@ class SingleSourceShortestPathCursor : public query::v2::plan::Cursor {
         // it is possible that the vertex is Null due to optional matching
         if (vertex_value.IsNull()) continue;
         lower_bound_ = self_.lower_bound_
-                           ? EvaluateInt(&evaluator, self_.lower_bound_, "Min depth in breadth-first expansion")
+                           ? expr::EvaluateInt(&evaluator, self_.lower_bound_, "Min depth in breadth-first expansion")
                            : 1;
         upper_bound_ = self_.upper_bound_
-                           ? EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in breadth-first expansion")
+                           ? expr::EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in breadth-first expansion")
                            : std::numeric_limits<int64_t>::max();
 
         if (upper_bound_ < 1 || lower_bound_ > upper_bound_) continue;
@@ -1550,7 +1552,8 @@ class ExpandWeightedShortestPathCursor : public query::v2::plan::Cursor {
           if (node.IsNull()) continue;
         }
         if (self_.upper_bound_) {
-          upper_bound_ = EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in weighted shortest path expansion");
+          upper_bound_ =
+              expr::EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in weighted shortest path expansion");
           upper_bound_set_ = true;
         } else {
           upper_bound_ = std::numeric_limits<int64_t>::max();
@@ -2063,7 +2066,8 @@ bool SetProperty::SetPropertyCursor::Pull(Frame &frame, ExecutionContext &contex
 
   switch (lhs.type()) {
     case TypedValue::Type::Vertex: {
-      auto old_value = PropsSetChecked(&lhs.ValueVertex(), *context.db_accessor, self_.property_, rhs);
+      auto old_value = storage::v3::PropertyToTypedValue<TypedValue>(
+          PropsSetChecked(&lhs.ValueVertex(), *context.db_accessor, self_.property_, rhs));
       context.execution_stats[ExecutionStats::Key::UPDATED_PROPERTIES] += 1;
       if (context.trigger_context_collector) {
         // rhs cannot be moved because it was created with the allocator that is only valid during current pull
@@ -2073,7 +2077,8 @@ bool SetProperty::SetPropertyCursor::Pull(Frame &frame, ExecutionContext &contex
       break;
     }
     case TypedValue::Type::Edge: {
-      auto old_value = PropsSetChecked(&lhs.ValueEdge(), *context.db_accessor, self_.property_, rhs);
+      auto old_value = storage::v3::PropertyToTypedValue<TypedValue>(
+          PropsSetChecked(&lhs.ValueEdge(), *context.db_accessor, self_.property_, rhs));
       context.execution_stats[ExecutionStats::Key::UPDATED_PROPERTIES] += 1;
       if (context.trigger_context_collector) {
         // rhs cannot be moved because it was created with the allocator that is only valid during current pull
@@ -2180,7 +2185,7 @@ void SetPropertiesOnRecord(TRecordAccessor *record, const TypedValue &rhs, SetPr
   };
 
   auto register_set_property = [&](auto &&returned_old_value, auto key, auto &&new_value) {
-    auto old_value = [&]() -> storage::v3::PropertyValue {
+    auto old_value = storage::v3::PropertyToTypedValue<TypedValue>([&]() -> storage::v3::PropertyValue {
       if (!old_values) {
         return std::forward<decltype(returned_old_value)>(returned_old_value);
       }
@@ -2190,10 +2195,9 @@ void SetPropertiesOnRecord(TRecordAccessor *record, const TypedValue &rhs, SetPr
       }
 
       return {};
-    }();
-
+    }());
     context->trigger_context_collector->RegisterSetObjectProperty(
-        *record, key, TypedValue(std::move(old_value)), TypedValue(std::forward<decltype(new_value)>(new_value)));
+        *record, key, std::move(old_value), memgraph::storage::v3::PropertyToTypedValue<TypedValue>(new_value));
   };
 
   auto set_props = [&, record](auto properties) {
@@ -2231,7 +2235,7 @@ void SetPropertiesOnRecord(TRecordAccessor *record, const TypedValue &rhs, SetPr
         auto key = context->db_accessor->NameToProperty(kv.first);
         auto old_value = PropsSetChecked(record, *context->db_accessor, key, kv.second);
         if (should_register_change) {
-          register_set_property(std::move(old_value), key, kv.second);
+          register_set_property(std::move(old_value), key, storage::v3::TypedToPropertyValue(kv.second));
         }
       }
       break;
@@ -2245,8 +2249,8 @@ void SetPropertiesOnRecord(TRecordAccessor *record, const TypedValue &rhs, SetPr
   if (should_register_change && old_values) {
     // register removed properties
     for (auto &[property_id, property_value] : *old_values) {
-      context->trigger_context_collector->RegisterRemovedObjectProperty(*record, property_id,
-                                                                        TypedValue(std::move(property_value)));
+      context->trigger_context_collector->RegisterRemovedObjectProperty(
+          *record, property_id, storage::v3::PropertyToTypedValue<TypedValue>(property_value));
     }
   }
 }
@@ -2383,8 +2387,8 @@ bool RemoveProperty::RemovePropertyCursor::Pull(Frame &frame, ExecutionContext &
     auto old_value = PropsSetChecked(record, *context.db_accessor, property, TypedValue{});
 
     if (context.trigger_context_collector) {
-      context.trigger_context_collector->RegisterRemovedObjectProperty(*record, property,
-                                                                       TypedValue(std::move(old_value)));
+      context.trigger_context_collector->RegisterRemovedObjectProperty(
+          *record, property, storage::v3::PropertyToTypedValue<TypedValue>(std::move(old_value)));
     }
   };
 
@@ -2855,7 +2859,7 @@ class AggregateCursor : public Cursor {
             // an exception was just thrown above
             // safe to assume a bool TypedValue
             if (comparison_result.ValueBool()) *value_it = input_value;
-          } catch (const TypedValueException &) {
+          } catch (const expr::TypedValueException &) {
             throw QueryRuntimeException("Unable to get MIN of '{}' and '{}'.", input_value.type(), value_it->type());
           }
           break;
@@ -2866,7 +2870,7 @@ class AggregateCursor : public Cursor {
           try {
             TypedValue comparison_result = input_value > *value_it;
             if (comparison_result.ValueBool()) *value_it = input_value;
-          } catch (const TypedValueException &) {
+          } catch (const expr::TypedValueException &) {
             throw QueryRuntimeException("Unable to get MAX of '{}' and '{}'.", input_value.type(), value_it->type());
           }
           break;
@@ -3816,7 +3820,7 @@ class CallProcedureCursor : public Cursor {
       // TODO: This will probably need to be changed when we add support for
       // generator like procedures which yield a new result on each invocation.
       auto *memory = context.evaluation_context.memory;
-      auto memory_limit = EvaluateMemoryLimit(&evaluator, self_->memory_limit_, self_->memory_scale_);
+      auto memory_limit = expr::EvaluateMemoryLimit(&evaluator, self_->memory_limit_, self_->memory_scale_);
       auto graph = mgp_graph::WritableGraph(*context.db_accessor, graph_view, context);
       CallCustomProcedure(self_->procedure_name_, *proc, self_->arguments_, graph, &evaluator, memory, memory_limit,
                           &result_);

src/query/v2/plan/operator.lcp

@@ -24,8 +24,10 @@
 
 #include "query/v2/common.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/semantic/symbol.hpp"
-#include "query/v2/typed_value.hpp"
+#include "expr/semantic/symbol.hpp"
+#include "query/v2//bindings/typed_value.hpp"
+#include "query/v2//bindings/frame.hpp"
+#include "query/v2//bindings/symbol_table.hpp"
 #include "storage/v3/id_types.hpp"
 #include "utils/bound.hpp"
 #include "utils/fnv.hpp"
@@ -40,9 +42,6 @@ cpp<#
 
 #>cpp
 struct ExecutionContext;
-class ExpressionEvaluator;
-class Frame;
-class SymbolTable;
 cpp<#
 
 (lcp:namespace plan)

src/query/v2/plan/planner.hpp

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "query/v2/bindings/symbol_table.hpp"
 #include "query/v2/plan/cost_estimator.hpp"
 #include "query/v2/plan/operator.hpp"
 #include "query/v2/plan/preprocess.hpp"
@@ -29,7 +30,6 @@
 namespace memgraph::query::v2 {
 
 class AstStorage;
-class SymbolTable;
 
 namespace plan {
 

src/query/v2/plan/preprocess.cpp

@@ -16,9 +16,9 @@
 #include <unordered_map>
 #include <variant>
 
+#include "query/v2/bindings/ast_visitor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/ast/ast_visitor.hpp"
 #include "query/v2/plan/preprocess.hpp"
 #include "utils/typeinfo.hpp"
 

src/query/v2/plan/preprocess.hpp

@@ -18,8 +18,8 @@
 #include <unordered_set>
 #include <vector>
 
+#include "query/v2/bindings/symbol_table.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/semantic/symbol_table.hpp"
 #include "query/v2/plan/operator.hpp"
 
 namespace memgraph::query::v2::plan {

src/query/v2/plan/pretty_print.cpp

@@ -12,8 +12,8 @@
 #include "query/v2/plan/pretty_print.hpp"
 #include <variant>
 
+#include "query/v2/bindings/pretty_print.hpp"
 #include "query/v2/db_accessor.hpp"
-#include "query/v2/frontend/ast/pretty_print.hpp"
 #include "utils/string.hpp"
 
 namespace memgraph::query::v2::plan {
@@ -324,7 +324,7 @@ std::string ToString(Ordering ord) {
 
 json ToJson(Expression *expression) {
   std::stringstream sstr;
-  PrintExpression(expression, &sstr);
+  expr::PrintExpression(expression, &sstr);
   return sstr.str();
 }
 

src/query/v2/plan/pretty_print.hpp

@@ -16,6 +16,7 @@
 
 #include <json/json.hpp>
 
+#include "query/v2/frontend/ast/ast.hpp"
 #include "query/v2/plan/operator.hpp"
 
 namespace memgraph::query::v2 {

src/query/v2/plan/profile.hpp

@@ -16,7 +16,7 @@
 
 #include <json/json.hpp>
 
-#include "query/v2/typed_value.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 
 namespace memgraph::query::v2 {
 

src/query/v2/plan/rule_based_planner.hpp

@@ -17,8 +17,8 @@
 
 #include "gflags/gflags.h"
 
+#include "query/v2/bindings/ast_visitor.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/ast/ast_visitor.hpp"
 #include "query/v2/plan/operator.hpp"
 #include "query/v2/plan/preprocess.hpp"
 #include "utils/logging.hpp"

src/query/v2/plan/vertex_count_cache.hpp

@@ -14,7 +14,8 @@
 
 #include <optional>
 
-#include "query/v2/typed_value.hpp"
+#include "query/v2/bindings/typed_value.hpp"
+#include "storage/v3/conversions.hpp"
 #include "storage/v3/id_types.hpp"
 #include "storage/v3/property_value.hpp"
 #include "utils/bound.hpp"
@@ -56,7 +57,7 @@ class VertexCountCache {
     auto label_prop = std::make_pair(label, property);
     auto &value_vertex_count = property_value_vertex_count_[label_prop];
     // TODO: Why do we even need TypedValue in this whole file?
-    TypedValue tv_value(value);
+    auto tv_value(storage::v3::PropertyToTypedValue<TypedValue>(value));
     if (value_vertex_count.find(tv_value) == value_vertex_count.end())
       value_vertex_count[tv_value] = db_->VerticesCount(label, property, value);
     return value_vertex_count.at(tv_value);
@@ -98,8 +99,8 @@ class VertexCountCache {
       const auto &maybe_upper = key.second;
       query::v2::TypedValue lower;
       query::v2::TypedValue upper;
-      if (maybe_lower) lower = TypedValue(maybe_lower->value());
-      if (maybe_upper) upper = TypedValue(maybe_upper->value());
+      if (maybe_lower) lower = storage::v3::PropertyToTypedValue<TypedValue>(maybe_lower->value());
+      if (maybe_upper) upper = storage::v3::PropertyToTypedValue<TypedValue>(maybe_upper->value());
       query::v2::TypedValue::Hash hash;
       return utils::HashCombine<size_t, size_t>{}(hash(lower), hash(upper));
     }
@@ -111,8 +112,8 @@ class VertexCountCache {
         if (maybe_bound_a && maybe_bound_b && maybe_bound_a->type() != maybe_bound_b->type()) return false;
         query::v2::TypedValue bound_a;
         query::v2::TypedValue bound_b;
-        if (maybe_bound_a) bound_a = TypedValue(maybe_bound_a->value());
-        if (maybe_bound_b) bound_b = TypedValue(maybe_bound_b->value());
+        if (maybe_bound_a) bound_a = storage::v3::PropertyToTypedValue<TypedValue>(maybe_bound_a->value());
+        if (maybe_bound_b) bound_b = storage::v3::PropertyToTypedValue<TypedValue>(maybe_bound_b->value());
         return query::v2::TypedValue::BoolEqual{}(bound_a, bound_b);
       };
       return bound_equal(a.first, b.first) && bound_equal(a.second, b.second);

src/query/v2/procedure/cypher_types.hpp

@@ -18,9 +18,9 @@
 #include <memory>
 #include <string_view>
 
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/procedure/cypher_type_ptr.hpp"
 #include "query/v2/procedure/mg_procedure_impl.hpp"
-#include "query/v2/typed_value.hpp"
 #include "utils/memory.hpp"
 #include "utils/pmr/string.hpp"
 

src/query/v2/procedure/mg_procedure_impl.cpp

@@ -24,9 +24,11 @@
 
 #include "mg_procedure.h"
 #include "module.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/procedure/cypher_types.hpp"
 #include "query/v2/procedure/mg_procedure_helpers.hpp"
 #include "query/v2/stream/common.hpp"
+#include "storage/v3/conversions.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/view.hpp"
 #include "utils/algorithm.hpp"
@@ -1606,7 +1608,8 @@ mgp_error mgp_vertex_set_property(struct mgp_vertex *v, const char *property_nam
         !trigger_ctx_collector->ShouldRegisterObjectPropertyChange<memgraph::query::v2::VertexAccessor>()) {
       return;
     }
-    const auto old_value = memgraph::query::v2::TypedValue(*result);
+    using memgraph::query::v2::TypedValue;
+    const auto old_value = memgraph::storage::v3::PropertyToTypedValue<TypedValue>(*result);
     if (property_value->type == mgp_value_type::MGP_VALUE_TYPE_NULL) {
       trigger_ctx_collector->RegisterRemovedObjectProperty(v->impl, prop_key, old_value);
       return;
@@ -2031,7 +2034,8 @@ mgp_error mgp_edge_set_property(struct mgp_edge *e, const char *property_name, m
         !trigger_ctx_collector->ShouldRegisterObjectPropertyChange<memgraph::query::v2::EdgeAccessor>()) {
       return;
     }
-    const auto old_value = memgraph::query::v2::TypedValue(*result);
+    using memgraph::query::v2::TypedValue;
+    const auto old_value = memgraph::storage::v3::PropertyToTypedValue<TypedValue>(*result);
     if (property_value->type == mgp_value_type::MGP_VALUE_TYPE_NULL) {
       e->from.graph->ctx->trigger_context_collector->RegisterRemovedObjectProperty(e->impl, prop_key, old_value);
       return;

src/query/v2/procedure/mg_procedure_impl.hpp

@@ -21,11 +21,11 @@
 
 #include "integrations/kafka/consumer.hpp"
 #include "integrations/pulsar/consumer.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
 #include "query/v2/procedure/cypher_type_ptr.hpp"
-#include "query/v2/typed_value.hpp"
 #include "storage/v3/view.hpp"
 #include "utils/memory.hpp"
 #include "utils/pmr/map.hpp"

src/query/v2/stream.hpp

@@ -14,7 +14,7 @@
 #include <memory>
 #include <vector>
 
-#include "query/v2/typed_value.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "utils/memory.hpp"
 
 namespace memgraph::query::v2 {

src/query/v2/stream/streams.cpp

@@ -20,6 +20,7 @@
 
 #include "integrations/constants.hpp"
 #include "mg_procedure.h"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/discard_value_stream.hpp"
 #include "query/v2/exceptions.hpp"
@@ -28,7 +29,7 @@
 #include "query/v2/procedure/mg_procedure_impl.hpp"
 #include "query/v2/procedure/module.hpp"
 #include "query/v2/stream/sources.hpp"
-#include "query/v2/typed_value.hpp"
+#include "storage/v3/conversions.hpp"
 #include "utils/event_counter.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory.hpp"
@@ -509,7 +510,7 @@ Streams::StreamsMap::iterator Streams::CreateConsumer(StreamsMap &map, const std
         for (auto &row : result.rows) {
           spdlog::trace("Processing row in stream '{}'", stream_name);
           auto [query_value, params_value] = ExtractTransformationResult(row.values, transformation_name, stream_name);
-          storage::v3::PropertyValue params_prop{params_value};
+          storage::v3::PropertyValue params_prop = storage::v3::TypedToPropertyValue(params_value);
 
           std::string query{query_value.ValueString()};
           spdlog::trace("Executing query '{}' in stream '{}'", query, stream_name);

src/query/v2/stream/streams.hpp

@@ -22,9 +22,9 @@
 
 #include "integrations/kafka/consumer.hpp"
 #include "kvstore/kvstore.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/stream/common.hpp"
 #include "query/v2/stream/sources.hpp"
-#include "query/v2/typed_value.hpp"
 #include "storage/v3/property_value.hpp"
 #include "utils/event_counter.hpp"
 #include "utils/exceptions.hpp"

src/query/v2/trigger.cpp

@@ -13,14 +13,14 @@
 
 #include <concepts>
 
+#include "query/v2/bindings/frame.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/config.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/cypher_query_interpreter.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/interpret/frame.hpp"
 #include "query/v2/serialization/property_value.hpp"
-#include "query/v2/typed_value.hpp"
 #include "storage/v3/property_value.hpp"
 #include "utils/event_counter.hpp"
 #include "utils/memory.hpp"

src/query/v2/trigger_context.cpp

@@ -13,13 +13,13 @@
 
 #include <concepts>
 
+#include "query/v2/bindings/frame.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/cypher_query_interpreter.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/interpret/frame.hpp"
 #include "query/v2/serialization/property_value.hpp"
-#include "query/v2/typed_value.hpp"
 #include "storage/v3/property_value.hpp"
 #include "utils/memory.hpp"
 

src/query/v2/trigger_context.hpp

@@ -20,8 +20,8 @@
 #include <utility>
 #include <vector>
 
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/db_accessor.hpp"
-#include "query/v2/typed_value.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/view.hpp"
 #include "utils/concepts.hpp"

src/query/v2/typed_value.hpp

@@ -1,739 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <cstdint>
-#include <iostream>
-#include <map>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-#include "query/v2/db_accessor.hpp"
-#include "query/v2/path.hpp"
-#include "utils/exceptions.hpp"
-#include "utils/memory.hpp"
-#include "utils/pmr/map.hpp"
-#include "utils/pmr/string.hpp"
-#include "utils/pmr/vector.hpp"
-#include "utils/temporal.hpp"
-
-namespace memgraph::query::v2 {
-
-// TODO: Neo4j does overflow checking. Should we also implement it?
-/**
- * Stores a query runtime value and its type.
- *
- * Values can be of a number of predefined types that are enumerated in
- * TypedValue::Type. Each such type corresponds to exactly one C++ type.
- *
- * Non-primitive value types perform additional memory allocations. To tune the
- * allocation scheme, each TypedValue stores a MemoryResource for said
- * allocations. When copying and moving TypedValue instances, take care that the
- * appropriate MemoryResource is used.
- */
-class TypedValue {
- public:
-  /** Custom TypedValue equality function that returns a bool
-   * (as opposed to returning TypedValue as the default equality does).
-   * This implementation treats two nulls as being equal and null
-   * not being equal to everything else.
-   */
-  struct BoolEqual {
-    bool operator()(const TypedValue &left, const TypedValue &right) const;
-  };
-
-  /** Hash operator for TypedValue.
-   *
-   * Not injecting into std
-   * due to linking problems. If the implementation is in this header,
-   * then it implicitly instantiates TypedValue::Value<T> before
-   * explicit instantiation in .cpp file. If the implementation is in
-   * the .cpp file, it won't link.
-   * TODO: No longer the case as Value<T> was removed.
-   */
-  struct Hash {
-    size_t operator()(const TypedValue &value) const;
-  };
-
-  /** A value type. Each type corresponds to exactly one C++ type */
-  enum class Type : unsigned {
-    Null,
-    Bool,
-    Int,
-    Double,
-    String,
-    List,
-    Map,
-    Vertex,
-    Edge,
-    Path,
-    Date,
-    LocalTime,
-    LocalDateTime,
-    Duration
-  };
-
-  // TypedValue at this exact moment of compilation is an incomplete type, and
-  // the standard says that instantiating a container with an incomplete type
-  // invokes undefined behaviour. The libstdc++-8.3.0 we are using supports
-  // std::map with incomplete type, but this is still murky territory. Note that
-  // since C++17, std::vector is explicitly said to support incomplete types.
-
-  using TString = utils::pmr::string;
-  using TVector = utils::pmr::vector<TypedValue>;
-  using TMap = utils::pmr::map<utils::pmr::string, TypedValue>;
-
-  /** Allocator type so that STL containers are aware that we need one */
-  using allocator_type = utils::Allocator<TypedValue>;
-
-  /** Construct a Null value with default utils::NewDeleteResource(). */
-  TypedValue() : type_(Type::Null) {}
-
-  /** Construct a Null value with given utils::MemoryResource. */
-  explicit TypedValue(utils::MemoryResource *memory) : memory_(memory), type_(Type::Null) {}
-
-  /**
-   * Construct a copy of other.
-   * utils::MemoryResource is obtained by calling
-   * std::allocator_traits<>::select_on_container_copy_construction(other.memory_).
-   * Since we use utils::Allocator, which does not propagate, this means that
-   * memory_ will be the default utils::NewDeleteResource().
-   */
-  TypedValue(const TypedValue &other);
-
-  /** Construct a copy using the given utils::MemoryResource */
-  TypedValue(const TypedValue &other, utils::MemoryResource *memory);
-
-  /**
-   * Construct with the value of other.
-   * utils::MemoryResource is obtained from other. After the move, other will be
-   * set to Null.
-   */
-  TypedValue(TypedValue &&other) noexcept;
-
-  /**
-   * Construct with the value of other, but use the given utils::MemoryResource.
-   * After the move, other will be set to Null.
-   * If `*memory != *other.GetMemoryResource()`, then a copy is made instead of
-   * a move.
-   */
-  TypedValue(TypedValue &&other, utils::MemoryResource *memory);
-
-  explicit TypedValue(bool value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Bool) {
-    bool_v = value;
-  }
-
-  explicit TypedValue(int value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Int) {
-    int_v = value;
-  }
-
-  explicit TypedValue(int64_t value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Int) {
-    int_v = value;
-  }
-
-  explicit TypedValue(double value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Double) {
-    double_v = value;
-  }
-
-  explicit TypedValue(const utils::Date &value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Date) {
-    date_v = value;
-  }
-
-  explicit TypedValue(const utils::LocalTime &value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::LocalTime) {
-    local_time_v = value;
-  }
-
-  explicit TypedValue(const utils::LocalDateTime &value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::LocalDateTime) {
-    local_date_time_v = value;
-  }
-
-  explicit TypedValue(const utils::Duration &value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Duration) {
-    duration_v = value;
-  }
-
-  // conversion function to storage::v3::PropertyValue
-  explicit operator storage::v3::PropertyValue() const;
-
-  // copy constructors for non-primitive types
-  explicit TypedValue(const std::string &value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::String) {
-    new (&string_v) TString(value, memory_);
-  }
-
-  explicit TypedValue(const char *value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::String) {
-    new (&string_v) TString(value, memory_);
-  }
-
-  explicit TypedValue(const std::string_view value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::String) {
-    new (&string_v) TString(value, memory_);
-  }
-
-  /**
-   * Construct a copy of other.
-   * utils::MemoryResource is obtained by calling
-   * std::allocator_traits<>::
-   *     select_on_container_copy_construction(other.get_allocator()).
-   * Since we use utils::Allocator, which does not propagate, this means that
-   * memory_ will be the default utils::NewDeleteResource().
-   */
-  explicit TypedValue(const TString &other)
-      : TypedValue(other, std::allocator_traits<utils::Allocator<TypedValue>>::select_on_container_copy_construction(
-                              other.get_allocator())
-                              .GetMemoryResource()) {}
-
-  /** Construct a copy using the given utils::MemoryResource */
-  TypedValue(const TString &other, utils::MemoryResource *memory) : memory_(memory), type_(Type::String) {
-    new (&string_v) TString(other, memory_);
-  }
-
-  /** Construct a copy using the given utils::MemoryResource */
-  explicit TypedValue(const std::vector<TypedValue> &value, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::List) {
-    new (&list_v) TVector(memory_);
-    list_v.reserve(value.size());
-    list_v.assign(value.begin(), value.end());
-  }
-
-  /**
-   * Construct a copy of other.
-   * utils::MemoryResource is obtained by calling
-   * std::allocator_traits<>::
-   *     select_on_container_copy_construction(other.get_allocator()).
-   * Since we use utils::Allocator, which does not propagate, this means that
-   * memory_ will be the default utils::NewDeleteResource().
-   */
-  explicit TypedValue(const TVector &other)
-      : TypedValue(other, std::allocator_traits<utils::Allocator<TypedValue>>::select_on_container_copy_construction(
-                              other.get_allocator())
-                              .GetMemoryResource()) {}
-
-  /** Construct a copy using the given utils::MemoryResource */
-  TypedValue(const TVector &value, utils::MemoryResource *memory) : memory_(memory), type_(Type::List) {
-    new (&list_v) TVector(value, memory_);
-  }
-
-  /** Construct a copy using the given utils::MemoryResource */
-  explicit TypedValue(const std::map<std::string, TypedValue> &value,
-                      utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Map) {
-    new (&map_v) TMap(memory_);
-    for (const auto &kv : value) map_v.emplace(kv.first, kv.second);
-  }
-
-  /**
-   * Construct a copy of other.
-   * utils::MemoryResource is obtained by calling
-   * std::allocator_traits<>::
-   *     select_on_container_copy_construction(other.get_allocator()).
-   * Since we use utils::Allocator, which does not propagate, this means that
-   * memory_ will be the default utils::NewDeleteResource().
-   */
-  explicit TypedValue(const TMap &other)
-      : TypedValue(other, std::allocator_traits<utils::Allocator<TypedValue>>::select_on_container_copy_construction(
-                              other.get_allocator())
-                              .GetMemoryResource()) {}
-
-  /** Construct a copy using the given utils::MemoryResource */
-  TypedValue(const TMap &value, utils::MemoryResource *memory) : memory_(memory), type_(Type::Map) {
-    new (&map_v) TMap(value, memory_);
-  }
-
-  explicit TypedValue(const VertexAccessor &vertex, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Vertex) {
-    new (&vertex_v) VertexAccessor(vertex);
-  }
-
-  explicit TypedValue(const EdgeAccessor &edge, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Edge) {
-    new (&edge_v) EdgeAccessor(edge);
-  }
-
-  explicit TypedValue(const Path &path, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : memory_(memory), type_(Type::Path) {
-    new (&path_v) Path(path, memory_);
-  }
-
-  /** Construct a copy using default utils::NewDeleteResource() */
-  explicit TypedValue(const storage::v3::PropertyValue &value);
-
-  /** Construct a copy using the given utils::MemoryResource */
-  TypedValue(const storage::v3::PropertyValue &value, utils::MemoryResource *memory);
-
-  // move constructors for non-primitive types
-
-  /**
-   * Construct with the value of other.
-   * utils::MemoryResource is obtained from other. After the move, other will be
-   * left in unspecified state.
-   */
-  explicit TypedValue(TString &&other) noexcept
-      : TypedValue(std::move(other), other.get_allocator().GetMemoryResource()) {}
-
-  /**
-   * Construct with the value of other and use the given MemoryResource
-   * After the move, other will be left in unspecified state.
-   */
-  TypedValue(TString &&other, utils::MemoryResource *memory) : memory_(memory), type_(Type::String) {
-    new (&string_v) TString(std::move(other), memory_);
-  }
-
-  /**
-   * Perform an element-wise move using default utils::NewDeleteResource().
-   * Other will be not be empty, though elements may be Null.
-   */
-  explicit TypedValue(std::vector<TypedValue> &&other) : TypedValue(std::move(other), utils::NewDeleteResource()) {}
-
-  /**
-   * Perform an element-wise move of the other and use the given MemoryResource.
-   * Other will be not be left empty, though elements may be Null.
-   */
-  TypedValue(std::vector<TypedValue> &&other, utils::MemoryResource *memory) : memory_(memory), type_(Type::List) {
-    new (&list_v) TVector(memory_);
-    list_v.reserve(other.size());
-    // std::vector<TypedValue> has std::allocator and there's no move
-    // constructor for std::vector using different allocator types. Since
-    // std::allocator is not propagated to elements, it is possible that some
-    // TypedValue elements have a MemoryResource that is the same as the one we
-    // are given. In such a case we would like to move those TypedValue
-    // instances, so we use move_iterator.
-    list_v.assign(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()));
-  }
-
-  /**
-   * Construct with the value of other.
-   * utils::MemoryResource is obtained from other. After the move, other will be
-   * left empty.
-   */
-  explicit TypedValue(TVector &&other) noexcept
-      : TypedValue(std::move(other), other.get_allocator().GetMemoryResource()) {}
-
-  /**
-   * Construct with the value of other and use the given MemoryResource.
-   * If `other.get_allocator() != *memory`, this call will perform an
-   * element-wise move and other is not guaranteed to be empty.
-   */
-  TypedValue(TVector &&other, utils::MemoryResource *memory) : memory_(memory), type_(Type::List) {
-    new (&list_v) TVector(std::move(other), memory_);
-  }
-
-  /**
-   * Perform an element-wise move using default utils::NewDeleteResource().
-   * Other will not be left empty, i.e. keys will exist but their values may
-   * be Null.
-   */
-  explicit TypedValue(std::map<std::string, TypedValue> &&other)
-      : TypedValue(std::move(other), utils::NewDeleteResource()) {}
-
-  /**
-   * Perform an element-wise move using the given MemoryResource.
-   * Other will not be left empty, i.e. keys will exist but their values may
-   * be Null.
-   */
-  TypedValue(std::map<std::string, TypedValue> &&other, utils::MemoryResource *memory)
-      : memory_(memory), type_(Type::Map) {
-    new (&map_v) TMap(memory_);
-    for (auto &kv : other) map_v.emplace(kv.first, std::move(kv.second));
-  }
-
-  /**
-   * Construct with the value of other.
-   * utils::MemoryResource is obtained from other. After the move, other will be
-   * left empty.
-   */
-  explicit TypedValue(TMap &&other) noexcept
-      : TypedValue(std::move(other), other.get_allocator().GetMemoryResource()) {}
-
-  /**
-   * Construct with the value of other and use the given MemoryResource.
-   * If `other.get_allocator() != *memory`, this call will perform an
-   * element-wise move and other is not guaranteed to be empty, i.e. keys may
-   * exist but their values may be Null.
-   */
-  TypedValue(TMap &&other, utils::MemoryResource *memory) : memory_(memory), type_(Type::Map) {
-    new (&map_v) TMap(std::move(other), memory_);
-  }
-
-  explicit TypedValue(VertexAccessor &&vertex, utils::MemoryResource *memory = utils::NewDeleteResource()) noexcept
-      : memory_(memory), type_(Type::Vertex) {
-    new (&vertex_v) VertexAccessor(std::move(vertex));
-  }
-
-  explicit TypedValue(EdgeAccessor &&edge, utils::MemoryResource *memory = utils::NewDeleteResource()) noexcept
-      : memory_(memory), type_(Type::Edge) {
-    new (&edge_v) EdgeAccessor(std::move(edge));
-  }
-
-  /**
-   * Construct with the value of path.
-   * utils::MemoryResource is obtained from path. After the move, path will be
-   * left empty.
-   */
-  explicit TypedValue(Path &&path) noexcept : TypedValue(std::move(path), path.GetMemoryResource()) {}
-
-  /**
-   * Construct with the value of path and use the given MemoryResource.
-   * If `*path.GetMemoryResource() != *memory`, this call will perform an
-   * element-wise move and path is not guaranteed to be empty.
-   */
-  TypedValue(Path &&path, utils::MemoryResource *memory) : memory_(memory), type_(Type::Path) {
-    new (&path_v) Path(std::move(path), memory_);
-  }
-
-  /**
-   * Construct with the value of other.
-   * Default utils::NewDeleteResource() is used for allocations. After the move,
-   * other will be set to Null.
-   */
-  explicit TypedValue(storage::v3::PropertyValue &&other);
-
-  /**
-   * Construct with the value of other, but use the given utils::MemoryResource.
-   * After the move, other will be set to Null.
-   */
-  TypedValue(storage::v3::PropertyValue &&other, utils::MemoryResource *memory);
-
-  // copy assignment operators
-  TypedValue &operator=(const char *);
-  TypedValue &operator=(int);
-  TypedValue &operator=(bool);
-  TypedValue &operator=(int64_t);
-  TypedValue &operator=(double);
-  TypedValue &operator=(std::string_view);
-  TypedValue &operator=(const TVector &);
-  TypedValue &operator=(const std::vector<TypedValue> &);
-  TypedValue &operator=(const TMap &);
-  TypedValue &operator=(const std::map<std::string, TypedValue> &);
-  TypedValue &operator=(const VertexAccessor &);
-  TypedValue &operator=(const EdgeAccessor &);
-  TypedValue &operator=(const Path &);
-  TypedValue &operator=(const utils::Date &);
-  TypedValue &operator=(const utils::LocalTime &);
-  TypedValue &operator=(const utils::LocalDateTime &);
-  TypedValue &operator=(const utils::Duration &);
-
-  /** Copy assign other, utils::MemoryResource of `this` is used */
-  TypedValue &operator=(const TypedValue &other);
-
-  /** Move assign other, utils::MemoryResource of `this` is used. */
-  TypedValue &operator=(TypedValue &&other) noexcept(false);
-
-  // move assignment operators
-  TypedValue &operator=(TString &&);
-  TypedValue &operator=(TVector &&);
-  TypedValue &operator=(std::vector<TypedValue> &&);
-  TypedValue &operator=(TMap &&);
-  TypedValue &operator=(std::map<std::string, TypedValue> &&);
-  TypedValue &operator=(Path &&);
-
-  ~TypedValue();
-
-  Type type() const { return type_; }
-
-  // TODO consider adding getters for primitives by value (and not by ref)
-
-#define DECLARE_VALUE_AND_TYPE_GETTERS(type_param, field)          \
-  /** Gets the value of type field. Throws if value is not field*/ \
-  type_param &Value##field();                                      \
-  /** Gets the value of type field. Throws if value is not field*/ \
-  const type_param &Value##field() const;                          \
-  /** Checks if it's the value is of the given type */             \
-  bool Is##field() const;
-
-  DECLARE_VALUE_AND_TYPE_GETTERS(bool, Bool)
-  DECLARE_VALUE_AND_TYPE_GETTERS(int64_t, Int)
-  DECLARE_VALUE_AND_TYPE_GETTERS(double, Double)
-  DECLARE_VALUE_AND_TYPE_GETTERS(TString, String)
-
-  /**
-   * Get the list value.
-   * @throw TypedValueException if stored value is not a list.
-   */
-  TVector &ValueList();
-
-  const TVector &ValueList() const;
-
-  /** Check if the stored value is a list value */
-  bool IsList() const;
-
-  DECLARE_VALUE_AND_TYPE_GETTERS(TMap, Map)
-  DECLARE_VALUE_AND_TYPE_GETTERS(VertexAccessor, Vertex)
-  DECLARE_VALUE_AND_TYPE_GETTERS(EdgeAccessor, Edge)
-  DECLARE_VALUE_AND_TYPE_GETTERS(Path, Path)
-
-  DECLARE_VALUE_AND_TYPE_GETTERS(utils::Date, Date)
-  DECLARE_VALUE_AND_TYPE_GETTERS(utils::LocalTime, LocalTime)
-  DECLARE_VALUE_AND_TYPE_GETTERS(utils::LocalDateTime, LocalDateTime)
-  DECLARE_VALUE_AND_TYPE_GETTERS(utils::Duration, Duration)
-
-#undef DECLARE_VALUE_AND_TYPE_GETTERS
-
-  /**  Checks if value is a TypedValue::Null. */
-  bool IsNull() const;
-
-  /** Convenience function for checking if this TypedValue is either
-   * an integer or double */
-  bool IsNumeric() const;
-
-  /** Convenience function for checking if this TypedValue can be converted into
-   * storage::v3::PropertyValue */
-  bool IsPropertyValue() const;
-
-  utils::MemoryResource *GetMemoryResource() const { return memory_; }
-
- private:
-  void DestroyValue();
-
-  // Memory resource for allocations of non primitive values
-  utils::MemoryResource *memory_{utils::NewDeleteResource()};
-
-  // storage for the value of the property
-  union {
-    bool bool_v;
-    int64_t int_v;
-    double double_v;
-    // Since this is used in query runtime, size of union is not critical so
-    // string and vector are used instead of pointers. It requires copy of data,
-    // but most of algorithms (concatenations, serialisation...) has linear time
-    // complexity so it shouldn't be a problem. This is maybe even faster
-    // because of data locality.
-    TString string_v;
-    TVector list_v;
-    TMap map_v;
-    VertexAccessor vertex_v;
-    EdgeAccessor edge_v;
-    Path path_v;
-    utils::Date date_v;
-    utils::LocalTime local_time_v;
-    utils::LocalDateTime local_date_time_v;
-    utils::Duration duration_v;
-  };
-
-  /**
-   * The Type of property.
-   */
-  Type type_;
-};
-
-/**
- * An exception raised by the TypedValue system. Typically when
- * trying to perform operations (such as addition) on TypedValues
- * of incompatible Types.
- */
-class TypedValueException : public utils::BasicException {
- public:
-  using utils::BasicException::BasicException;
-};
-
-// binary bool operators
-
-/**
- * Perform logical 'and' on TypedValues.
- *
- * If any of the values is false, return false. Otherwise checks if any value is
- * Null and return Null. All other cases return true. The resulting value uses
- * the same MemoryResource as the left hand side arguments.
- *
- * @throw TypedValueException if arguments are not boolean or Null.
- */
-TypedValue operator&&(const TypedValue &a, const TypedValue &b);
-
-/**
- * Perform logical 'or' on TypedValues.
- *
- * If any of the values is true, return true. Otherwise checks if any value is
- * Null and return Null. All other cases return false. The resulting value uses
- * the same MemoryResource as the left hand side arguments.
- *
- * @throw TypedValueException if arguments are not boolean or Null.
- */
-TypedValue operator||(const TypedValue &a, const TypedValue &b);
-
-/**
- * Logically negate a TypedValue.
- *
- * Negating Null value returns Null. Values other than null raise an exception.
- * The resulting value uses the same MemoryResource as the argument.
- *
- * @throw TypedValueException if TypedValue is not a boolean or Null.
- */
-TypedValue operator!(const TypedValue &a);
-
-// binary bool xor, not power operator
-// Be careful: since ^ is binary operator and || and && are logical operators
-// they have different priority in c++.
-TypedValue operator^(const TypedValue &a, const TypedValue &b);
-
-// comparison operators
-
-/**
- * Compare TypedValues and return true, false or Null.
- *
- * Null is returned if either of the two values is Null.
- * Since each TypedValue may have a different MemoryResource for allocations,
- * the results is allocated using MemoryResource obtained from the left hand
- * side.
- */
-TypedValue operator==(const TypedValue &a, const TypedValue &b);
-
-/**
- * Compare TypedValues and return true, false or Null.
- *
- * Null is returned if either of the two values is Null.
- * Since each TypedValue may have a different MemoryResource for allocations,
- * the results is allocated using MemoryResource obtained from the left hand
- * side.
- */
-inline TypedValue operator!=(const TypedValue &a, const TypedValue &b) { return !(a == b); }
-
-/**
- * Compare TypedValues and return true, false or Null.
- *
- * Null is returned if either of the two values is Null.
- * The resulting value uses the same MemoryResource as the left hand side
- * argument.
- *
- * @throw TypedValueException if the values cannot be compared, i.e. they are
- *        not either Null, numeric or a character string type.
- */
-TypedValue operator<(const TypedValue &a, const TypedValue &b);
-
-/**
- * Compare TypedValues and return true, false or Null.
- *
- * Null is returned if either of the two values is Null.
- * The resulting value uses the same MemoryResource as the left hand side
- * argument.
- *
- * @throw TypedValueException if the values cannot be compared, i.e. they are
- *        not either Null, numeric or a character string type.
- */
-inline TypedValue operator<=(const TypedValue &a, const TypedValue &b) { return a < b || a == b; }
-
-/**
- * Compare TypedValues and return true, false or Null.
- *
- * Null is returned if either of the two values is Null.
- * The resulting value uses the same MemoryResource as the left hand side
- * argument.
- *
- * @throw TypedValueException if the values cannot be compared, i.e. they are
- *        not either Null, numeric or a character string type.
- */
-inline TypedValue operator>(const TypedValue &a, const TypedValue &b) { return !(a <= b); }
-
-/**
- * Compare TypedValues and return true, false or Null.
- *
- * Null is returned if either of the two values is Null.
- * The resulting value uses the same MemoryResource as the left hand side
- * argument.
- *
- * @throw TypedValueException if the values cannot be compared, i.e. they are
- *        not either Null, numeric or a character string type.
- */
-inline TypedValue operator>=(const TypedValue &a, const TypedValue &b) { return !(a < b); }
-
-// arithmetic operators
-
-/**
- * Arithmetically negate a value.
- *
- * If the value is Null, then Null is returned.
- * The resulting value uses the same MemoryResource as the argument.
- *
- * @throw TypedValueException if the value is not numeric or Null.
- */
-TypedValue operator-(const TypedValue &a);
-
-/**
- * Apply the unary plus operator to a value.
- *
- * If the value is Null, then Null is returned.
- * The resulting value uses the same MemoryResource as the argument.
- *
- * @throw TypedValueException if the value is not numeric or Null.
- */
-TypedValue operator+(const TypedValue &a);
-
-/**
- * Perform addition or concatenation on two values.
- *
- * Numeric values are summed, while lists and character strings are
- * concatenated. If either value is Null, then Null is returned. The resulting
- * value uses the same MemoryResource as the left hand side argument.
- *
- * @throw TypedValueException if values cannot be summed or concatenated.
- */
-TypedValue operator+(const TypedValue &a, const TypedValue &b);
-
-/**
- * Subtract two values.
- *
- * If any of the values is Null, then Null is returned.
- * The resulting value uses the same MemoryResource as the left hand side
- * argument.
- *
- * @throw TypedValueException if the values are not numeric or Null.
- */
-TypedValue operator-(const TypedValue &a, const TypedValue &b);
-
-/**
- * Divide two values.
- *
- * If any of the values is Null, then Null is returned.
- * The resulting value uses the same MemoryResource as the left hand side
- * argument.
- *
- * @throw TypedValueException if the values are not numeric or Null, or if
- *        dividing two integer values by zero.
- */
-TypedValue operator/(const TypedValue &a, const TypedValue &b);
-
-/**
- * Multiply two values.
- *
- * If any of the values is Null, then Null is returned.
- * The resulting value uses the same MemoryResource as the left hand side
- * argument.
- *
- * @throw TypedValueException if the values are not numeric or Null.
- */
-TypedValue operator*(const TypedValue &a, const TypedValue &b);
-
-/**
- * Perform modulo operation on two values.
- *
- * If any of the values is Null, then Null is returned.
- * The resulting value uses the same MemoryResource as the left hand side
- * argument.
- *
- * @throw TypedValueException if the values are not numeric or Null.
- */
-TypedValue operator%(const TypedValue &a, const TypedValue &b);
-
-/** Output the TypedValue::Type value as a string */
-std::ostream &operator<<(std::ostream &os, const TypedValue::Type &type);
-
-}  // namespace memgraph::query::v2

src/storage/v3/CMakeLists.txt

@@ -37,4 +37,4 @@ add_library(mg-storage-v3 STATIC ${storage_v3_src_files})
 target_link_libraries(mg-storage-v3 Threads::Threads mg-utils gflags)
 
 add_dependencies(mg-storage-v3 generate_lcp_storage)
-target_link_libraries(mg-storage-v3 mg-rpc mg-slk)
+target_link_libraries(mg-storage-v3 mg-rpc mg-slk mg-expr)

src/storage/v3/conversions.hpp

@@ -0,0 +1,116 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "expr/typed_value.hpp"
+#include "storage/v3/property_value.hpp"
+
+#pragma once
+
+namespace memgraph::storage::v3 {
+
+template <typename TTypedValue>
+TTypedValue PropertyToTypedValue(const PropertyValue &value) {
+  switch (value.type()) {
+    case storage::v3::PropertyValue::Type::Null:
+      return TTypedValue();
+    case storage::v3::PropertyValue::Type::Bool:
+      return TTypedValue(value.ValueBool());
+    case storage::v3::PropertyValue::Type::Int:
+      return TTypedValue(value.ValueInt());
+    case storage::v3::PropertyValue::Type::Double:
+      return TTypedValue(value.ValueDouble());
+    case storage::v3::PropertyValue::Type::String:
+      return TTypedValue(value.ValueString());
+    case storage::v3::PropertyValue::Type::List: {
+      const auto &src = value.ValueList();
+      std::vector<TTypedValue> dst;
+      dst.reserve(src.size());
+      for (const auto &elem : src) {
+        dst.push_back(PropertyToTypedValue<TTypedValue>(elem));
+      }
+      return TTypedValue(std::move(dst));
+    }
+    case storage::v3::PropertyValue::Type::Map: {
+      const auto &src = value.ValueMap();
+      std::map<std::string, TTypedValue> dst;
+      for (const auto &elem : src) {
+        dst.insert({std::string(elem.first), PropertyToTypedValue<TTypedValue>(elem.second)});
+      }
+      return TTypedValue(std::move(dst));
+    }
+    case storage::v3::PropertyValue::Type::TemporalData: {
+      const auto &temporal_data = value.ValueTemporalData();
+      switch (temporal_data.type) {
+        case storage::v3::TemporalType::Date: {
+          return TTypedValue(utils::Date(temporal_data.microseconds));
+        }
+        case storage::v3::TemporalType::LocalTime: {
+          return TTypedValue(utils::LocalTime(temporal_data.microseconds));
+        }
+        case storage::v3::TemporalType::LocalDateTime: {
+          return TTypedValue(utils::LocalDateTime(temporal_data.microseconds));
+        }
+        case storage::v3::TemporalType::Duration: {
+          return TTypedValue(utils::Duration(temporal_data.microseconds));
+        }
+      }
+    }
+  }
+  LOG_FATAL("Unsupported type");
+}
+
+template <typename TTypedValue>
+storage::v3::PropertyValue TypedToPropertyValue(const TTypedValue &value) {
+  switch (value.type()) {
+    case TTypedValue::Type::Null:
+      return storage::v3::PropertyValue{};
+    case TTypedValue::Type::Bool:
+      return storage::v3::PropertyValue(value.ValueBool());
+    case TTypedValue::Type::Int:
+      return storage::v3::PropertyValue(value.ValueInt());
+    case TTypedValue::Type::Double:
+      return storage::v3::PropertyValue(value.ValueDouble());
+    case TTypedValue::Type::String:
+      return storage::v3::PropertyValue(std::string(value.ValueString()));
+    case TTypedValue::Type::List: {
+      const auto &src = value.ValueList();
+      std::vector<storage::v3::PropertyValue> dst;
+      dst.reserve(src.size());
+      std::transform(src.begin(), src.end(), std::back_inserter(dst),
+                     [](const auto &val) { return TypedToPropertyValue(val); });
+      return storage::v3::PropertyValue(std::move(dst));
+    }
+    case TTypedValue::Type::Map: {
+      const auto &src = value.ValueMap();
+      std::map<std::string, storage::v3::PropertyValue> dst;
+      for (const auto &elem : src) {
+        dst.insert({std::string(elem.first), TypedToPropertyValue(elem.second)});
+      }
+      return storage::v3::PropertyValue(std::move(dst));
+    }
+    case TTypedValue::Type::Date:
+      return storage::v3::PropertyValue(
+          storage::v3::TemporalData{storage::v3::TemporalType::Date, value.ValueDate().MicrosecondsSinceEpoch()});
+    case TTypedValue::Type::LocalTime:
+      return storage::v3::PropertyValue(storage::v3::TemporalData{storage::v3::TemporalType::LocalTime,
+                                                                  value.ValueLocalTime().MicrosecondsSinceEpoch()});
+    case TTypedValue::Type::LocalDateTime:
+      return storage::v3::PropertyValue(storage::v3::TemporalData{storage::v3::TemporalType::LocalDateTime,
+                                                                  value.ValueLocalDateTime().MicrosecondsSinceEpoch()});
+    case TTypedValue::Type::Duration:
+      return storage::v3::PropertyValue(
+          storage::v3::TemporalData{storage::v3::TemporalType::Duration, value.ValueDuration().microseconds});
+    default:
+      break;
+  }
+  throw expr::TypedValueException("Unsupported conversion from TTypedValue to PropertyValue");
+}
+}  // namespace memgraph::storage::v3

tests/unit/CMakeLists.txt

@@ -333,7 +333,7 @@ add_unit_test(query_v2_query_plan_accumulate_aggregate.cpp)
 target_link_libraries(${test_prefix}query_v2_query_plan_accumulate_aggregate mg-query-v2)
 
 add_unit_test(query_v2_query_plan_create_set_remove_delete.cpp)
-target_link_libraries(${test_prefix}query_v2_query_plan_create_set_remove_delete mg-query-v2)
+target_link_libraries(${test_prefix}query_v2_query_plan_create_set_remove_delete mg-query-v2 mg-expr)
 
 add_unit_test(query_v2_query_plan_bag_semantics.cpp)
 target_link_libraries(${test_prefix}query_v2_query_plan_bag_semantics mg-query-v2)

tests/unit/query_v2_interpreter.cpp

@@ -21,11 +21,11 @@
 #include "communication/bolt/v1/value.hpp"
 #include "glue/v2/communication.hpp"
 #include "query/v2/auth_checker.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/config.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/interpreter.hpp"
 #include "query/v2/stream.hpp"
-#include "query/v2/typed_value.hpp"
 #include "query_v2_query_common.hpp"
 #include "result_stream_faker.hpp"
 #include "storage/v3/isolation_level.hpp"
@@ -565,8 +565,10 @@ TEST_F(InterpreterTest, UniqueConstraintTest) {
   ASSERT_NO_THROW(Interpret("CREATE SCHEMA ON :A(a INTEGER);"));
 
   // Empty property list should result with syntax exception.
-  ASSERT_THROW(Interpret("CREATE CONSTRAINT ON (n:A) ASSERT IS UNIQUE;"), memgraph::query::v2::SyntaxException);
-  ASSERT_THROW(Interpret("DROP CONSTRAINT ON (n:A) ASSERT IS UNIQUE;"), memgraph::query::v2::SyntaxException);
+  ASSERT_THROW(Interpret("CREATE CONSTRAINT ON (n:A) ASSERT IS UNIQUE;"),
+               memgraph::frontend::opencypher::SyntaxException);
+  ASSERT_THROW(Interpret("DROP CONSTRAINT ON (n:A) ASSERT IS UNIQUE;"),
+               memgraph::frontend::opencypher::SyntaxException);
 
   // Too large list of properties should also result with syntax exception.
   {
@@ -1083,25 +1085,27 @@ TEST_F(InterpreterTest, LoadCsvClause) {
   }
 }
 
-TEST_F(InterpreterTest, CacheableQueries) {
-  const auto &interpreter_context = default_interpreter.interpreter_context;
-  // This should be cached
-  {
-    SCOPED_TRACE("Cacheable query");
-    Interpret("RETURN 1");
-    EXPECT_EQ(interpreter_context.ast_cache.size(), 1U);
-    EXPECT_EQ(interpreter_context.plan_cache.size(), 1U);
-  }
-
-  {
-    SCOPED_TRACE("Uncacheable query");
-    // Queries which are calling procedure should not be cached because the
-    // result signature could be changed
-    Interpret("CALL mg.load_all()");
-    EXPECT_EQ(interpreter_context.ast_cache.size(), 1U);
-    EXPECT_EQ(interpreter_context.plan_cache.size(), 1U);
-  }
-}
+// TODO(kostasrim)
+// Fix this when we support modules for distributed
+// TEST_F(InterpreterTest, CacheableQueries) {
+//   const auto &interpreter_context = default_interpreter.interpreter_context;
+//   // This should be cached
+//   {
+//     SCOPED_TRACE("Cacheable query");
+//     Interpret("RETURN 1");
+//     EXPECT_EQ(interpreter_context.ast_cache.size(), 1U);
+//     EXPECT_EQ(interpreter_context.plan_cache.size(), 1U);
+//   }
+//
+//   {
+//     SCOPED_TRACE("Uncacheable query");
+//     // Queries which are calling procedure should not be cached because the
+//     // result signature could be changed
+//     Interpret("CALL mg.load_all()");
+//     EXPECT_EQ(interpreter_context.ast_cache.size(), 1U);
+//     EXPECT_EQ(interpreter_context.plan_cache.size(), 1U);
+//   }
+// }
 
 TEST_F(InterpreterTest, AllowLoadCsvConfig) {
   const auto check_load_csv_queries = [&](const bool allow_load_csv) {
@@ -1528,12 +1532,11 @@ TEST_F(InterpreterTest, DropSchemaMulticommandTransaction) {
 
 TEST_F(InterpreterTest, SchemaTestCreateAndShow) {
   // Empty schema type map should result with syntax exception.
-  ASSERT_THROW(Interpret("CREATE SCHEMA ON :label();"), memgraph::query::v2::SyntaxException);
+  ASSERT_THROW(Interpret("CREATE SCHEMA ON :label();"), memgraph::frontend::opencypher::SyntaxException);
 
   // Duplicate properties are should also cause an exception
-  ASSERT_THROW(Interpret("CREATE SCHEMA ON :label(name STRING, name STRING);"), memgraph::query::v2::SemanticException);
-  ASSERT_THROW(Interpret("CREATE SCHEMA ON :label(name STRING, name INTEGER);"),
-               memgraph::query::v2::SemanticException);
+  ASSERT_THROW(Interpret("CREATE SCHEMA ON :label(name STRING, name STRING);"), memgraph::expr::SemanticException);
+  ASSERT_THROW(Interpret("CREATE SCHEMA ON :label(name STRING, name INTEGER);"), memgraph::expr::SemanticException);
 
   {
     // Cannot create same schema twice
@@ -1597,7 +1600,7 @@ TEST_F(InterpreterTest, SchemaTestCreateAndShow) {
 TEST_F(InterpreterTest, SchemaTestCreateDropAndShow) {
   Interpret("CREATE SCHEMA ON :label(name STRING, age INTEGER)");
   // Wrong syntax for dropping schema.
-  ASSERT_THROW(Interpret("DROP SCHEMA ON :label();"), memgraph::query::v2::SyntaxException);
+  ASSERT_THROW(Interpret("DROP SCHEMA ON :label();"), memgraph::frontend::opencypher::SyntaxException);
   // Cannot drop non existant schema.
   ASSERT_THROW(Interpret("DROP SCHEMA ON :label1;"), memgraph::query::v2::QueryException);
 

tests/unit/query_v2_query_common.hpp

@@ -41,8 +41,9 @@
 #include <utility>
 #include <vector>
 
+#include "query/v2/bindings/pretty_print.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/ast/pretty_print.hpp"
 #include "storage/v3/id_types.hpp"
 #include "utils/string.hpp"
 
@@ -66,13 +67,13 @@ auto ToIntMap(const TypedValue &t) {
 
 std::string ToString(Expression *expr) {
   std::ostringstream ss;
-  PrintExpression(expr, &ss);
+  expr::PrintExpression(expr, &ss);
   return ss.str();
 }
 
 std::string ToString(NamedExpression *expr) {
   std::ostringstream ss;
-  PrintExpression(expr, &ss);
+  expr::PrintExpression(expr, &ss);
   return ss.str();
 }
 

tests/unit/query_v2_query_plan_accumulate_aggregate.cpp

@@ -22,6 +22,7 @@
 #include "query/v2/exceptions.hpp"
 #include "query/v2/plan/operator.hpp"
 #include "query_v2_query_plan_common.hpp"
+#include "storage/v3/conversions.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/schemas.hpp"
 
@@ -358,7 +359,7 @@ TEST_F(QueryPlanAccumulateAggregateTest, AggregateGroupByValues) {
   ASSERT_EQ(result_group_bys.size(), group_by_vals.size() - 2);
   std::vector<TypedValue> group_by_tvals;
   group_by_tvals.reserve(group_by_vals.size());
-  for (const auto &v : group_by_vals) group_by_tvals.emplace_back(v);
+  for (const auto &v : group_by_vals) group_by_tvals.emplace_back(storage::v3::PropertyToTypedValue<TypedValue>(v));
   EXPECT_TRUE(std::is_permutation(group_by_tvals.begin(), group_by_tvals.end() - 2, result_group_bys.begin(),
                                   TypedValue::BoolEqual{}));
 }
@@ -599,11 +600,9 @@ TEST(QueryPlan, Unwind) {
   SymbolTable symbol_table;
 
   // UNWIND [ [1, true, "x"], [], ["bla"] ] AS x UNWIND x as y RETURN x, y
-  auto input_expr = storage.Create<PrimitiveLiteral>(std::vector<storage::v3::PropertyValue>{
-      storage::v3::PropertyValue(std::vector<storage::v3::PropertyValue>{
-          storage::v3::PropertyValue(1), storage::v3::PropertyValue(true), storage::v3::PropertyValue("x")}),
-      storage::v3::PropertyValue(std::vector<storage::v3::PropertyValue>{}),
-      storage::v3::PropertyValue(std::vector<storage::v3::PropertyValue>{storage::v3::PropertyValue("bla")})});
+  auto input_expr = storage.Create<PrimitiveLiteral>(std::vector<TypedValue>{
+      TypedValue(std::vector<TypedValue>{TypedValue(1), TypedValue(true), TypedValue("x")}),
+      TypedValue(std::vector<TypedValue>{}), TypedValue(std::vector<TypedValue>{TypedValue("bla")})});
 
   auto x = symbol_table.CreateSymbol("x", true);
   auto unwind_0 = std::make_shared<plan::Unwind>(nullptr, input_expr, x);

tests/unit/query_v2_query_plan_bag_semantics.cpp

@@ -23,6 +23,7 @@
 #include "query/v2/plan/operator.hpp"
 
 #include "query_v2_query_plan_common.hpp"
+#include "storage/v3/conversions.hpp"
 #include "storage/v3/property_value.hpp"
 
 using namespace memgraph::query::v2;
@@ -165,7 +166,7 @@ TEST_F(QueryPlanBagSemanticsTest, OrderBy) {
   for (const auto &order_value_pair : orderable) {
     std::vector<TypedValue> values;
     values.reserve(order_value_pair.second.size());
-    for (const auto &v : order_value_pair.second) values.emplace_back(v);
+    for (const auto &v : order_value_pair.second) values.emplace_back(storage::v3::PropertyToTypedValue<TypedValue>(v));
     // empty database
     for (auto vertex : dba.Vertices(storage::v3::View::OLD)) ASSERT_TRUE(dba.DetachRemoveVertex(&vertex).HasValue());
     dba.AdvanceCommand();
@@ -186,7 +187,7 @@ TEST_F(QueryPlanBagSemanticsTest, OrderBy) {
     // create the vertices
     for (const auto &value : shuffled) {
       ASSERT_TRUE(dba.InsertVertexAndValidate(label, {}, {{property, storage::v3::PropertyValue(1)}})
-                      ->SetProperty(prop, storage::v3::PropertyValue(value))
+                      ->SetProperty(prop, storage::v3::TypedToPropertyValue(value))
                       .HasValue());
     }
     dba.AdvanceCommand();

tests/unit/query_v2_query_plan_common.hpp

@@ -15,11 +15,11 @@
 #include <memory>
 #include <vector>
 
+#include "query/v2/bindings/frame.hpp"
+#include "query/v2/bindings/symbol_table.hpp"
 #include "query/v2/common.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/db_accessor.hpp"
-#include "query/v2/frontend/semantic/symbol_table.hpp"
-#include "query/v2/interpret/frame.hpp"
 #include "query/v2/plan/operator.hpp"
 #include "storage/v3/storage.hpp"
 #include "utils/logging.hpp"

tests/unit/query_v2_query_plan_create_set_remove_delete.cpp

@@ -18,13 +18,15 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+#include "query/v2/bindings/frame.hpp"
+#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
-#include "query/v2/interpret/frame.hpp"
 #include "query/v2/plan/operator.hpp"
 
 #include "query_v2_query_plan_common.hpp"
+#include "storage/v3/conversions.hpp"
 #include "storage/v3/id_types.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/schemas.hpp"
@@ -81,7 +83,7 @@ TEST_F(QueryPlanCRUDTest, CreateNodeWithAttributes) {
     EXPECT_EQ(properties.size(), 1);
     auto maybe_prop = vertex.GetProperty(storage::v3::View::OLD, property);
     ASSERT_TRUE(maybe_prop.HasValue());
-    auto prop_eq = TypedValue(*maybe_prop) == TypedValue(42);
+    auto prop_eq = storage::v3::PropertyToTypedValue<TypedValue>(*maybe_prop) == TypedValue(42);
     ASSERT_EQ(prop_eq.type(), TypedValue::Type::Bool);
     EXPECT_TRUE(prop_eq.ValueBool());
   }
@@ -436,7 +438,7 @@ TEST_F(QueryPlanCRUDTest, DeleteReturn) {
   auto produce = MakeProduce(delete_op, n_p);
 
   auto context = MakeContext(storage, symbol_table, &dba);
-  ASSERT_THROW(CollectProduce(*produce, &context), QueryRuntimeException);
+  ASSERT_THROW(CollectProduce(*produce, &context), memgraph::expr::ExpressionRuntimeException);
 }
 
 TEST(QueryPlan, DeleteNull) {
@@ -484,7 +486,7 @@ TEST_F(QueryPlanCRUDTest, DeleteAdvance) {
     auto n_prop = PROPERTY_LOOKUP(n_get, dba.NameToProperty("prop"));
     auto produce = MakeProduce(advance, NEXPR("res", n_prop)->MapTo(res_sym));
     auto context = MakeContext(storage, symbol_table, &dba);
-    EXPECT_THROW(PullAll(*produce, &context), QueryRuntimeException);
+    EXPECT_THROW(PullAll(*produce, &context), memgraph::expr::ExpressionRuntimeException);
   }
 }
 
@@ -768,7 +770,8 @@ TEST_F(QueryPlanCRUDTest, NodeFilterSet) {
   auto context = MakeContext(storage, symbol_table, &dba);
   EXPECT_EQ(2, PullAll(*set, &context));
   dba.AdvanceCommand();
-  auto prop_eq = TypedValue(*v1.GetProperty(storage::v3::View::OLD, prop.second)) == TypedValue(42 + 2);
+  auto prop_eq = storage::v3::PropertyToTypedValue<TypedValue>(*v1.GetProperty(storage::v3::View::OLD, prop.second)) ==
+                 TypedValue(42 + 2);
   ASSERT_EQ(prop_eq.type(), TypedValue::Type::Bool);
   EXPECT_TRUE(prop_eq.ValueBool());
 }

tests/unit/query_v2_query_plan_match_filter_return.cpp

@@ -24,16 +24,20 @@
 #include <cppitertools/range.hpp>
 #include <cppitertools/repeat.hpp>
 
+#include "expr/typed_value.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/plan/operator.hpp"
 #include "query_v2_query_common.hpp"
+#include "storage/v3/conversions.hpp"
 #include "storage/v3/property_value.hpp"
 
 #include "query_v2_query_plan_common.hpp"
 
 using namespace memgraph::query::v2;
 using namespace memgraph::query::v2::plan;
+using memgraph::storage::v3::PropertyToTypedValue;
+using memgraph::storage::v3::TypedToPropertyValue;
 
 namespace std {
 template <>
@@ -1726,8 +1730,8 @@ TEST_F(QueryPlanMatchFilterTest, ScanAllByLabelProperty) {
     auto results = run_scan_all(lower, lower_type, upper, upper_type);
     ASSERT_EQ(results.size(), expected.size());
     for (size_t i = 0; i < expected.size(); i++) {
-      TypedValue equal =
-          TypedValue(*results[i][0].ValueVertex().GetProperty(storage::v3::View::OLD, prop)) == expected[i];
+      TypedValue equal = PropertyToTypedValue<TypedValue>(
+                             *results[i][0].ValueVertex().GetProperty(storage::v3::View::OLD, prop)) == expected[i];
       ASSERT_EQ(equal.type(), TypedValue::Type::Bool);
       EXPECT_TRUE(equal.ValueBool());
     }
@@ -1759,11 +1763,12 @@ TEST_F(QueryPlanMatchFilterTest, ScanAllByLabelProperty) {
                          static_cast<storage::v3::PropertyValue>(value_b).type()))
         continue;
       if (is_orderable(value_a) && is_orderable(value_b)) {
-        check(TypedValue(value_a), Bound::Type::INCLUSIVE, TypedValue(value_b), Bound::Type::INCLUSIVE, {});
+        check(PropertyToTypedValue<TypedValue>(value_a), Bound::Type::INCLUSIVE,
+              PropertyToTypedValue<TypedValue>(value_b), Bound::Type::INCLUSIVE, {});
       } else {
-        EXPECT_THROW(
-            run_scan_all(TypedValue(value_a), Bound::Type::INCLUSIVE, TypedValue(value_b), Bound::Type::INCLUSIVE),
-            QueryRuntimeException);
+        EXPECT_THROW(run_scan_all(PropertyToTypedValue<TypedValue>(value_a), Bound::Type::INCLUSIVE,
+                                  PropertyToTypedValue<TypedValue>(value_b), Bound::Type::INCLUSIVE),
+                     QueryRuntimeException);
       }
     }
   }
@@ -1812,7 +1817,7 @@ TEST_F(QueryPlanMatchFilterTest, ScanAllByLabelPropertyEqualityNoError) {
   const auto &row = results[0];
   ASSERT_EQ(row.size(), 1);
   auto vertex = row[0].ValueVertex();
-  TypedValue value(*vertex.GetProperty(storage::v3::View::OLD, prop));
+  TypedValue value = PropertyToTypedValue<TypedValue>(*vertex.GetProperty(storage::v3::View::OLD, prop));
   TypedValue::BoolEqual eq;
   EXPECT_TRUE(eq(value, TypedValue(42)));
 }
@@ -1844,7 +1849,7 @@ TEST_F(QueryPlanMatchFilterTest, ScanAllByLabelPropertyValueError) {
   auto scan_index =
       MakeScanAllByLabelPropertyValue(storage, symbol_table, "n", label1, prop, "prop", ident_m, scan_all.op_);
   auto context = MakeContext(storage, symbol_table, &dba);
-  EXPECT_THROW(PullAll(*scan_index.op_, &context), QueryRuntimeException);
+  EXPECT_THROW(PullAll(*scan_index.op_, &context), memgraph::expr::TypedValueException);
 }
 
 TEST_F(QueryPlanMatchFilterTest, ScanAllByLabelPropertyRangeError) {

tests/unit/query_v2_query_plan_v2_create_set_remove_delete.cpp

@@ -11,7 +11,7 @@
 
 #include <gtest/gtest.h>
 
-#include "query/v2/frontend/semantic/symbol_table.hpp"
+#include "query/v2/bindings/symbol_table.hpp"
 #include "query/v2/plan/operator.hpp"
 #include "query_v2_query_plan_common.hpp"
 #include "storage/v3/property_value.hpp"

tests/unit/query_v2_query_required_privileges.cpp

@@ -12,8 +12,8 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "query/v2/bindings/ast_visitor.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/frontend/ast/ast_visitor.hpp"
 #include "query/v2/frontend/semantic/required_privileges.hpp"
 #include "storage/v3/id_types.hpp"
 

tests/unit/result_stream_faker.hpp

@@ -14,7 +14,8 @@
 #include <map>
 
 #include "glue/v2/communication.hpp"
-#include "query/v2/typed_value.hpp"
+#include "query/v2/bindings/typed_value.hpp"
+
 #include "storage/v3/storage.hpp"
 #include "utils/algorithm.hpp"