From 5f7837d6134b33d96a6cca5e2bd702b724ac3e7d Mon Sep 17 00:00:00 2001
From: Teon Banek <teon.banek@memgraph.io>
Date: Wed, 20 Dec 2017 11:24:48 +0100
Subject: [PATCH] Serialize Ast classes

Summary:
Although the first solution used cereal, the final implementation uses
boost. Since the cereal is still used in the codebase, compilation has
been modified to support multithreaded cereal.

In addition to serializing Ast classes, the following also needed to be
serialized:

  * GraphDbTypes
  * Symbol
  * TypedValue

TypedValue is treated specially, by inlining the serialization code in
the Ast class, concretely PrimitiveLiteral.

Another special case was the Function Ast class, which now stores a
function name which is resolved to a concrete std::function on
construction.

Tests have been added for serialized Ast in
tests/unit/cypher_main_visitor

Reviewers: mferencevic, mislav.bradac, florijan

Reviewed By: mislav.bradac

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D1067
---
 CMakeLists.txt                                |    3 +
 init                                          |    4 +
 libs/CMakeLists.txt                           |    3 +
 src/CMakeLists.txt                            |    2 +-
 src/database/graph_db_datatypes.hpp           |   52 +
 src/query/frontend/ast/ast.cpp                |  138 ++
 src/query/frontend/ast/ast.hpp                | 1358 ++++++++++++++++-
 .../frontend/ast/cypher_main_visitor.cpp      |   17 +-
 src/query/frontend/semantic/symbol.hpp        |   11 +
 src/query/interpret/eval.hpp                  |    2 +-
 tests/unit/cypher_main_visitor.cpp            |   35 +-
 tests/unit/query_common.hpp                   |    6 +-
 tests/unit/query_expression_evaluator.cpp     |    3 +-
 13 files changed, 1591 insertions(+), 43 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a12a61721..1fddb3cb2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -128,6 +128,9 @@ if (USE_READLINE)
   endif()
 endif()
 
+set(Boost_USE_STATIC_LIBS ON)
+find_package(Boost REQUIRED COMPONENTS serialization)
+
 set(libs_dir ${CMAKE_SOURCE_DIR}/libs)
 add_subdirectory(libs EXCLUDE_FROM_ALL)
 
diff --git a/init b/init
index d65133386..23a31a1f0 100755
--- a/init
+++ b/init
@@ -1,10 +1,14 @@
 #!/bin/bash -e
 
+# TODO: Consider putting boost library in libs/setup.sh, since the license
+# allows source modification and static compilation. Unfortunately, it is quite
+# a pain to set up the boost build process.
 required_pkgs=(git arcanist # source code control
                cmake clang-3.8 llvm-3.8 pkg-config # build system
                curl wget # for downloading libs
                uuid-dev default-jre-headless # required by antlr
                libreadline-dev # for memgraph console
+               libboost-serialization-dev
                python3 python-virtualenv python3-pip # for qa, macro_benchmark and stress tests
               )
 
diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt
index 0d4dca5d3..59ac57995 100644
--- a/libs/CMakeLists.txt
+++ b/libs/CMakeLists.txt
@@ -167,3 +167,6 @@ import_header_library(json ${CMAKE_CURRENT_SOURCE_DIR})
 
 # Setup cereal
 import_header_library(cereal "${CMAKE_CURRENT_SOURCE_DIR}/cereal/include")
+# Make cereal multithreaded by passing -DCEREAL_THREAD_SAFE=1 (note that -D is omitted below).
+set_property(TARGET cereal PROPERTY
+             INTERFACE_COMPILE_DEFINITIONS CEREAL_THREAD_SAFE=1)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f5b7859d8..4028355d4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -54,7 +54,7 @@ set(memgraph_src_files
 
 # memgraph_lib depend on these libraries
 set(MEMGRAPH_ALL_LIBS stdc++fs Threads::Threads fmt cppitertools cereal
-    antlr_opencypher_parser_lib dl glog gflags)
+    antlr_opencypher_parser_lib dl glog gflags Boost::serialization)
 
 if (USE_LTALLOC)
     list(APPEND MEMGRAPH_ALL_LIBS ltalloc)
diff --git a/src/database/graph_db_datatypes.hpp b/src/database/graph_db_datatypes.hpp
index aadbf6d6d..b53deb3cf 100644
--- a/src/database/graph_db_datatypes.hpp
+++ b/src/database/graph_db_datatypes.hpp
@@ -2,6 +2,9 @@
 
 #include <string>
 
+#include "boost/serialization/base_object.hpp"
+#include "cereal/types/base_class.hpp"
+
 #include "utils/total_ordering.hpp"
 
 namespace GraphDbTypes {
@@ -33,18 +36,67 @@ class Common : TotalOrdering<TSpecificType> {
 
  private:
   StorageT storage_{0};
+
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & storage_;
+  }
 };
 
 class Label : public Common<Label> {
   using Common::Common;
+
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & boost::serialization::base_object<Common<Label>>(*this);
+  }
+
+ public:
+  /** Required for cereal serialization. */
+  template <class Archive>
+  void serialize(Archive &archive) {
+    archive(cereal::base_class<Common<Label>>(this));
+  }
 };
 
 class EdgeType : public Common<EdgeType> {
   using Common::Common;
+
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & boost::serialization::base_object<Common<EdgeType>>(*this);
+  }
+
+ public:
+  /** Required for cereal serialization. */
+  template <class Archive>
+  void serialize(Archive &archive) {
+    archive(cereal::base_class<Common<EdgeType>>(this));
+  }
 };
 
 class Property : public Common<Property> {
   using Common::Common;
+
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & boost::serialization::base_object<Common<Property>>(*this);
+  }
+
+ public:
+  /** Required for cereal serialization. */
+  template <class Archive>
+  void serialize(Archive &archive) {
+    archive(cereal::base_class<Common<Property>>(this));
+  }
 };
 
 };  // namespace GraphDbTypes
diff --git a/src/query/frontend/ast/ast.cpp b/src/query/frontend/ast/ast.cpp
index 52aa3783e..11ac537ec 100644
--- a/src/query/frontend/ast/ast.cpp
+++ b/src/query/frontend/ast/ast.cpp
@@ -10,6 +10,14 @@ Query *AstTreeStorage::query() const {
   return dynamic_cast<Query *>(storage_[0].get());
 }
 
+int AstTreeStorage::MaximumStorageUid() const {
+  int max_uid = -1;
+  for (const auto &tree : storage_) {
+    max_uid = std::max(max_uid, tree->uid());
+  }
+  return max_uid;
+}
+
 ReturnBody CloneReturnBody(AstTreeStorage &storage, const ReturnBody &body) {
   ReturnBody new_body;
   new_body.distinct = body.distinct;
@@ -26,3 +34,133 @@ ReturnBody CloneReturnBody(AstTreeStorage &storage, const ReturnBody &body) {
 }
 
 }  // namespace query
