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);
 }