+
+#define LOAD_AND_CONSTRUCT(DerivedClass, ...)               \
+  template <class TArchive>                                 \
+  void load_construct_data(TArchive &ar, DerivedClass *cls, \
+                           const unsigned int) {            \
+    ::new (cls) DerivedClass(__VA_ARGS__);                  \
+  }
+
+// All of the serialization cruft follows
+
+namespace boost::serialization {
+LOAD_AND_CONSTRUCT(query::Where, 0);
+LOAD_AND_CONSTRUCT(query::OrOperator, 0);
+LOAD_AND_CONSTRUCT(query::XorOperator, 0);
+LOAD_AND_CONSTRUCT(query::AndOperator, 0);
+LOAD_AND_CONSTRUCT(query::AdditionOperator, 0);
+LOAD_AND_CONSTRUCT(query::SubtractionOperator, 0);
+LOAD_AND_CONSTRUCT(query::MultiplicationOperator, 0);
+LOAD_AND_CONSTRUCT(query::DivisionOperator, 0);
+LOAD_AND_CONSTRUCT(query::ModOperator, 0);
+LOAD_AND_CONSTRUCT(query::NotEqualOperator, 0);
+LOAD_AND_CONSTRUCT(query::EqualOperator, 0);
+LOAD_AND_CONSTRUCT(query::LessOperator, 0);
+LOAD_AND_CONSTRUCT(query::GreaterOperator, 0);
+LOAD_AND_CONSTRUCT(query::LessEqualOperator, 0);
+LOAD_AND_CONSTRUCT(query::GreaterEqualOperator, 0);
+LOAD_AND_CONSTRUCT(query::InListOperator, 0);
+LOAD_AND_CONSTRUCT(query::ListMapIndexingOperator, 0);
+LOAD_AND_CONSTRUCT(query::ListSlicingOperator, 0, nullptr, nullptr, nullptr);
+LOAD_AND_CONSTRUCT(query::IfOperator, 0, nullptr, nullptr, nullptr);
+LOAD_AND_CONSTRUCT(query::NotOperator, 0);
+LOAD_AND_CONSTRUCT(query::UnaryPlusOperator, 0);
+LOAD_AND_CONSTRUCT(query::UnaryMinusOperator, 0);
+LOAD_AND_CONSTRUCT(query::IsNullOperator, 0);
+LOAD_AND_CONSTRUCT(query::PrimitiveLiteral, 0);
+LOAD_AND_CONSTRUCT(query::ListLiteral, 0);
+LOAD_AND_CONSTRUCT(query::MapLiteral, 0);
+LOAD_AND_CONSTRUCT(query::Identifier, 0, "");
+LOAD_AND_CONSTRUCT(query::PropertyLookup, 0, nullptr, "",
+                   GraphDbTypes::Property());
+LOAD_AND_CONSTRUCT(query::LabelsTest, 0, nullptr,
+                   std::vector<GraphDbTypes::Label>());
+LOAD_AND_CONSTRUCT(query::Function, 0);
+LOAD_AND_CONSTRUCT(query::Aggregation, 0, nullptr, nullptr,
+                   query::Aggregation::Op::COUNT);
+LOAD_AND_CONSTRUCT(query::All, 0, nullptr, nullptr, nullptr);
+LOAD_AND_CONSTRUCT(query::ParameterLookup, 0);
+LOAD_AND_CONSTRUCT(query::NamedExpression, 0);
+LOAD_AND_CONSTRUCT(query::NodeAtom, 0);
+LOAD_AND_CONSTRUCT(query::EdgeAtom, 0);
+LOAD_AND_CONSTRUCT(query::Pattern, 0);
+LOAD_AND_CONSTRUCT(query::SingleQuery, 0);
+LOAD_AND_CONSTRUCT(query::CypherUnion, 0);
+LOAD_AND_CONSTRUCT(query::Query, 0);
+LOAD_AND_CONSTRUCT(query::Create, 0);
+LOAD_AND_CONSTRUCT(query::Match, 0);
+LOAD_AND_CONSTRUCT(query::Return, 0);
+LOAD_AND_CONSTRUCT(query::With, 0);
+LOAD_AND_CONSTRUCT(query::Delete, 0);
+LOAD_AND_CONSTRUCT(query::SetProperty, 0);
+LOAD_AND_CONSTRUCT(query::SetProperties, 0);
+LOAD_AND_CONSTRUCT(query::SetLabels, 0);
+LOAD_AND_CONSTRUCT(query::RemoveProperty, 0);
+LOAD_AND_CONSTRUCT(query::RemoveLabels, 0);
+LOAD_AND_CONSTRUCT(query::Merge, 0);
+LOAD_AND_CONSTRUCT(query::Unwind, 0);
+LOAD_AND_CONSTRUCT(query::CreateIndex, 0);
+}  // namespace boost::serialization
+
+#undef LOAD_AND_CONSTRUCT
+
+// Include archives before registering most derived types.
+#include "boost/archive/binary_iarchive.hpp"
+#include "boost/archive/binary_oarchive.hpp"
+#include "boost/archive/text_iarchive.hpp"
+#include "boost/archive/text_oarchive.hpp"
+
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Query);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::SingleQuery);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::CypherUnion);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::NamedExpression);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::OrOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::XorOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::AndOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::NotOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::AdditionOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::SubtractionOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::MultiplicationOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::DivisionOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::ModOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::NotEqualOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::EqualOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::LessOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::GreaterOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::LessEqualOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::GreaterEqualOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::InListOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::ListMapIndexingOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::ListSlicingOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::IfOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::UnaryPlusOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::UnaryMinusOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::IsNullOperator);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::ListLiteral);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::MapLiteral);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::PropertyLookup);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::LabelsTest);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Aggregation);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Function);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::All);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::ParameterLookup);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Create);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Match);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Return);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::With);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Pattern);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::NodeAtom);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::EdgeAtom);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Delete);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Where);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::SetProperty);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::SetProperties);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::SetLabels);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::RemoveProperty);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::RemoveLabels);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Merge);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Unwind);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::Identifier);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::PrimitiveLiteral);
+BOOST_CLASS_EXPORT_IMPLEMENT(query::CreateIndex);
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index 2571a348a..850e19bae 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -5,12 +5,18 @@
 #include <unordered_map>
 #include <vector>
 
+#include "boost/serialization/base_object.hpp"
+#include "boost/serialization/export.hpp"
+#include "boost/serialization/split_member.hpp"
+#include "boost/serialization/string.hpp"
+#include "boost/serialization/vector.hpp"
 #include "glog/logging.h"
 
 #include "database/graph_db.hpp"
 #include "database/graph_db_datatypes.hpp"
 #include "query/frontend/ast/ast_visitor.hpp"
 #include "query/frontend/semantic/symbol.hpp"
+#include "query/interpret/awesome_memgraph_functions.hpp"
 #include "query/parameters.hpp"
 #include "query/typed_value.hpp"
 
@@ -33,19 +39,25 @@ namespace query {
 
 #define CLONE_BINARY_EXPRESSION                                              \
   auto Clone(AstTreeStorage &storage) const->std::remove_const<              \
-      std::remove_pointer<decltype(this)>::type>::type * override {          \
+      std::remove_pointer<decltype(this)>::type>::type *override {           \
     return storage.Create<                                                   \
         std::remove_cv<std::remove_reference<decltype(*this)>::type>::type>( \
         expression1_->Clone(storage), expression2_->Clone(storage));         \
   }
 #define CLONE_UNARY_EXPRESSION                                               \
   auto Clone(AstTreeStorage &storage) const->std::remove_const<              \
-      std::remove_pointer<decltype(this)>::type>::type * override {          \
+      std::remove_pointer<decltype(this)>::type>::type *override {           \
     return storage.Create<                                                   \
         std::remove_cv<std::remove_reference<decltype(*this)>::type>::type>( \
         expression_->Clone(storage));                                        \
   }
 
+#define SERIALIZE_USING_BASE(BaseClass)                       \
+  template <class TArchive>                                   \
+  void serialize(TArchive &ar, const unsigned int) {          \
+    ar & boost::serialization::base_object<BaseClass>(*this); \
+  }
+
 class Tree;
 
 // It would be better to call this AstTree, but we already have a class Tree,
@@ -70,11 +82,75 @@ class AstTreeStorage {
 
   Query *query() const;
 
+  /// Load an Ast Node into this storage.
+  template <class TArchive, class TNode>
+  void Load(TArchive &ar, TNode &node) {
+    auto &tmp_ast = ar.template get_helper<AstTreeStorage>();
+    tmp_ast.storage_ = std::move(storage_);
+    ar >> node;
+    storage_ = std::move(tmp_ast.storage_);
+    next_uid_ = MaximumStorageUid() + 1;
+  }
+
+  /// Load a Query into this storage.
+  template <class TArchive>
+  void Load(TArchive &ar) {
+    Load(ar, *query());
+  }
+
  private:
   int next_uid_ = 0;
   std::vector<std::unique_ptr<Tree>> storage_;
+
+  int MaximumStorageUid() const;
+
+  template <class TArchive, class TNode>
+  friend void LoadPointer(TArchive &ar, TNode *&node);
 };
 
+template <class TArchive, class TNode>
+void SavePointer(TArchive &ar, TNode *node) {
+  ar << node;
+}
+
+template <class TArchive, class TNode>
+void LoadPointer(TArchive &ar, TNode *&node) {
+  ar >> node;
+  if (node) {
+    auto &ast_storage = ar.template get_helper<AstTreeStorage>();
+    auto found =
+        std::find_if(ast_storage.storage_.begin(), ast_storage.storage_.end(),
+                     [&](const auto &n) { return n->uid() == node->uid(); });
+    // Boost makes sure pointers to same address are deserialized only once, so
+    // we only need to add nodes to the storage only on the first load.
+    DCHECK(ast_storage.storage_.end() == found ||
+           dynamic_cast<TNode *>(found->get()) == node);
+    if (ast_storage.storage_.end() == found) {
+      ast_storage.storage_.emplace_back(node);
+    }
+  }
+}
+
+template <class TArchive, class TNode>
+void SavePointers(TArchive &ar, const std::vector<TNode *> &nodes) {
+  ar << nodes.size();
+  for (auto *node : nodes) {
+    SavePointer(ar, node);
+  }
+}
+
+template <class TArchive, class TNode>
+void LoadPointers(TArchive &ar, std::vector<TNode *> &nodes) {
+  size_t size = 0;
+  ar >> size;
+  for (size_t i = 0; i < size; ++i) {
+    TNode *node = nullptr;
+    LoadPointer(ar, node);
+    DCHECK(node) << "Unexpected nullptr serialized";
+    nodes.emplace_back(node);
+  }
+}
+
 class Tree : public ::utils::Visitable<HierarchicalTreeVisitor>,
              ::utils::Visitable<TreeVisitor<TypedValue>> {
   friend class AstTreeStorage;
@@ -91,7 +167,14 @@ class Tree : public ::utils::Visitable<HierarchicalTreeVisitor>,
   explicit Tree(int uid) : uid_(uid) {}
 
  private:
-  const int uid_;
+  int uid_;
+
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & uid_;
+  }
 };
 
 // Expressions
@@ -104,6 +187,10 @@ class Expression : public Tree {
 
  protected:
   explicit Expression(int uid) : Tree(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(Tree);
 };
 
 class Where : public Tree {
@@ -127,6 +214,27 @@ class Where : public Tree {
  protected:
   explicit Where(int uid) : Tree(uid) {}
   Where(int uid, Expression *expression) : Tree(uid), expression_(expression) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Tree>(*this);
+    SavePointer(ar, expression_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Tree>(*this);
+    LoadPointer(ar, expression_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Where *,
+                                                        const unsigned int);
 };
 
 class BinaryOperator : public Expression {
@@ -142,6 +250,25 @@ class BinaryOperator : public Expression {
   explicit BinaryOperator(int uid) : Expression(uid) {}
   BinaryOperator(int uid, Expression *expression1, Expression *expression2)
       : Expression(uid), expression1_(expression1), expression2_(expression2) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Expression>(*this);
+    SavePointer(ar, expression1_);
+    SavePointer(ar, expression2_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Expression>(*this);
+    LoadPointer(ar, expression1_);
+    LoadPointer(ar, expression2_);
+  }
 };
 
 class UnaryOperator : public Expression {
@@ -156,6 +283,23 @@ class UnaryOperator : public Expression {
   explicit UnaryOperator(int uid) : Expression(uid) {}
   UnaryOperator(int uid, Expression *expression)
       : Expression(uid), expression_(expression) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Expression>(*this);
+    SavePointer(ar, expression_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Expression>(*this);
+    LoadPointer(ar, expression_);
+  }
 };
 
 class OrOperator : public BinaryOperator {
@@ -173,6 +317,14 @@ class OrOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        OrOperator *,
+                                                        const unsigned int);
 };
 
 class XorOperator : public BinaryOperator {
@@ -190,6 +342,14 @@ class XorOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        XorOperator *,
+                                                        const unsigned int);
 };
 
 class AndOperator : public BinaryOperator {
@@ -207,6 +367,14 @@ class AndOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        AndOperator *,
+                                                        const unsigned int);
 };
 
 class AdditionOperator : public BinaryOperator {
@@ -224,6 +392,14 @@ class AdditionOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        AdditionOperator *,
+                                                        const unsigned int);
 };
 
 class SubtractionOperator : public BinaryOperator {
@@ -241,6 +417,14 @@ class SubtractionOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        SubtractionOperator *,
+                                                        const unsigned int);
 };
 
 class MultiplicationOperator : public BinaryOperator {
@@ -258,6 +442,13 @@ class MultiplicationOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(
+      TArchive &, MultiplicationOperator *, const unsigned int);
 };
 
 class DivisionOperator : public BinaryOperator {
@@ -275,6 +466,14 @@ class DivisionOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        DivisionOperator *,
+                                                        const unsigned int);
 };
 
 class ModOperator : public BinaryOperator {
@@ -292,6 +491,14 @@ class ModOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        ModOperator *,
+                                                        const unsigned int);
 };
 
 class NotEqualOperator : public BinaryOperator {
@@ -309,6 +516,14 @@ class NotEqualOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        NotEqualOperator *,
+                                                        const unsigned int);
 };
 
 class EqualOperator : public BinaryOperator {
@@ -326,6 +541,14 @@ class EqualOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        EqualOperator *,
+                                                        const unsigned int);
 };
 
 class LessOperator : public BinaryOperator {
@@ -343,6 +566,14 @@ class LessOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        LessOperator *,
+                                                        const unsigned int);
 };
 
 class GreaterOperator : public BinaryOperator {
@@ -360,6 +591,14 @@ class GreaterOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        GreaterOperator *,
+                                                        const unsigned int);
 };
 
 class LessEqualOperator : public BinaryOperator {
@@ -377,6 +616,14 @@ class LessEqualOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        LessEqualOperator *,
+                                                        const unsigned int);
 };
 
 class GreaterEqualOperator : public BinaryOperator {
@@ -394,6 +641,14 @@ class GreaterEqualOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        GreaterEqualOperator *,
+                                                        const unsigned int);
 };
 
 class InListOperator : public BinaryOperator {
@@ -411,6 +666,14 @@ class InListOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        InListOperator *,
+                                                        const unsigned int);
 };
 
 class ListMapIndexingOperator : public BinaryOperator {
@@ -428,6 +691,13 @@ class ListMapIndexingOperator : public BinaryOperator {
 
  protected:
   using BinaryOperator::BinaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(BinaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(
+      TArchive &, ListMapIndexingOperator *, const unsigned int);
 };
 
 class ListSlicingOperator : public Expression {
@@ -455,9 +725,9 @@ class ListSlicingOperator : public Expression {
         upper_bound_ ? upper_bound_->Clone(storage) : nullptr);
   }
 
-  Expression *list_;
-  Expression *lower_bound_;
-  Expression *upper_bound_;
+  Expression *list_ = nullptr;
+  Expression *lower_bound_ = nullptr;
+  Expression *upper_bound_ = nullptr;
 
  protected:
   ListSlicingOperator(int uid, Expression *list, Expression *lower_bound,
@@ -466,6 +736,32 @@ class ListSlicingOperator : public Expression {
         list_(list),
         lower_bound_(lower_bound),
         upper_bound_(upper_bound) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Expression>(*this);
+    SavePointer(ar, list_);
+    SavePointer(ar, lower_bound_);
+    SavePointer(ar, upper_bound_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Expression>(*this);
+    LoadPointer(ar, list_);
+    LoadPointer(ar, lower_bound_);
+    LoadPointer(ar, upper_bound_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        ListSlicingOperator *,
+                                                        const unsigned int);
 };
 
 class IfOperator : public Expression {
@@ -499,11 +795,33 @@ class IfOperator : public Expression {
       : Expression(uid),
         condition_(condition),
         then_expression_(then_expression),
-        else_expression_(else_expression) {
-    DCHECK(condition_ != nullptr && then_expression_ != nullptr &&
-           else_expression_ != nullptr)
-        << "clause_, then_expression_ and else_expression_ can't be nullptr";
+        else_expression_(else_expression) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Expression>(*this);
+    SavePointer(ar, condition_);
+    SavePointer(ar, then_expression_);
+    SavePointer(ar, else_expression_);
   }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Expression>(*this);
+    LoadPointer(ar, condition_);
+    LoadPointer(ar, then_expression_);
+    LoadPointer(ar, else_expression_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        IfOperator *,
+                                                        const unsigned int);
 };
 
 class NotOperator : public UnaryOperator {
@@ -521,6 +839,14 @@ class NotOperator : public UnaryOperator {
 
  protected:
   using UnaryOperator::UnaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(UnaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        NotOperator *,
+                                                        const unsigned int);
 };
 
 class UnaryPlusOperator : public UnaryOperator {
@@ -538,6 +864,14 @@ class UnaryPlusOperator : public UnaryOperator {
 
  protected:
   using UnaryOperator::UnaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(UnaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        UnaryPlusOperator *,
+                                                        const unsigned int);
 };
 
 class UnaryMinusOperator : public UnaryOperator {
@@ -555,6 +889,14 @@ class UnaryMinusOperator : public UnaryOperator {
 
  protected:
   using UnaryOperator::UnaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(UnaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        UnaryMinusOperator *,
+                                                        const unsigned int);
 };
 
 class IsNullOperator : public UnaryOperator {
@@ -572,6 +914,14 @@ class IsNullOperator : public UnaryOperator {
 
  protected:
   using UnaryOperator::UnaryOperator;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(UnaryOperator);
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        IsNullOperator *,
+                                                        const unsigned int);
 };
 
 class BaseLiteral : public Expression {
@@ -582,6 +932,10 @@ class BaseLiteral : public Expression {
 
  protected:
   explicit BaseLiteral(int uid) : Expression(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(Expression);
 };
 
 class PrimitiveLiteral : public BaseLiteral {
@@ -608,6 +962,139 @@ class PrimitiveLiteral : public BaseLiteral {
   template <typename T>
   PrimitiveLiteral(int uid, T value, int token_position)
       : BaseLiteral(uid), value_(value), token_position_(token_position) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<BaseLiteral>(*this);
+    ar << token_position_;
+    SaveTypedValue(ar, value_);
+  }
+
+  template <class TArchive>
+  static void SaveTypedValue(TArchive &ar, const TypedValue &value) {
+    ar << value.type();
+    switch (value.type()) {
+      case TypedValue::Type::Null:
+        return;
+      case TypedValue::Type::Bool:
+        ar << value.Value<bool>();
+        return;
+      case TypedValue::Type::Int:
+        ar << value.Value<int64_t>();
+        return;
+      case TypedValue::Type::Double:
+        ar << value.Value<double>();
+        return;
+      case TypedValue::Type::String:
+        ar << value.Value<std::string>();
+        return;
+      case TypedValue::Type::List: {
+        const auto &values = value.Value<std::vector<TypedValue>>();
+        ar << values.size();
+        for (const auto &v : values) {
+          SaveTypedValue(ar, v);
+        }
+        return;
+      }
+      case TypedValue::Type::Map: {
+        const auto &map = value.Value<std::map<std::string, TypedValue>>();
+        ar << map.size();
+        for (const auto &key_value : map) {
+          ar << key_value.first;
+          SaveTypedValue(ar, key_value.second);
+        }
+        return;
+      }
+      case TypedValue::Type::Vertex:
+      case TypedValue::Type::Edge:
+      case TypedValue::Type::Path:
+        throw utils::BasicException("Unexpected value type in literal: '{}'",
+                                    value.type());
+    }
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<BaseLiteral>(*this);
+    ar >> token_position_;
+    LoadTypedValue(ar, value_);
+  }
+
+  template <class TArchive>
+  static void LoadTypedValue(TArchive &ar, TypedValue &value) {
+    TypedValue::Type type = TypedValue::Type::Null;
+    ar >> type;
+    switch (type) {
+      case TypedValue::Type::Null:
+        return;
+      case TypedValue::Type::Bool: {
+        bool v;
+        ar >> v;
+        value = v;
+        return;
+      }
+      case TypedValue::Type::Int: {
+        int64_t v;
+        ar >> v;
+        value = v;
+        return;
+      }
+      case TypedValue::Type::Double: {
+        double v;
+        ar >> v;
+        value = v;
+        return;
+      }
+      case TypedValue::Type::String: {
+        std::string v;
+        ar >> v;
+        value = v;
+        return;
+      }
+      case TypedValue::Type::List: {
+        std::vector<TypedValue> values;
+        size_t size;
+        ar >> size;
+        values.reserve(size);
+        for (size_t i = 0; i < size; ++i) {
+          TypedValue tv;
+          LoadTypedValue(ar, tv);
+          values.emplace_back(tv);
+        }
+        value = values;
+        return;
+      }
+      case TypedValue::Type::Map: {
+        std::map<std::string, TypedValue> map;
+        size_t size;
+        ar >> size;
+        for (size_t i = 0; i < size; ++i) {
+          std::string key;
+          ar >> key;
+          TypedValue v;
+          LoadTypedValue(ar, v);
+          map.emplace(key, v);
+        }
+        value = map;
+        return;
+      }
+      case TypedValue::Type::Vertex:
+      case TypedValue::Type::Edge:
+      case TypedValue::Type::Path:
+        throw utils::BasicException("Unexpected value type in literal: '{}'",
+                                    type);
+    }
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        PrimitiveLiteral *,
+                                                        const unsigned int);
 };
 
 class ListLiteral : public BaseLiteral {
@@ -637,6 +1124,28 @@ class ListLiteral : public BaseLiteral {
   explicit ListLiteral(int uid) : BaseLiteral(uid) {}
   ListLiteral(int uid, const std::vector<Expression *> &elements)
       : BaseLiteral(uid), elements_(elements) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<BaseLiteral>(*this);
+    SavePointers(ar, elements_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<BaseLiteral>(*this);
+    LoadPointers(ar, elements_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        ListLiteral *,
+                                                        const unsigned int);
 };
 
 class MapLiteral : public BaseLiteral {
@@ -671,6 +1180,44 @@ class MapLiteral : public BaseLiteral {
       const std::unordered_map<std::pair<std::string, GraphDbTypes::Property>,
                                Expression *> &elements)
       : BaseLiteral(uid), elements_(elements) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<BaseLiteral>(*this);
+    ar << elements_.size();
+    for (const auto &element : elements_) {
+      const auto &property = element.first;
+      ar << property.first;
+      ar << property.second;
+      SavePointer(ar, element.second);
+    }
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<BaseLiteral>(*this);
+    size_t size = 0;
+    ar >> size;
+    for (size_t i = 0; i < size; ++i) {
+      std::pair<std::string, GraphDbTypes::Property> property;
+      ar >> property.first;
+      ar >> property.second;
+      Expression *expression = nullptr;
+      LoadPointer(ar, expression);
+      DCHECK(expression) << "Unexpected nullptr expression serialized";
+      elements_.emplace(property, expression);
+    }
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        MapLiteral *,
+                                                        const unsigned int);
 };
 
 class Identifier : public Expression {
@@ -691,6 +1238,21 @@ class Identifier : public Expression {
   Identifier(int uid, const std::string &name) : Expression(uid), name_(name) {}
   Identifier(int uid, const std::string &name, bool user_declared)
       : Expression(uid), name_(name), user_declared_(user_declared) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & boost::serialization::base_object<Expression>(*this);
+    ar & name_;
+    ar & user_declared_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        Identifier *,
+                                                        const unsigned int);
 };
 
 class PropertyLookup : public Expression {
@@ -728,6 +1290,32 @@ class PropertyLookup : public Expression {
         expression_(expression),
         property_name_(property.first),
         property_(property.second) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Expression>(*this);
+    SavePointer(ar, expression_);
+    ar << property_name_;
+    ar << property_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Expression>(*this);
+    LoadPointer(ar, expression_);
+    ar >> property_name_;
+    ar >> property_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        PropertyLookup *,
+                                                        const unsigned int);
 };
 
 class LabelsTest : public Expression {
@@ -753,6 +1341,30 @@ class LabelsTest : public Expression {
   LabelsTest(int uid, Expression *expression,
              const std::vector<GraphDbTypes::Label> &labels)
       : Expression(uid), expression_(expression), labels_(labels) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Expression>(*this);
+    SavePointer(ar, expression_);
+    ar << labels_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Expression>(*this);
+    LoadPointer(ar, expression_);
+    ar >> labels_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        LabelsTest *,
+                                                        const unsigned int);
 };
 
 class Function : public Expression {
@@ -769,25 +1381,58 @@ class Function : public Expression {
     return visitor.PostVisit(*this);
   }
 
-  // TODO: Think if there are any problems if function_ is mutable.
   Function *Clone(AstTreeStorage &storage) const override {
     std::vector<Expression *> arguments;
     for (auto *argument : arguments_) {
       arguments.push_back(argument->Clone(storage));
     }
-    return storage.Create<Function>(function_, arguments);
+    return storage.Create<Function>(function_name_, arguments);
   }
 
-  std::function<TypedValue(const std::vector<TypedValue> &, GraphDbAccessor &)>
-      function_;
+  const auto &function() const { return function_; }
+  const auto &function_name() const { return function_name_; }
   std::vector<Expression *> arguments_;
 
  protected:
-  Function(int uid,
-           const std::function<TypedValue(const std::vector<TypedValue> &,
-                                          GraphDbAccessor &)> &function,
+  explicit Function(int uid) : Expression(uid) {}
+
+  Function(int uid, const std::string &function_name,
            const std::vector<Expression *> &arguments)
-      : Expression(uid), function_(function), arguments_(arguments) {}
+      : Expression(uid),
+        arguments_(arguments),
+        function_name_(function_name),
+        function_(NameToFunction(function_name_)) {
+    DCHECK(function_) << "Unexpected missing function: " << function_name_;
+  }
+
+ private:
+  std::string function_name_;
+  std::function<TypedValue(const std::vector<TypedValue> &, GraphDbAccessor &)>
+      function_;
+
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Expression>(*this);
+    ar << function_name_;
+    SavePointers(ar, arguments_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Expression>(*this);
+    ar >> function_name_;
+    function_ = NameToFunction(function_name_);
+    DCHECK(function_) << "Unexpected missing function: " << function_name_;
+    LoadPointers(ar, arguments_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Function *,
+                                                        const unsigned int);
 };
 
 class Aggregation : public BinaryOperator {
@@ -831,6 +1476,20 @@ class Aggregation : public BinaryOperator {
         << "The second expression is obligatory in COLLECT_MAP and "
            "invalid otherwise";
   }
+
+ private:
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & boost::serialization::base_object<BinaryOperator>(*this);
+    ar & op_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        Aggregation *,
+                                                        const unsigned int);
 };
 
 class All : public Expression {
@@ -852,6 +1511,7 @@ class All : public Expression {
                                where_->Clone(storage));
   }
 
+  // None of these should be nullptr after construction.
   Identifier *identifier_ = nullptr;
   Expression *list_expression_ = nullptr;
   Where *where_ = nullptr;
@@ -862,11 +1522,32 @@ class All : public Expression {
       : Expression(uid),
         identifier_(identifier),
         list_expression_(list_expression),
-        where_(where) {
-    DCHECK(identifier) << "identifier must not be nullptr";
-    DCHECK(list_expression) << "list_expression must not be nullptr";
-    DCHECK(where) << "where must not be nullptr";
+        where_(where) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Expression>(*this);
+    SavePointer(ar, identifier_);
+    SavePointer(ar, list_expression_);
+    SavePointer(ar, where_);
   }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Expression>(*this);
+    LoadPointer(ar, identifier_);
+    LoadPointer(ar, list_expression_);
+    LoadPointer(ar, where_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, All *,
+                                                        const unsigned int);
 };
 
 class ParameterLookup : public Expression {
@@ -889,6 +1570,19 @@ class ParameterLookup : public Expression {
   explicit ParameterLookup(int uid) : Expression(uid) {}
   ParameterLookup(int uid, int token_position)
       : Expression(uid), token_position_(token_position) {}
+
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & boost::serialization::base_object<Expression>(*this);
+    ar & token_position_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        ParameterLookup *,
+                                                        const unsigned int);
 };
 
 class NamedExpression : public Tree {
@@ -926,6 +1620,32 @@ class NamedExpression : public Tree {
         name_(name),
         expression_(expression),
         token_position_(token_position) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Tree>(*this);
+    ar << name_;
+    SavePointer(ar, expression_);
+    ar << token_position_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Tree>(*this);
+    ar >> name_;
+    LoadPointer(ar, expression_);
+    ar >> token_position_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        NamedExpression *,
+                                                        const unsigned int);
 };
 
 // Pattern atoms
@@ -942,6 +1662,23 @@ class PatternAtom : public Tree {
   explicit PatternAtom(int uid) : Tree(uid) {}
   PatternAtom(int uid, Identifier *identifier)
       : Tree(uid), identifier_(identifier) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Tree>(*this);
+    SavePointer(ar, identifier_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Tree>(*this);
+    LoadPointer(ar, identifier_);
+  }
 };
 
 class NodeAtom : public PatternAtom {
@@ -978,6 +1715,45 @@ class NodeAtom : public PatternAtom {
 
  protected:
   using PatternAtom::PatternAtom;
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<PatternAtom>(*this);
+    ar << labels_;
+    ar << properties_.size();
+    for (const auto &property : properties_) {
+      const auto &key = property.first;
+      ar << key.first;
+      ar << key.second;
+      SavePointer(ar, property.second);
+    }
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<PatternAtom>(*this);
+    ar >> labels_;
+    size_t size = 0;
+    ar >> size;
+    for (size_t i = 0; i < size; ++i) {
+      std::pair<std::string, GraphDbTypes::Property> property;
+      ar >> property.first;
+      ar >> property.second;
+      Expression *expression = nullptr;
+      LoadPointer(ar, expression);
+      DCHECK(expression) << "Unexpected nullptr expression serialized";
+      properties_.emplace(property, expression);
+    }
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, NodeAtom *,
+                                                        const unsigned int);
 };
 
 class EdgeAtom : public PatternAtom {
@@ -1065,6 +1841,59 @@ class EdgeAtom : public PatternAtom {
         type_(type),
         direction_(direction),
         edge_types_(edge_types) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<PatternAtom>(*this);
+    ar << type_;
+    ar << direction_;
+    ar << edge_types_;
+    ar << properties_.size();
+    for (const auto &property : properties_) {
+      const auto &key = property.first;
+      ar << key.first;
+      ar << key.second;
+      SavePointer(ar, property.second);
+    }
+    SavePointer(ar, lower_bound_);
+    SavePointer(ar, upper_bound_);
+    SavePointer(ar, inner_edge_);
+    SavePointer(ar, inner_node_);
+    SavePointer(ar, filter_expression_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<PatternAtom>(*this);
+    ar >> type_;
+    ar >> direction_;
+    ar >> edge_types_;
+    size_t size = 0;
+    ar >> size;
+    for (size_t i = 0; i < size; ++i) {
+      std::pair<std::string, GraphDbTypes::Property> property;
+      ar >> property.first;
+      ar >> property.second;
+      Expression *expression = nullptr;
+      LoadPointer(ar, expression);
+      DCHECK(expression) << "Unexpected nullptr expression serialized";
+      properties_.emplace(property, expression);
+    }
+    LoadPointer(ar, lower_bound_);
+    LoadPointer(ar, upper_bound_);
+    LoadPointer(ar, inner_edge_);
+    LoadPointer(ar, inner_node_);
+    LoadPointer(ar, filter_expression_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, EdgeAtom *,
+                                                        const unsigned int);
 };
 
 class Pattern : public Tree {
@@ -1098,6 +1927,29 @@ class Pattern : public Tree {
 
  protected:
   explicit Pattern(int uid) : Tree(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Tree>(*this);
+    SavePointer(ar, identifier_);
+    SavePointers(ar, atoms_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Tree>(*this);
+    LoadPointer(ar, identifier_);
+    LoadPointers(ar, atoms_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Pattern *,
+                                                        const unsigned int);
 };
 
 // Clause
@@ -1109,6 +1961,10 @@ class Clause : public Tree {
   explicit Clause(int uid) : Tree(uid) {}
 
   Clause *Clone(AstTreeStorage &storage) const override = 0;
+
+ private:
+  friend class boost::serialization::access;
+  SERIALIZE_USING_BASE(Tree);
 };
 
 // SingleQuery
@@ -1139,6 +1995,28 @@ class SingleQuery : public Tree {
 
  protected:
   explicit SingleQuery(int uid) : Tree(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Tree>(*this);
+    SavePointers(ar, clauses_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Tree>(*this);
+    LoadPointers(ar, clauses_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        SingleQuery *,
+                                                        const unsigned int);
 };
 
 // CypherUnion
@@ -1173,6 +2051,32 @@ class CypherUnion : public Tree {
  protected:
   explicit CypherUnion(int uid) : Tree(uid) {}
   CypherUnion(int uid, bool distinct) : Tree(uid), distinct_(distinct) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Tree>(*this);
+    SavePointer(ar, single_query_);
+    ar << distinct_;
+    ar << union_symbols_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Tree>(*this);
+    LoadPointer(ar, single_query_);
+    ar >> distinct_;
+    ar >> union_symbols_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        CypherUnion *,
+                                                        const unsigned int);
 };
 
 // Queries
@@ -1209,6 +2113,29 @@ class Query : public Tree {
 
  protected:
   explicit Query(int uid) : Tree(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Tree>(*this);
+    SavePointer(ar, single_query_);
+    SavePointers(ar, cypher_unions_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Tree>(*this);
+    LoadPointer(ar, single_query_);
+    LoadPointers(ar, cypher_unions_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Query *,
+                                                        const unsigned int);
 };
 
 // Clauses
@@ -1217,7 +2144,6 @@ class Create : public Clause {
   friend class AstTreeStorage;
 
  public:
-  explicit Create(int uid) : Clause(uid) {}
   DEFVISITABLE(TreeVisitor<TypedValue>);
   bool Accept(HierarchicalTreeVisitor &visitor) override {
     if (visitor.PreVisit(*this)) {
@@ -1237,6 +2163,30 @@ class Create : public Clause {
   }
 
   std::vector<Pattern *> patterns_;
+
+ protected:
+  explicit Create(int uid) : Clause(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointers(ar, patterns_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointers(ar, patterns_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Create *,
+                                                        const unsigned int);
 };
 
 class Match : public Clause {
@@ -1276,6 +2226,31 @@ class Match : public Clause {
  protected:
   explicit Match(int uid) : Clause(uid) {}
   Match(int uid, bool optional) : Clause(uid), optional_(optional) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointers(ar, patterns_);
+    SavePointer(ar, where_);
+    ar << optional_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointers(ar, patterns_);
+    LoadPointer(ar, where_);
+    ar >> optional_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Match *,
+                                                        const unsigned int);
 };
 
 /** @brief Defines the order for sorting values (ascending or descending). */
@@ -1304,6 +2279,44 @@ struct ReturnBody {
 // function class member.
 ReturnBody CloneReturnBody(AstTreeStorage &storage, const ReturnBody &body);
 
+template <class TArchive>
+void serialize(TArchive &ar, ReturnBody &body,
+               const unsigned int file_version) {
+  boost::serialization::split_free(ar, body, file_version);
+}
+
+template <class TArchive>
+void save(TArchive &ar, const ReturnBody &body, const unsigned int) {
+  ar << body.distinct;
+  ar << body.all_identifiers;
+  SavePointers(ar, body.named_expressions);
+  ar << body.order_by.size();
+  for (const auto &order_by : body.order_by) {
+    ar << order_by.first;
+    SavePointer(ar, order_by.second);
+  }
+  SavePointer(ar, body.skip);
+  SavePointer(ar, body.limit);
+}
+
+template <class TArchive>
+void load(TArchive &ar, ReturnBody &body, const unsigned int) {
+  ar >> body.distinct;
+  ar >> body.all_identifiers;
+  LoadPointers(ar, body.named_expressions);
+  size_t size = 0;
+  ar >> size;
+  for (size_t i = 0; i < size; ++i) {
+    std::pair<Ordering, Expression *> order_by;
+    ar >> order_by.first;
+    LoadPointer(ar, order_by.second);
+    DCHECK(order_by.second) << "Unexpected nullptr serialized";
+    body.order_by.emplace_back(order_by);
+  }
+  LoadPointer(ar, body.skip);
+  LoadPointer(ar, body.limit);
+}
+
 class Return : public Clause {
   friend class AstTreeStorage;
 
@@ -1342,6 +2355,19 @@ class Return : public Clause {
 
  protected:
   explicit Return(int uid) : Clause(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & boost::serialization::base_object<Clause>(*this);
+    ar & body_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Return *,
+                                                        const unsigned int);
 };
 
 class With : public Clause {
@@ -1385,6 +2411,29 @@ class With : public Clause {
 
  protected:
   explicit With(int uid) : Clause(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    ar << body_;
+    SavePointer(ar, where_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    ar >> body_;
+    LoadPointer(ar, where_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, With *,
+                                                        const unsigned int);
 };
 
 class Delete : public Clause {
@@ -1415,6 +2464,29 @@ class Delete : public Clause {
 
  protected:
   explicit Delete(int uid) : Clause(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointers(ar, expressions_);
+    ar << detach_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointers(ar, expressions_);
+    ar >> detach_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Delete *,
+                                                        const unsigned int);
 };
 
 class SetProperty : public Clause {
@@ -1443,6 +2515,30 @@ class SetProperty : public Clause {
       : Clause(uid),
         property_lookup_(property_lookup),
         expression_(expression) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointer(ar, property_lookup_);
+    SavePointer(ar, expression_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointer(ar, property_lookup_);
+    LoadPointer(ar, expression_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        SetProperty *,
+                                                        const unsigned int);
 };
 
 class SetProperties : public Clause {
@@ -1474,6 +2570,32 @@ class SetProperties : public Clause {
         identifier_(identifier),
         expression_(expression),
         update_(update) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointer(ar, identifier_);
+    SavePointer(ar, expression_);
+    ar << update_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointer(ar, identifier_);
+    LoadPointer(ar, expression_);
+    ar >> update_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        SetProperties *,
+                                                        const unsigned int);
 };
 
 class SetLabels : public Clause {
@@ -1500,6 +2622,29 @@ class SetLabels : public Clause {
   SetLabels(int uid, Identifier *identifier,
             const std::vector<GraphDbTypes::Label> &labels)
       : Clause(uid), identifier_(identifier), labels_(labels) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointer(ar, identifier_);
+    ar << labels_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointer(ar, identifier_);
+    ar >> labels_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, SetLabels *,
+                                                        const unsigned int);
 };
 
 class RemoveProperty : public Clause {
@@ -1524,6 +2669,28 @@ class RemoveProperty : public Clause {
   explicit RemoveProperty(int uid) : Clause(uid) {}
   RemoveProperty(int uid, PropertyLookup *property_lookup)
       : Clause(uid), property_lookup_(property_lookup) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointer(ar, property_lookup_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointer(ar, property_lookup_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        RemoveProperty *,
+                                                        const unsigned int);
 };
 
 class RemoveLabels : public Clause {
@@ -1550,6 +2717,30 @@ class RemoveLabels : public Clause {
   RemoveLabels(int uid, Identifier *identifier,
                const std::vector<GraphDbTypes::Label> &labels)
       : Clause(uid), identifier_(identifier), labels_(labels) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointer(ar, identifier_);
+    ar << labels_;
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointer(ar, identifier_);
+    ar >> labels_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        RemoveLabels *,
+                                                        const unsigned int);
 };
 
 class Merge : public Clause {
@@ -1598,6 +2789,31 @@ class Merge : public Clause {
 
  protected:
   explicit Merge(int uid) : Clause(uid) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointer(ar, pattern_);
+    SavePointers(ar, on_match_);
+    SavePointers(ar, on_create_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointer(ar, pattern_);
+    LoadPointers(ar, on_match_);
+    LoadPointers(ar, on_create_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Merge *,
+                                                        const unsigned int);
 };
 
 class Unwind : public Clause {
@@ -1616,14 +2832,37 @@ class Unwind : public Clause {
     return storage.Create<Unwind>(named_expression_->Clone(storage));
   }
 
-  NamedExpression *const named_expression_ = nullptr;
+  NamedExpression *named_expression_ = nullptr;
 
  protected:
+  explicit Unwind(int uid) : Clause(uid) {}
+
   Unwind(int uid, NamedExpression *named_expression)
       : Clause(uid), named_expression_(named_expression) {
     DCHECK(named_expression)
         << "Unwind cannot take nullptr for named_expression";
   }
+
+ private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER();
+
+  template <class TArchive>
+  void save(TArchive &ar, const unsigned int) const {
+    ar << boost::serialization::base_object<Clause>(*this);
+    SavePointer(ar, named_expression_);
+  }
+
+  template <class TArchive>
+  void load(TArchive &ar, const unsigned int) {
+    ar >> boost::serialization::base_object<Clause>(*this);
+    LoadPointer(ar, named_expression_);
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &, Unwind *,
+                                                        const unsigned int);
 };
 
 class CreateIndex : public Clause {
@@ -1641,11 +2880,82 @@ class CreateIndex : public Clause {
   GraphDbTypes::Property property_;
 
  protected:
+  explicit CreateIndex(int uid) : Clause(uid) {}
   CreateIndex(int uid, GraphDbTypes::Label label,
               GraphDbTypes::Property property)
       : Clause(uid), label_(label), property_(property) {}
+
+ private:
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & boost::serialization::base_object<Clause>(*this);
+    ar & label_;
+    ar & property_;
+  }
+
+  template <class TArchive>
+  friend void boost::serialization::load_construct_data(TArchive &,
+                                                        CreateIndex *,
+                                                        const unsigned int);
 };
 
 #undef CLONE_BINARY_EXPRESSION
 #undef CLONE_UNARY_EXPRESSION
+#undef SERIALIZE_USING_BASE
 }  // namespace query
+
+BOOST_CLASS_EXPORT_KEY(query::Query);
+BOOST_CLASS_EXPORT_KEY(query::SingleQuery);
+BOOST_CLASS_EXPORT_KEY(query::CypherUnion);
+BOOST_CLASS_EXPORT_KEY(query::NamedExpression);
+BOOST_CLASS_EXPORT_KEY(query::OrOperator);
+BOOST_CLASS_EXPORT_KEY(query::XorOperator);
+BOOST_CLASS_EXPORT_KEY(query::AndOperator);
+BOOST_CLASS_EXPORT_KEY(query::NotOperator);
+BOOST_CLASS_EXPORT_KEY(query::AdditionOperator);
+BOOST_CLASS_EXPORT_KEY(query::SubtractionOperator);
+BOOST_CLASS_EXPORT_KEY(query::MultiplicationOperator);
+BOOST_CLASS_EXPORT_KEY(query::DivisionOperator);
+BOOST_CLASS_EXPORT_KEY(query::ModOperator);
+BOOST_CLASS_EXPORT_KEY(query::NotEqualOperator);
+BOOST_CLASS_EXPORT_KEY(query::EqualOperator);
+BOOST_CLASS_EXPORT_KEY(query::LessOperator);
+BOOST_CLASS_EXPORT_KEY(query::GreaterOperator);
+BOOST_CLASS_EXPORT_KEY(query::LessEqualOperator);
+BOOST_CLASS_EXPORT_KEY(query::GreaterEqualOperator);
+BOOST_CLASS_EXPORT_KEY(query::InListOperator);
+BOOST_CLASS_EXPORT_KEY(query::ListMapIndexingOperator);
+BOOST_CLASS_EXPORT_KEY(query::ListSlicingOperator);
+BOOST_CLASS_EXPORT_KEY(query::IfOperator);
+BOOST_CLASS_EXPORT_KEY(query::UnaryPlusOperator);
+BOOST_CLASS_EXPORT_KEY(query::UnaryMinusOperator);
+BOOST_CLASS_EXPORT_KEY(query::IsNullOperator);
+BOOST_CLASS_EXPORT_KEY(query::ListLiteral);
+BOOST_CLASS_EXPORT_KEY(query::MapLiteral);
+BOOST_CLASS_EXPORT_KEY(query::PropertyLookup);
+BOOST_CLASS_EXPORT_KEY(query::LabelsTest);
+BOOST_CLASS_EXPORT_KEY(query::Aggregation);
+BOOST_CLASS_EXPORT_KEY(query::Function);
+BOOST_CLASS_EXPORT_KEY(query::All);
+BOOST_CLASS_EXPORT_KEY(query::ParameterLookup);
+BOOST_CLASS_EXPORT_KEY(query::Create);
+BOOST_CLASS_EXPORT_KEY(query::Match);
+BOOST_CLASS_EXPORT_KEY(query::Return);
+BOOST_CLASS_EXPORT_KEY(query::With);
+BOOST_CLASS_EXPORT_KEY(query::Pattern);
+BOOST_CLASS_EXPORT_KEY(query::NodeAtom);
+BOOST_CLASS_EXPORT_KEY(query::EdgeAtom);
+BOOST_CLASS_EXPORT_KEY(query::Delete);
+BOOST_CLASS_EXPORT_KEY(query::Where);
+BOOST_CLASS_EXPORT_KEY(query::SetProperty);
+BOOST_CLASS_EXPORT_KEY(query::SetProperties);
+BOOST_CLASS_EXPORT_KEY(query::SetLabels);
+BOOST_CLASS_EXPORT_KEY(query::RemoveProperty);
+BOOST_CLASS_EXPORT_KEY(query::RemoveLabels);
+BOOST_CLASS_EXPORT_KEY(query::Merge);
+BOOST_CLASS_EXPORT_KEY(query::Unwind);
+BOOST_CLASS_EXPORT_KEY(query::Identifier);
+BOOST_CLASS_EXPORT_KEY(query::PrimitiveLiteral);
+BOOST_CLASS_EXPORT_KEY(query::CreateIndex);
diff --git a/src/query/frontend/ast/cypher_main_visitor.cpp b/src/query/frontend/ast/cypher_main_visitor.cpp
index 0f14de39f..ad306fb03 100644
--- a/src/query/frontend/ast/cypher_main_visitor.cpp
+++ b/src/query/frontend/ast/cypher_main_visitor.cpp
@@ -755,27 +755,24 @@ antlrcpp::Any CypherMainVisitor::visitExpression3a(
       expression = static_cast<Expression *>(storage_.Create<InListOperator>(
           expression, op->expression3b()->accept(this)));
     } else {
-      std::function<TypedValue(const std::vector<TypedValue> &,
-                               GraphDbAccessor &)>
-          f;
+      std::string function_name;
       if (op->STARTS() && op->WITH()) {
-        f = NameToFunction(kStartsWith);
+        function_name = kStartsWith;
       } else if (op->ENDS() && op->WITH()) {
-        f = NameToFunction(kEndsWith);
+        function_name = kEndsWith;
       } else if (op->CONTAINS()) {
-        f = NameToFunction(kContains);
+        function_name = kContains;
       } else {
         throw utils::NotYetImplemented("function '{}'", op->getText());
       }
       auto expression2 = op->expression3b()->accept(this);
       std::vector<Expression *> args = {expression, expression2};
-      expression =
-          static_cast<Expression *>(storage_.Create<Function>(f, args));
+      expression = static_cast<Expression *>(
+          storage_.Create<Function>(function_name, args));
     }
   }
   return expression;
 }
-
 antlrcpp::Any CypherMainVisitor::visitStringAndNullOperators(
     CypherParser::StringAndNullOperatorsContext *) {
   DLOG(FATAL) << "Should never be called. See documentation in hpp.";
@@ -989,7 +986,7 @@ antlrcpp::Any CypherMainVisitor::visitFunctionInvocation(
   if (!function)
     throw SemanticException("Function '{}' doesn't exist.", function_name);
   return static_cast<Expression *>(
-      storage_.Create<Function>(function, expressions));
+      storage_.Create<Function>(function_name, expressions));
 }
 
 antlrcpp::Any CypherMainVisitor::visitFunctionName(
diff --git a/src/query/frontend/semantic/symbol.hpp b/src/query/frontend/semantic/symbol.hpp
index 478614628..3e6e85e12 100644
--- a/src/query/frontend/semantic/symbol.hpp
+++ b/src/query/frontend/semantic/symbol.hpp
@@ -43,6 +43,17 @@ class Symbol {
   bool user_declared_ = true;
   Type type_ = Type::Any;
   int token_position_ = -1;
+
+  friend class boost::serialization::access;
+
+  template <class TArchive>
+  void serialize(TArchive &ar, const unsigned int) {
+    ar & name_;
+    ar & position_;
+    ar & user_declared_;
+    ar & type_;
+    ar & token_position_;
+  }
 };
 
 }  // namespace query
diff --git a/src/query/interpret/eval.hpp b/src/query/interpret/eval.hpp
index e6a905eda..df68b74db 100644
--- a/src/query/interpret/eval.hpp
+++ b/src/query/interpret/eval.hpp
@@ -350,7 +350,7 @@ class ExpressionEvaluator : public TreeVisitor<TypedValue> {
     for (const auto &argument : function.arguments_) {
       arguments.emplace_back(argument->Accept(*this));
     }
-    return function.function_(arguments, db_accessor_);
+    return function.function()(arguments, db_accessor_);
   }
 
   TypedValue Visit(All &all) override {
diff --git a/tests/unit/cypher_main_visitor.cpp b/tests/unit/cypher_main_visitor.cpp
index d5ae2aa58..f8ecc80bb 100644
--- a/tests/unit/cypher_main_visitor.cpp
+++ b/tests/unit/cypher_main_visitor.cpp
@@ -6,8 +6,11 @@
 #include <vector>
 
 #include "antlr4-runtime.h"
+#include "boost/archive/text_iarchive.hpp"
+#include "boost/archive/text_oarchive.hpp"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+
 #include "query/context.hpp"
 #include "query/frontend/ast/ast.hpp"
 #include "query/frontend/ast/cypher_main_visitor.hpp"
@@ -107,11 +110,39 @@ class CachedAstGenerator : public Base {
   Query *query_;
 };
 
+// This generator serializes the parsed ast and uses the deserialized one.
+class SerializedAstGenerator : public Base {
+ public:
+  SerializedAstGenerator(const std::string &query)
+      : Base(query),
+        storage_([&]() {
+          ::frontend::opencypher::Parser parser(query);
+          CypherMainVisitor visitor(context_);
+          visitor.visit(parser.tree());
+          std::stringstream stream;
+          {
+            boost::archive::text_oarchive out_archive(stream);
+            out_archive << *visitor.query();
+          }
+          AstTreeStorage new_ast;
+          {
+            boost::archive::text_iarchive in_archive(stream);
+            new_ast.Load(in_archive);
+          }
+          return new_ast;
+        }()),
+        query_(storage_.query()) {}
+
+  AstTreeStorage storage_;
+  Query *query_;
+};
+
 template <typename T>
 class CypherMainVisitorTest : public ::testing::Test {};
 
 typedef ::testing::Types<AstGenerator, OriginalAfterCloningAstGenerator,
-                         ClonedAstGenerator, CachedAstGenerator>
+                         ClonedAstGenerator, CachedAstGenerator,
+                         SerializedAstGenerator>
     AstGeneratorTypes;
 TYPED_TEST_CASE(CypherMainVisitorTest, AstGeneratorTypes);
 
@@ -712,7 +743,7 @@ TYPED_TEST(CypherMainVisitorTest, Function) {
   auto *function = dynamic_cast<Function *>(
       return_clause->body_.named_expressions[0]->expression_);
   ASSERT_TRUE(function);
-  ASSERT_TRUE(function->function_);
+  ASSERT_TRUE(function->function());
 }
 
 TYPED_TEST(CypherMainVisitorTest, StringLiteralDoubleQuotes) {
diff --git a/tests/unit/query_common.hpp b/tests/unit/query_common.hpp
index 5a148e790..201af90f7 100644
--- a/tests/unit/query_common.hpp
+++ b/tests/unit/query_common.hpp
@@ -579,9 +579,9 @@ auto GetMerge(AstTreeStorage &storage, Pattern *pattern, OnMatch on_match,
 #define AND(expr1, expr2) storage.Create<query::AndOperator>((expr1), (expr2))
 #define OR(expr1, expr2) storage.Create<query::OrOperator>((expr1), (expr2))
 // Function call
-#define FN(function_name, ...)                                  \
-  storage.Create<query::Function>(                              \
-      query::NameToFunction(utils::ToUpperCase(function_name)), \
+#define FN(function_name, ...)           \
+  storage.Create<query::Function>(       \
+      utils::ToUpperCase(function_name), \
       std::vector<query::Expression *>{__VA_ARGS__})
 // List slicing
 #define SLICE(list, lower_bound, upper_bound) \
diff --git a/tests/unit/query_expression_evaluator.cpp b/tests/unit/query_expression_evaluator.cpp
index b206cd2ae..2a42a271c 100644
--- a/tests/unit/query_expression_evaluator.cpp
+++ b/tests/unit/query_expression_evaluator.cpp
@@ -49,8 +49,7 @@ TypedValue EvaluateFunction(const std::string &function_name,
   for (const auto &arg : args) {
     expressions.push_back(storage.Create<PrimitiveLiteral>(arg));
   }
-  auto *op =
-      storage.Create<Function>(NameToFunction(function_name), expressions);
+  auto *op = storage.Create<Function>(function_name, expressions);
   return op->Accept(eval);
 }