Merge branch 'dev' of https://memgraph.phacility.com/diffusion/MG/memgraph into dev

.arclint

@@ -0,0 +1,8 @@
+{
+  "linters": {
+    "cppcheck": {
+      "type": "cppcheck",
+      "include": ["(\\.cpp$)", "(\\.hpp$)"]
+    }
+  }
+}

CMakeLists.txt

@@ -86,6 +86,7 @@ set(fmt_source_dir ${libs_dir}/fmt)
 set(fmt_static_lib ${fmt_source_dir}/fmt/libfmt.a)
 # yaml-cpp
 set(yaml_source_dir ${libs_dir}/yaml-cpp)
+set(yaml_include_dir ${yaml_source_dir}/include)
 set(yaml_static_lib ${yaml_source_dir}/libyaml-cpp.a)
 # Catch (C++ Automated Test Cases in Headers)
 set(catch_source_dir "${libs_dir}/Catch")
@@ -135,193 +136,31 @@ foreach(source_foler ${source_folders})
     file(COPY ${include_dir}/${source_folder} DESTINATION ${test_include_dir})
 endforeach()
 
-# -----------------------------------------------------------------------------
+include(copy_includes)
-# COPY header files required by query engine (query compiler)
-# TODO: somehow automate (in destination dir should be only required include files)
-FILE(COPY ${include_dir}/barrier/barrier.hpp DESTINATION ${build_include_dir}/barrier)
-FILE(COPY ${include_dir}/database/db.hpp DESTINATION ${build_include_dir}/database)
-FILE(COPY ${include_dir}/database/db_transaction.hpp DESTINATION ${build_include_dir}/database)
-FILE(COPY ${include_dir}/database/db_accessor.hpp DESTINATION ${build_include_dir}/database)
 
-FILE(COPY ${include_dir}/storage/common.hpp DESTINATION ${build_include_dir}/storage)
+# linter setup (clang-tidy)
-FILE(COPY ${include_dir}/storage/graph.hpp DESTINATION ${build_include_dir}/storage)
+# all source files for linting
-FILE(COPY ${include_dir}/storage/edge.hpp DESTINATION ${build_include_dir}/storage)
+FILE(GLOB_RECURSE LINTER_SRC_FILES
-FILE(COPY ${include_dir}/storage/edge_record.hpp DESTINATION ${build_include_dir}/storage)
+    ${src_dir}/*.cpp
-FILE(COPY ${include_dir}/storage/vertex_record.hpp DESTINATION ${build_include_dir}/storage)
+    ${CMAKE_SOURCE_DIR}/tests/.cpp
-FILE(COPY ${include_dir}/storage/edge_accessor.hpp DESTINATION ${build_include_dir}/storage)
+    ${CMAKE_SOURCE_DIR}/poc/.cpp
-FILE(COPY ${include_dir}/storage/edges.hpp DESTINATION ${build_include_dir}/storage)
+)
-FILE(COPY ${include_dir}/storage/vertices.hpp DESTINATION ${build_include_dir}/storage)
+MESSAGE(STATUS "All cpp files for linting are: ${LINTER_SRC_FILES}")
-FILE(COPY ${include_dir}/storage/vertex.hpp DESTINATION ${build_include_dir}/storage)
-FILE(COPY ${include_dir}/storage/vertex_accessor.hpp DESTINATION ${build_include_dir}/storage)
-FILE(COPY ${include_dir}/storage/record_accessor.hpp DESTINATION ${build_include_dir}/storage)
-FILE(COPY ${include_dir}/storage/locking/record_lock.hpp DESTINATION ${build_include_dir}/storage/locking)
-FILE(COPY ${include_dir}/storage/locking/lock_status.hpp DESTINATION ${build_include_dir}/storage/locking)
-FILE(COPY ${include_dir}/storage/edge_type/edge_type_store.hpp DESTINATION ${build_include_dir}/storage/edge_type)
-FILE(COPY ${include_dir}/storage/edge_type/edge_type.hpp DESTINATION ${build_include_dir}/storage/edge_type)
-FILE(COPY ${include_dir}/storage/label/label_store.hpp DESTINATION ${build_include_dir}/storage/label)
-FILE(COPY ${include_dir}/storage/model/edge_map.hpp DESTINATION ${build_include_dir}/storage/model)
-FILE(COPY ${include_dir}/storage/model/properties/flags.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/stored_property.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/property_holder.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/type_group_edge.hpp DESTINATION ${build_include_dir}/storage)
-FILE(COPY ${include_dir}/storage/type_group_vertex.hpp DESTINATION ${build_include_dir}/storage)
 
-FILE(COPY ${include_dir}/query/util.hpp DESTINATION ${build_include_dir}/query)
+# linter target clang-tidy
-FILE(COPY ${include_dir}/query/i_plan_cpu.hpp DESTINATION ${build_include_dir}/query)
+find_program(CLANG_TIDY "clang-tidy")
-FILE(COPY ${include_dir}/query/strip/stripped.hpp DESTINATION ${build_include_dir}/query/strip)
+if(CLANG_TIDY)
-
+    add_custom_target(
-FILE(COPY ${include_dir}/data_structures/concurrent/concurrent_map.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+        clang-tidy
-FILE(COPY ${include_dir}/data_structures/concurrent/concurrent_set.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+        COMMAND /usr/bin/clang-tidy
-FILE(COPY ${include_dir}/data_structures/concurrent/concurrent_list.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+        ${LINTER_SRC_FILES}
-FILE(COPY ${include_dir}/data_structures/concurrent/common.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+        -config=''
-FILE(COPY ${include_dir}/data_structures/concurrent/skiplist.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+        --
-FILE(COPY ${include_dir}/data_structures/concurrent/skiplist_gc.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+        -std=c++1y
-FILE(COPY ${include_dir}/data_structures/map/rh_hashmultimap.hpp DESTINATION ${build_include_dir}/data_structures/map)
+        -I${CMAKE_SOURCE_DIR}/include -I${fmt_source_dir} -I${yaml_include_dir}
-FILE(COPY ${include_dir}/data_structures/map/rh_common.hpp DESTINATION ${build_include_dir}/data_structures/map)
+    )
-
+endif()
-FILE(COPY ${include_dir}/data_structures/bitset/dynamic_bitset.hpp DESTINATION ${build_include_dir}/data_structures/bitset)
+# linter setup
-
-FILE(COPY ${include_dir}/threading/sync/lockable.hpp DESTINATION ${build_include_dir}/threading/sync)
-FILE(COPY ${include_dir}/threading/sync/spinlock.hpp DESTINATION ${build_include_dir}/threading/sync)
-FILE(COPY ${include_dir}/threading/sync/futex.hpp DESTINATION ${build_include_dir}/threading/sync)
-FILE(COPY ${include_dir}/threading/sync/lock_timeout_error.hpp DESTINATION ${build_include_dir}/threading/sync)
-
-FILE(COPY ${include_dir}/memory/freelist.hpp DESTINATION ${build_include_dir}/memory)
-FILE(COPY ${include_dir}/memory/lazy_gc.hpp DESTINATION ${build_include_dir}/garbage)
-FILE(COPY ${include_dir}/mvcc/cre_exp.hpp DESTINATION ${build_include_dir}/mvcc)
-FILE(COPY ${include_dir}/mvcc/hints.hpp DESTINATION ${build_include_dir}/mvcc)
-FILE(COPY ${include_dir}/mvcc/id.hpp DESTINATION ${build_include_dir}/mvcc)
-FILE(COPY ${include_dir}/mvcc/mvcc_error.hpp DESTINATION ${build_include_dir}/mvcc)
-FILE(COPY ${include_dir}/mvcc/record.hpp DESTINATION ${build_include_dir}/mvcc)
-FILE(COPY ${include_dir}/mvcc/serialization_error.hpp DESTINATION ${build_include_dir}/mvcc)
-FILE(COPY ${include_dir}/mvcc/version.hpp DESTINATION ${build_include_dir}/mvcc)
-FILE(COPY ${include_dir}/mvcc/version_list.hpp DESTINATION ${build_include_dir}/mvcc)
-
-FILE(COPY ${include_dir}/transactions/transaction.hpp DESTINATION ${build_include_dir}/transactions)
-FILE(COPY ${include_dir}/transactions/lock_store.hpp DESTINATION ${build_include_dir}/transactions)
-FILE(COPY ${include_dir}/transactions/snapshot.hpp DESTINATION ${build_include_dir}/transactions)
-FILE(COPY ${include_dir}/transactions/commit_log.hpp DESTINATION ${build_include_dir}/transactions)
-FILE(COPY ${include_dir}/transactions/engine.hpp DESTINATION ${build_include_dir}/transactions)
-FILE(COPY ${include_dir}/transactions/transaction_store.hpp DESTINATION ${build_include_dir}/transactions)
-FILE(COPY ${include_dir}/transactions/transaction_read.hpp DESTINATION ${build_include_dir}/transactions)
-
-FILE(COPY ${include_dir}/storage/model/properties/properties.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/property.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/traversers/consolewriter.hpp DESTINATION ${build_include_dir}/storage/model/properties/traversers)
-FILE(COPY ${include_dir}/storage/model/properties/traversers/jsonwriter.hpp DESTINATION ${build_include_dir}/storage/model/properties/traversers)
-FILE(COPY ${include_dir}/storage/model/properties/all.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/bool.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/null.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/float.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/double.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/int32.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/int64.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/string.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/array.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/floating.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/number.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/integral.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/property_family.hpp DESTINATION ${build_include_dir}/storage/model/properties)
-FILE(COPY ${include_dir}/storage/model/properties/utils/math_operations.hpp DESTINATION ${build_include_dir}/storage/model/properties/utils)
-FILE(COPY ${include_dir}/storage/model/properties/utils/unary_negation.hpp DESTINATION ${build_include_dir}/storage/model/properties/utils)
-FILE(COPY ${include_dir}/storage/model/properties/utils/modulo.hpp DESTINATION ${build_include_dir}/storage/model/properties/utils)
-
-
-FILE(COPY ${include_dir}/storage/model/edge_model.hpp DESTINATION ${build_include_dir}/storage/model)
-FILE(COPY ${include_dir}/storage/model/property_model.hpp DESTINATION ${build_include_dir}/storage/model)
-FILE(COPY ${include_dir}/storage/model/vertex_model.hpp DESTINATION ${build_include_dir}/storage/model)
-FILE(COPY ${include_dir}/storage/model/edge_list.hpp DESTINATION ${build_include_dir}/storage/model)
-
-FILE(COPY ${include_dir}/storage/label/label.hpp DESTINATION ${build_include_dir}/storage/label)
-FILE(COPY ${include_dir}/storage/label/label_collection.hpp DESTINATION ${build_include_dir}/storage/label)
-FILE(COPY ${include_dir}/storage/label/label_store.hpp DESTINATION ${build_include_dir}/storage/label)
-
-FILE(COPY ${include_dir}/storage/indexes/index_record.hpp DESTINATION ${build_include_dir}/storage/indexes)
-FILE(COPY ${include_dir}/storage/indexes/index_base.hpp DESTINATION ${build_include_dir}/storage/indexes)
-FILE(COPY ${include_dir}/storage/indexes/impl/nonunique_unordered_index.hpp DESTINATION ${build_include_dir}/storage/indexes/impl)
-FILE(COPY ${include_dir}/storage/indexes/index_holder.hpp DESTINATION ${build_include_dir}/storage/indexes)
-FILE(COPY ${include_dir}/storage/indexes/index_definition.hpp DESTINATION ${build_include_dir}/storage/indexes)
-FILE(COPY ${include_dir}/storage/indexes/index_update.hpp DESTINATION ${build_include_dir}/storage/indexes)
-
-FILE(COPY ${include_dir}/storage/garbage/delete_sensitive.hpp DESTINATION ${build_include_dir}/storage/garbage)
-FILE(COPY ${include_dir}/storage/garbage/garbage.hpp DESTINATION ${build_include_dir}/storage/garbage)
-
-FILE(COPY ${include_dir}/utils/sys.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/char_str.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/void.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/array_store.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/bswap.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/stacktrace.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/auto_scope.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/assert.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/reference_wrapper.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/underlying_cast.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/total_ordering.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/crtp.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/placeholder.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/likely.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/cpu_relax.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/counters/atomic_counter.hpp DESTINATION ${build_include_dir}/utils/counters)
-FILE(COPY ${include_dir}/utils/counters/simple_counter.hpp DESTINATION ${build_include_dir}/utils/counters)
-FILE(COPY ${include_dir}/utils/random/fast_binomial.hpp DESTINATION ${build_include_dir}/utils/random)
-FILE(COPY ${include_dir}/utils/random/xorshift128plus.hpp DESTINATION ${build_include_dir}/utils/random)
-FILE(COPY ${include_dir}/utils/exceptions/basic_exception.hpp DESTINATION ${build_include_dir}/utils/exceptions)
-FILE(COPY ${include_dir}/utils/datetime/timestamp.hpp DESTINATION ${build_include_dir}/utils/datetime)
-FILE(COPY ${include_dir}/utils/datetime/datetime_error.hpp DESTINATION ${build_include_dir}/utils/datetime)
-FILE(COPY ${include_dir}/utils/types/byte.hpp DESTINATION ${build_include_dir}/utils/types)
-FILE(COPY ${include_dir}/utils/option_ptr.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/option.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/border.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/order.hpp DESTINATION ${build_include_dir}/utils)
-FILE(COPY ${include_dir}/utils/numerics/saturate.hpp DESTINATION ${build_include_dir}/utils/numerics)
-
-FILE(COPY ${include_dir}/utils/iterator/iterator_base.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/virtual_iter.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/iterator.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/composable.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/count.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/accessor.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/combined.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/count.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/filter.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/flat_map.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/for_all.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/inspect.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/iterator_accessor.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/lambda_iterator.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/limited_map.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/map.hpp DESTINATION ${build_include_dir}/utils/iterator)
-FILE(COPY ${include_dir}/utils/iterator/range_iterator.hpp DESTINATION ${build_include_dir}/utils/iterator)
-
-FILE(COPY ${include_dir}/communication/communication.hpp DESTINATION ${build_include_dir}/communication)
-FILE(COPY ${include_dir}/communication/bolt/v1/config.hpp DESTINATION ${build_include_dir}/communication/bolt/v1)
-FILE(COPY ${include_dir}/communication/bolt/v1/serialization/record_stream.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/serialization)
-FILE(COPY ${include_dir}/communication/bolt/v1/serialization/bolt_serializer.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/serialization)
-FILE(COPY ${include_dir}/communication/bolt/v1/transport/bolt_encoder.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
-FILE(COPY ${include_dir}/communication/bolt/v1/transport/chunked_buffer.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
-FILE(COPY ${include_dir}/communication/bolt/v1/transport/chunked_encoder.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
-FILE(COPY ${include_dir}/communication/bolt/v1/transport/socket_stream.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
-FILE(COPY ${include_dir}/communication/bolt/v1/transport/stream_error.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
-FILE(COPY ${include_dir}/communication/bolt/v1/packing/codes.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/packing)
-FILE(COPY ${include_dir}/communication/bolt/v1/messaging/codes.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/messaging)
-
-FILE(COPY ${include_dir}/io/network/socket.hpp DESTINATION ${build_include_dir}/io/network)
-FILE(COPY ${include_dir}/io/network/addrinfo.hpp DESTINATION ${build_include_dir}/io/network)
-FILE(COPY ${include_dir}/io/network/network_error.hpp DESTINATION ${build_include_dir}/io/network)
-FILE(COPY ${include_dir}/io/network/socket.hpp DESTINATION ${build_include_dir}/io/network)
-
-FILE(COPY ${include_dir}/logging/default.hpp DESTINATION ${build_include_dir}/logging)
-FILE(COPY ${include_dir}/logging/log.hpp DESTINATION ${build_include_dir}/logging)
-FILE(COPY ${include_dir}/logging/logger.hpp DESTINATION ${build_include_dir}/logging)
-FILE(COPY ${include_dir}/logging/levels.hpp DESTINATION ${build_include_dir}/logging)
-
-FILE(COPY ${include_dir}/snapshot/snapshot_engine.hpp DESTINATION ${build_include_dir}/snapshot)
-# -----------------------------------------------------------------------------
-
-# add all cpp file recursive into sourceFiles varibale
-# FILE(GLOB_RECURSE sourceFiles ${src_dir}/*.cpp)
-# print list of source files
-# MESSAGE(STATUS "All source files are: ${sourceFiles}")
 
 # debug flags
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
@@ -418,16 +257,6 @@ message(STATUS "TESTS binaries: ${TESTS}")
 option(BENCHMARK "Build benchmark binaries" ON)
 message(STATUS "BENCHMARK binaries: ${BENCHMARK}")
 # -- binaries -----------------------------------------------------------------
-# -- barrier - this is the way how the engine is isolated so it can be shipped
-# wherever, the code is completely hidden behind the barrier, during the
-# development the barrier can be turned off because it is much easier to
-# debug
-option(BARRIER "Barrier" ON)
-message(STATUS "BARRIER: ${BARRIER} (Source code isolation)")
-if(BARRIER)
-    add_definitions( -DBARRIER )
-endif()
-# -- barrier ------------------------------------------------------------------
 # -- configure defines --------------------------------------------------------
 
 # -- includes -----------------------------------------------------------------
@@ -435,7 +264,7 @@ include_directories(${CMAKE_SOURCE_DIR}/include)
 include_directories(${src_dir})
 include_directories(${build_include_dir})
 include_directories(${fmt_source_dir})
-include_directories(${yaml_source_dir}/include)
+include_directories(${yaml_include_dir})
 include_directories(${http_parser_source_dir})
 include_directories(${lexertl_dir})
 include_directories(${libuv_source_dir}/include)
@@ -461,7 +290,6 @@ set(memgraph_src_files
     ${src_dir}/utils/string/join.cpp
     ${src_dir}/utils/string/file.cpp
     ${src_dir}/utils/numerics/saturate.cpp
-    ${src_dir}/query_engine/util.cpp
     ${src_dir}/communication/bolt/v1/bolt.cpp
     ${src_dir}/communication/bolt/v1/states.cpp
     ${src_dir}/communication/bolt/v1/session.cpp
@@ -483,6 +311,7 @@ set(memgraph_src_files
     ${src_dir}/storage/label/label.cpp
     ${src_dir}/storage/label/label_collection.cpp
     ${src_dir}/storage/label/label_store.cpp
+    ${src_dir}/storage/label/labels_writer.cpp
     ${src_dir}/storage/edge_type/edge_type.cpp
     ${src_dir}/storage/edge_type/edge_type_store.cpp
     ${src_dir}/storage/model/properties/null.cpp
@@ -532,15 +361,6 @@ add_library(memgraph STATIC ${memgraph_src_files})
 add_library(memgraph_pic STATIC ${memgraph_src_files})
 set_property(TARGET memgraph_pic PROPERTY POSITION_INDEPENDENT_CODE TRUE)
 
-if (BARRIER)
-    # create static barrier lib
-    add_library(barrier STATIC ${memgraph_src_files})
-
-    # create pic static barrier lib
-    add_library(barrier_pic STATIC ${memgraph_src_files})
-    set_property(TARGET barrier_pic PROPERTY POSITION_INDEPENDENT_CODE TRUE)
-endif()
-
 # tests
 if (TESTS)
     enable_testing()
@@ -584,12 +404,7 @@ message(STATUS "Release flags: ${CMAKE_CXX_FLAGS_RELEASE}")
 if (MEMGRAPH)
     add_executable(${MEMGRAPH_BUILD_NAME} ${src_dir}/memgraph_bolt.cpp)
 
-    if (BARRIER)
+    target_link_libraries(${MEMGRAPH_BUILD_NAME} memgraph)
-        target_link_libraries(${MEMGRAPH_BUILD_NAME} barrier)
-    elseif (NOT BARRIER)
-        target_link_libraries(${MEMGRAPH_BUILD_NAME} memgraph)
-    endif ()
-
     target_link_libraries(${MEMGRAPH_BUILD_NAME} stdc++fs)
     target_link_libraries(${MEMGRAPH_BUILD_NAME} Threads::Threads)
     target_link_libraries(${MEMGRAPH_BUILD_NAME} cypher_lib)

cmake/copy_includes.cmake

@@ -0,0 +1,187 @@
+# -----------------------------------------------------------------------------
+# COPY header files required by query engine (query compiler)
+# TODO: create a copy function, COPY_RELATIVE(base relative_path dst)
+# TODO: somehow automate (in destination dir should be only required include files)
+FILE(COPY ${include_dir}/database/db.hpp DESTINATION ${build_include_dir}/database)
+FILE(COPY ${include_dir}/database/db_transaction.hpp DESTINATION ${build_include_dir}/database)
+FILE(COPY ${include_dir}/database/db_accessor.hpp DESTINATION ${build_include_dir}/database)
+
+FILE(COPY ${include_dir}/storage/common.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/graph.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/edge.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/edge_record.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/vertex_record.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/edge_accessor.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/edges.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/vertices.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/vertex.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/vertex_accessor.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/record_accessor.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/locking/record_lock.hpp DESTINATION ${build_include_dir}/storage/locking)
+FILE(COPY ${include_dir}/storage/locking/lock_status.hpp DESTINATION ${build_include_dir}/storage/locking)
+FILE(COPY ${include_dir}/storage/edge_type/edge_type_store.hpp DESTINATION ${build_include_dir}/storage/edge_type)
+FILE(COPY ${include_dir}/storage/edge_type/edge_type.hpp DESTINATION ${build_include_dir}/storage/edge_type)
+FILE(COPY ${include_dir}/storage/label/label_store.hpp DESTINATION ${build_include_dir}/storage/label)
+FILE(COPY ${include_dir}/storage/label/labels_writer.hpp DESTINATION ${build_include_dir}/storage/label)
+FILE(COPY ${include_dir}/storage/model/edge_map.hpp DESTINATION ${build_include_dir}/storage/model)
+FILE(COPY ${include_dir}/storage/model/properties/flags.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/stored_property.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/property_holder.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/type_group_edge.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/type_group_vertex.hpp DESTINATION ${build_include_dir}/storage)
+FILE(COPY ${include_dir}/storage/edge_x_vertex.hpp DESTINATION ${build_include_dir}/storage)
+
+FILE(COPY ${include_dir}/query/util.hpp DESTINATION ${build_include_dir}/query)
+FILE(COPY ${include_dir}/query/i_plan_cpu.hpp DESTINATION ${build_include_dir}/query)
+FILE(COPY ${include_dir}/query/strip/stripped.hpp DESTINATION ${build_include_dir}/query/strip)
+
+FILE(COPY ${include_dir}/data_structures/concurrent/concurrent_map.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+FILE(COPY ${include_dir}/data_structures/concurrent/concurrent_set.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+FILE(COPY ${include_dir}/data_structures/concurrent/concurrent_list.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+FILE(COPY ${include_dir}/data_structures/concurrent/common.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+FILE(COPY ${include_dir}/data_structures/concurrent/skiplist.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+FILE(COPY ${include_dir}/data_structures/concurrent/skiplist_gc.hpp DESTINATION ${build_include_dir}/data_structures/concurrent)
+FILE(COPY ${include_dir}/data_structures/map/rh_hashmultimap.hpp DESTINATION ${build_include_dir}/data_structures/map)
+FILE(COPY ${include_dir}/data_structures/map/rh_common.hpp DESTINATION ${build_include_dir}/data_structures/map)
+
+FILE(COPY ${include_dir}/data_structures/bitset/dynamic_bitset.hpp DESTINATION ${build_include_dir}/data_structures/bitset)
+
+FILE(COPY ${include_dir}/threading/sync/lockable.hpp DESTINATION ${build_include_dir}/threading/sync)
+FILE(COPY ${include_dir}/threading/sync/spinlock.hpp DESTINATION ${build_include_dir}/threading/sync)
+FILE(COPY ${include_dir}/threading/sync/futex.hpp DESTINATION ${build_include_dir}/threading/sync)
+FILE(COPY ${include_dir}/threading/sync/lock_timeout_error.hpp DESTINATION ${build_include_dir}/threading/sync)
+
+FILE(COPY ${include_dir}/memory/freelist.hpp DESTINATION ${build_include_dir}/memory)
+FILE(COPY ${include_dir}/memory/lazy_gc.hpp DESTINATION ${build_include_dir}/memory)
+
+FILE(COPY ${include_dir}/mvcc/cre_exp.hpp DESTINATION ${build_include_dir}/mvcc)
+FILE(COPY ${include_dir}/mvcc/hints.hpp DESTINATION ${build_include_dir}/mvcc)
+FILE(COPY ${include_dir}/mvcc/id.hpp DESTINATION ${build_include_dir}/mvcc)
+FILE(COPY ${include_dir}/mvcc/mvcc_error.hpp DESTINATION ${build_include_dir}/mvcc)
+FILE(COPY ${include_dir}/mvcc/record.hpp DESTINATION ${build_include_dir}/mvcc)
+FILE(COPY ${include_dir}/mvcc/serialization_error.hpp DESTINATION ${build_include_dir}/mvcc)
+FILE(COPY ${include_dir}/mvcc/version.hpp DESTINATION ${build_include_dir}/mvcc)
+FILE(COPY ${include_dir}/mvcc/version_list.hpp DESTINATION ${build_include_dir}/mvcc)
+
+FILE(COPY ${include_dir}/transactions/transaction.hpp DESTINATION ${build_include_dir}/transactions)
+FILE(COPY ${include_dir}/transactions/lock_store.hpp DESTINATION ${build_include_dir}/transactions)
+FILE(COPY ${include_dir}/transactions/snapshot.hpp DESTINATION ${build_include_dir}/transactions)
+FILE(COPY ${include_dir}/transactions/commit_log.hpp DESTINATION ${build_include_dir}/transactions)
+FILE(COPY ${include_dir}/transactions/engine.hpp DESTINATION ${build_include_dir}/transactions)
+FILE(COPY ${include_dir}/transactions/transaction_store.hpp DESTINATION ${build_include_dir}/transactions)
+FILE(COPY ${include_dir}/transactions/transaction_read.hpp DESTINATION ${build_include_dir}/transactions)
+
+FILE(COPY ${include_dir}/storage/model/properties/properties.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/property.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/json_writer.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/all.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/bool.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/null.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/float.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/double.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/int32.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/int64.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/string.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/array.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/floating.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/number.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/integral.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/property_family.hpp DESTINATION ${build_include_dir}/storage/model/properties)
+FILE(COPY ${include_dir}/storage/model/properties/utils/math_operations.hpp DESTINATION ${build_include_dir}/storage/model/properties/utils)
+FILE(COPY ${include_dir}/storage/model/properties/utils/unary_negation.hpp DESTINATION ${build_include_dir}/storage/model/properties/utils)
+FILE(COPY ${include_dir}/storage/model/properties/utils/modulo.hpp DESTINATION ${build_include_dir}/storage/model/properties/utils)
+
+
+FILE(COPY ${include_dir}/storage/model/edge_model.hpp DESTINATION ${build_include_dir}/storage/model)
+FILE(COPY ${include_dir}/storage/model/property_model.hpp DESTINATION ${build_include_dir}/storage/model)
+FILE(COPY ${include_dir}/storage/model/vertex_model.hpp DESTINATION ${build_include_dir}/storage/model)
+FILE(COPY ${include_dir}/storage/model/edge_list.hpp DESTINATION ${build_include_dir}/storage/model)
+
+FILE(COPY ${include_dir}/storage/label/label.hpp DESTINATION ${build_include_dir}/storage/label)
+FILE(COPY ${include_dir}/storage/label/label_collection.hpp DESTINATION ${build_include_dir}/storage/label)
+FILE(COPY ${include_dir}/storage/label/label_store.hpp DESTINATION ${build_include_dir}/storage/label)
+
+FILE(COPY ${include_dir}/storage/indexes/index_record.hpp DESTINATION ${build_include_dir}/storage/indexes)
+FILE(COPY ${include_dir}/storage/indexes/index_base.hpp DESTINATION ${build_include_dir}/storage/indexes)
+FILE(COPY ${include_dir}/storage/indexes/impl/nonunique_unordered_index.hpp DESTINATION ${build_include_dir}/storage/indexes/impl)
+FILE(COPY ${include_dir}/storage/indexes/index_holder.hpp DESTINATION ${build_include_dir}/storage/indexes)
+FILE(COPY ${include_dir}/storage/indexes/index_definition.hpp DESTINATION ${build_include_dir}/storage/indexes)
+FILE(COPY ${include_dir}/storage/indexes/index_update.hpp DESTINATION ${build_include_dir}/storage/indexes)
+
+FILE(COPY ${include_dir}/storage/garbage/delete_sensitive.hpp DESTINATION ${build_include_dir}/storage/garbage)
+FILE(COPY ${include_dir}/storage/garbage/garbage.hpp DESTINATION ${build_include_dir}/storage/garbage)
+
+FILE(COPY ${include_dir}/utils/string_buffer.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/handle_write.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/sys.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/char_str.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/void.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/array_store.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/bswap.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/stacktrace.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/auto_scope.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/assert.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/reference_wrapper.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/underlying_cast.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/total_ordering.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/crtp.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/placeholder.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/likely.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/cpu_relax.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/counters/atomic_counter.hpp DESTINATION ${build_include_dir}/utils/counters)
+FILE(COPY ${include_dir}/utils/counters/simple_counter.hpp DESTINATION ${build_include_dir}/utils/counters)
+FILE(COPY ${include_dir}/utils/random/fast_binomial.hpp DESTINATION ${build_include_dir}/utils/random)
+FILE(COPY ${include_dir}/utils/random/xorshift128plus.hpp DESTINATION ${build_include_dir}/utils/random)
+FILE(COPY ${include_dir}/utils/exceptions/basic_exception.hpp DESTINATION ${build_include_dir}/utils/exceptions)
+FILE(COPY ${include_dir}/utils/datetime/timestamp.hpp DESTINATION ${build_include_dir}/utils/datetime)
+FILE(COPY ${include_dir}/utils/datetime/datetime_error.hpp DESTINATION ${build_include_dir}/utils/datetime)
+FILE(COPY ${include_dir}/utils/types/byte.hpp DESTINATION ${build_include_dir}/utils/types)
+FILE(COPY ${include_dir}/utils/option_ptr.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/option.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/border.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/order.hpp DESTINATION ${build_include_dir}/utils)
+FILE(COPY ${include_dir}/utils/numerics/saturate.hpp DESTINATION ${build_include_dir}/utils/numerics)
+
+FILE(COPY ${include_dir}/utils/iterator/iterator_base.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/virtual_iter.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/iterator.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/composable.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/count.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/accessor.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/combined.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/count.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/filter.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/flat_map.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/for_all.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/inspect.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/iterator_accessor.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/lambda_iterator.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/limited_map.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/map.hpp DESTINATION ${build_include_dir}/utils/iterator)
+FILE(COPY ${include_dir}/utils/iterator/range_iterator.hpp DESTINATION ${build_include_dir}/utils/iterator)
+
+FILE(COPY ${include_dir}/communication/communication.hpp DESTINATION ${build_include_dir}/communication)
+FILE(COPY ${include_dir}/communication/bolt/v1/config.hpp DESTINATION ${build_include_dir}/communication/bolt/v1)
+FILE(COPY ${include_dir}/communication/bolt/v1/serialization/record_stream.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/serialization)
+FILE(COPY ${include_dir}/communication/bolt/v1/serialization/bolt_serializer.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/serialization)
+FILE(COPY ${include_dir}/communication/bolt/v1/transport/bolt_encoder.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
+FILE(COPY ${include_dir}/communication/bolt/v1/transport/chunked_buffer.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
+FILE(COPY ${include_dir}/communication/bolt/v1/transport/chunked_encoder.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
+FILE(COPY ${include_dir}/communication/bolt/v1/transport/socket_stream.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
+FILE(COPY ${include_dir}/communication/bolt/v1/transport/stream_error.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/transport)
+FILE(COPY ${include_dir}/communication/bolt/v1/packing/codes.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/packing)
+FILE(COPY ${include_dir}/communication/bolt/v1/messaging/codes.hpp DESTINATION ${build_include_dir}/communication/bolt/v1/messaging)
+
+FILE(COPY ${include_dir}/io/network/socket.hpp DESTINATION ${build_include_dir}/io/network)
+FILE(COPY ${include_dir}/io/network/addrinfo.hpp DESTINATION ${build_include_dir}/io/network)
+FILE(COPY ${include_dir}/io/network/network_error.hpp DESTINATION ${build_include_dir}/io/network)
+FILE(COPY ${include_dir}/io/network/socket.hpp DESTINATION ${build_include_dir}/io/network)
+
+FILE(COPY ${include_dir}/logging/default.hpp DESTINATION ${build_include_dir}/logging)
+FILE(COPY ${include_dir}/logging/log.hpp DESTINATION ${build_include_dir}/logging)
+FILE(COPY ${include_dir}/logging/logger.hpp DESTINATION ${build_include_dir}/logging)
+FILE(COPY ${include_dir}/logging/levels.hpp DESTINATION ${build_include_dir}/logging)
+FILE(COPY ${include_dir}/logging/loggable.hpp DESTINATION ${build_include_dir}/logging)
+
+FILE(COPY ${include_dir}/snapshot/snapshot_engine.hpp DESTINATION ${build_include_dir}/snapshot)
+# -----------------------------------------------------------------------------

config/memgraph.yaml

@@ -1,8 +1,27 @@
+###########################
+# MEMGRAPH DEFAULT CONFIG #
+###########################
+
+# NOTE: all paths are relative to the run folder
+# (where the executable is runned)
+
+# path to the codes which will be compiled
 compile_cpu_path: "./compiled/cpu/"
-template_cpu_cpp_path: "./template/template_code_cpu.cpp"
+
-barrier_template_cpu_cpp_path: "./template/barrier_template_code_cpu.cpp"
+# path to the template (cpp) for codes generation
+template_cpu_cpp_path: "./template/template_code_cpu_cpp"
+
+# path to the template (hpp) for codes generation
 template_cpu_hpp_path: "./template/template_code_cpu.hpp"
+
+# path to the folder with snapshots
 snapshots_path: "snapshots"
+
+# leaning cycle interval
 cleaning_cycle_sec: "300"
+
+# snapshot cycle interval
 snapshot_cycle_sec: "60"
+
+# max number of snapshots which will be kept on the disk at some point
 max_retained_snapshots: "3"

docker/memgraph.dockerfile

@@ -1,33 +0,0 @@
-FROM ubuntu:16.04
-
-# apt-get setup
-RUN apt-get update \
-    && apt-get install -y cmake git python clang wget \
-    && apt-get install -y check libpcre3 libpcre3-dev libjemalloc-dev \
-                          libjemalloc1 build-essential libtool automake \
-                          autoconf pkg-config
-#    && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
-
-# prepare source
-RUN mkdir -p /memgraph/build
-RUN mkdir -p /memgraph/libs
-COPY libs/setup.sh /memgraph/libs/setup.sh
-COPY src /memgraph/src
-COPY tests /memgraph/tests
-COPY CMakeLists.txt /memgraph/CMakeLists.txt
-
-# setup libs
-WORKDIR /memgraph/libs
-RUN ./setup.sh
-
-# build
-WORKDIR /memgraph/build
-RUN cmake -DCMAKE_C_COMPILER=clang \
-          -DCMAKE_CXX_COMPILER=clang++ \
-          -DRUNTIME_ASSERT=OFF \
-          -DTHROW_EXCEPTION_ON_ERROR=OFF \
-          -DNDEBUG=OFF ..
-RUN make
-
-# run
-CMD /memgraph/build/memgraph 7474

example/.gitignore

@@ -0,0 +1 @@
+*.out

example/xorshift.cpp

@@ -5,6 +5,7 @@
 #include <array>
 #include <atomic>
 #include <thread>
+#include <cassert>
 
 #include <sys/ioctl.h>
 #include <unistd.h>
@@ -47,6 +48,7 @@ int main(void)
 
     auto max = std::accumulate(buckets.begin(), buckets.end(), 0u,
         [](auto& acc, auto& x) { return std::max(acc, x.load()); });
+    assert(max != 0u);
 
     std::cout << std::fixed;
 

include/barrier/barrier.hpp

@@ -1,588 +0,0 @@
-#pragma once
-
-#ifdef BARRIER
-
-#include "barrier/common.hpp"
-
-// This namespace is holding header parts of barrier classes. Barrier class
-// object is in fact object from other class inside memgraph. Main purpose of
-// barrier classes is to hide real classes from outside viewers. This header
-// should be only to be included from memgraph into generated/compiled query.
-// And this header must ensure that it defines all classes and methods required
-// for querys.
-namespace barrier
-{
-// Every class from database which must be visible to outside the barrier should
-// have there barrier class defined here.
-
-// ************ Here should be forward declarations of Sized barrier classes
-// ACCESSORS
-class DbAccessor;
-class VertexAccessor;
-class EdgeAccessor;
-
-// GENERIC ITERATORS
-class VertexIterator;
-class EdgeIterator;
-
-// TYPED ITERATORS
-class VertexAccessIterator;
-class EdgeAccessIterator;
-class OutEdgesIterator;
-class InEdgesIterator;
-
-// PROPERTY
-class VertexPropertyKey;
-class EdgePropertyKey;
-template <class T>
-class VertexPropertyType;
-template <class T>
-class EdgePropertyType;
-
-// BOLT
-template <class Stream>
-class RecordStream;
-
-// ************ Here should be forward declarations of Unsized barrier classes
-// COMMON
-class Db;
-class Label;
-class EdgeType;
-
-// GENERIC INDEXES
-template <class K>
-class VertexIndex;
-template <class K>
-class EdgeIndex;
-
-// PROPERTY
-class VertexPropertyFamily;
-class EdgePropertyFamily;
-
-// ************* Here should be defined usings
-using label_ref_t = ReferenceWrapper<const Label>;
-using VertexStoredProperty = PropertyHolder<VertexPropertyKey>;
-using EdgeStoredProperty = PropertyHolder<EdgePropertyKey>;
-
-// ************ Here should be definitions of Sized barrier classes
-// Original class should have Sized barrier class if it can't be Unsized.
-// Sized barrier classes should:
-// --Have same name as original class.
-// --Inherit Sized class from common.hpp as public. Blueprint:
-//      class class_name: public Sized<size_of_t,aligment_of_t>
-// --Sized template arguments must be hardcoded numbers equal to sizeof(T) and
-//   alignof(T) where T is original class.
-// --It should have undefined public constructor which is specialized in .cpp
-//   Blueprint:
-//   public:
-//      template<class T> class_name(T &&d);
-// --It should delete or specify following methods depending on the behavior of
-//   the original class:
-//   public:
-//      class_name(const class_name &other);
-//      class_name(class_name &&other);
-//      ~class_name();
-//      class_name &operator=(const class_name &other);
-//      class_name &operator=(class_name &&other);
-// --It should specify public methods which can be called on the original class.
-//
-// Blueprint:
-// class class_name : public Sized<,>
-// {
-// public:
-//     template <class T>
-//     class_name(T &&d);
-//
-//     class_name(const class_name &other);
-//     class_name(class_name &&other);
-//     ~class_name();
-//
-//     class_name &operator=(const class_name &other);
-//     class_name &operator=(class_name &&other);
-//
-// };
-
-// TODO: Extract methods od RecordAccessor for VertexAccessor and EdgeAccessor
-// into joined class.
-class VertexAccessor : private Sized<24, 8>
-{
-public:
-    template <class T>
-    VertexAccessor(T &&d);
-
-    VertexAccessor(VertexAccessor &other);
-    VertexAccessor(const VertexAccessor &other);
-    VertexAccessor(VertexAccessor &&other);
-    VertexAccessor(VertexAccessor const &&other);
-    ~VertexAccessor();
-
-    VertexAccessor &operator=(const VertexAccessor &other);
-    VertexAccessor &operator=(VertexAccessor &&other);
-
-    bool isolated() const;
-
-    size_t out_degree() const;
-
-    size_t in_degree() const;
-
-    size_t degree() const;
-
-    bool add_label(const Label &label);
-
-    bool remove_label(const Label &label);
-
-    bool has_label(const Label &label) const;
-
-    const std::vector<label_ref_t> &labels() const;
-
-    OutEdgesIterator out() const;
-
-    InEdgesIterator in() const;
-
-    bool in_contains(VertexAccessor const &other) const;
-
-    bool empty() const;
-
-    bool fill() const;
-
-    const Id &id() const;
-
-    VertexAccessor update() const;
-
-    void remove() const;
-
-    // template <class TG>
-    // bool contains(property_key<TG> &key) const;
-
-    const VertexStoredProperty &at(VertexPropertyFamily &key) const;
-
-    const VertexStoredProperty &at(VertexPropertyKey &key) const;
-
-    template <class V>
-    OptionPtr<const V> at(VertexPropertyType<V> &key) const;
-
-    void set(VertexPropertyKey &key, Property &&value);
-
-    void clear(VertexPropertyKey &key);
-
-    void clear(VertexPropertyFamily &key);
-
-    template <class Handler>
-    void accept(Handler &handler) const;
-
-    explicit operator bool() const;
-
-    friend bool operator==(const VertexAccessor &a, const VertexAccessor &b);
-
-    friend bool operator!=(const VertexAccessor &a, const VertexAccessor &b);
-};
-
-class EdgeAccessor : private Sized<24, 8>
-{
-public:
-    template <class T>
-    EdgeAccessor(T &&d);
-
-    EdgeAccessor(EdgeAccessor &other);
-    EdgeAccessor(const EdgeAccessor &other);
-    EdgeAccessor(EdgeAccessor &&other);
-    EdgeAccessor(EdgeAccessor const &&other);
-    ~EdgeAccessor();
-
-    EdgeAccessor &operator=(const EdgeAccessor &other);
-    EdgeAccessor &operator=(EdgeAccessor &&other);
-
-    void edge_type(const EdgeType &edge_type);
-
-    const EdgeType &edge_type() const;
-
-    const VertexAccessor from() const;
-
-    const VertexAccessor to() const;
-
-    bool empty() const;
-
-    bool fill() const;
-
-    const Id &id() const;
-
-    EdgeAccessor update() const;
-
-    void remove() const;
-
-    const EdgeStoredProperty &at(EdgePropertyFamily &key) const;
-
-    const EdgeStoredProperty &at(EdgePropertyKey &key) const;
-
-    template <class V>
-    OptionPtr<const V> at(EdgePropertyType<V> &key) const;
-
-    void set(EdgePropertyKey &key, Property &&value);
-
-    void clear(EdgePropertyKey &key);
-
-    void clear(EdgePropertyFamily &key);
-
-    template <class Handler>
-    void accept(Handler &handler) const;
-
-    explicit operator bool() const;
-
-    friend bool operator==(const EdgeAccessor &a, const EdgeAccessor &b);
-
-    friend bool operator!=(const EdgeAccessor &a, const EdgeAccessor &b);
-};
-
-class DbAccessor : protected Sized<40, 8>
-{
-public:
-    DbAccessor(Db &d);
-
-    DbAccessor(const DbAccessor &other) = delete;
-    DbAccessor(DbAccessor &&other) = delete;
-    ~DbAccessor();
-
-    DbAccessor &operator=(const DbAccessor &other) = delete;
-    DbAccessor &operator=(DbAccessor &&other) = delete;
-
-    VertexAccessIterator vertex_access();
-
-    Option<const VertexAccessor> vertex_find(const Id &id);
-
-    VertexAccessor vertex_insert();
-
-    EdgeAccessIterator edge_access();
-
-    Option<const EdgeAccessor> edge_find(const Id &id);
-
-    EdgeAccessor edge_insert(VertexAccessor const &from,
-                             VertexAccessor const &to);
-
-    const Label &label_find_or_create(const char *name);
-
-    bool label_contains(const char *name);
-
-    const EdgeType &type_find_or_create(const char *name);
-
-    bool type_contains(const char *name);
-
-    VertexPropertyFamily &vertex_property_family_get(const std::string &name);
-
-    EdgePropertyFamily &edge_property_family_get(const std::string &name);
-
-    VertexPropertyKey vertex_property_key(const std::string &name, Type type);
-
-    EdgePropertyKey edge_property_key(const std::string &name, Type type);
-
-    template <class T>
-    VertexPropertyType<T> vertex_property_key(const std::string &name);
-
-    template <class T>
-    EdgePropertyType<T> edge_property_key(const std::string &name);
-
-    bool commit();
-    void abort();
-};
-
-class VertexIterator
-    : public Sized<8, 8>,
-      public iter::Composable<const VertexAccessor, VertexIterator>
-{
-public:
-    template <class T>
-    VertexIterator(T &&d);
-
-    VertexIterator(const VertexIterator &other) = delete;
-    VertexIterator(VertexIterator &&other);
-    ~VertexIterator();
-    VertexIterator &operator=(const VertexIterator &other) = delete;
-    VertexIterator &operator=(VertexIterator &&other) = delete;
-
-    Option<const VertexAccessor> next();
-
-    Count count();
-};
-
-// NOTE: This large size is because of SkipList accessor which is embeded into
-// iterator. The accessor has 64 fields of pointers which is in total 512 B.
-class VertexAccessIterator
-    : public Sized<560, 8>,
-      public iter::Composable<const VertexAccessor, VertexAccessIterator>
-{
-public:
-    template <class T>
-    VertexAccessIterator(T &&d);
-
-    VertexAccessIterator(const VertexAccessIterator &other) = delete;
-    VertexAccessIterator(VertexAccessIterator &&other);
-    ~VertexAccessIterator();
-    VertexAccessIterator &operator=(const VertexAccessIterator &other) = delete;
-    VertexAccessIterator &operator=(VertexAccessIterator &&other) = delete;
-
-    Option<const VertexAccessor> next();
-
-    Count count();
-};
-
-// NOTE: This large size is because of SkipList accessor which is embeded into
-// iterator. The accessor has 64 fields of pointers which is in total 512 B.
-class EdgeAccessIterator
-    : public Sized<560, 8>,
-      public iter::Composable<const EdgeAccessor, EdgeAccessIterator>
-{
-public:
-    template <class T>
-    EdgeAccessIterator(T &&d);
-
-    EdgeAccessIterator(const EdgeAccessIterator &other) = delete;
-    EdgeAccessIterator(EdgeAccessIterator &&other);
-    ~EdgeAccessIterator();
-    EdgeAccessIterator &operator=(const EdgeAccessIterator &other) = delete;
-    EdgeAccessIterator &operator=(EdgeAccessIterator &&other) = delete;
-
-    Option<const EdgeAccessor> next();
-
-    Count count();
-};
-
-class OutEdgesIterator
-    : public Sized<48, 8>,
-      public iter::Composable<const EdgeAccessor, OutEdgesIterator>
-{
-public:
-    template <class T>
-    OutEdgesIterator(T &&d);
-
-    OutEdgesIterator(const OutEdgesIterator &other) = delete;
-    OutEdgesIterator(OutEdgesIterator &&other);
-    ~OutEdgesIterator();
-    OutEdgesIterator &operator=(const OutEdgesIterator &other) = delete;
-    OutEdgesIterator &operator=(OutEdgesIterator &&other) = delete;
-
-    Option<const EdgeAccessor> next();
-
-    Count count();
-};
-
-class InEdgesIterator
-    : public Sized<64, 8>,
-      public iter::Composable<const EdgeAccessor, InEdgesIterator>
-{
-public:
-    template <class T>
-    InEdgesIterator(T &&d);
-
-    InEdgesIterator(const InEdgesIterator &other) = delete;
-    InEdgesIterator(InEdgesIterator &&other);
-    ~InEdgesIterator();
-    InEdgesIterator &operator=(const InEdgesIterator &other) = delete;
-    InEdgesIterator &operator=(InEdgesIterator &&other) = delete;
-
-    Option<const EdgeAccessor> next();
-
-    Count count();
-};
-
-class EdgeIterator : public Sized<8, 8>,
-                     public iter::Composable<const EdgeAccessor, EdgeIterator>
-{
-public:
-    template <class T>
-    EdgeIterator(T &&d);
-
-    EdgeIterator(const EdgeIterator &other) = delete;
-    EdgeIterator(EdgeIterator &&other);
-    ~EdgeIterator();
-    EdgeIterator &operator=(const EdgeIterator &other) = delete;
-    EdgeIterator &operator=(EdgeIterator &&other) = delete;
-
-    Option<const EdgeAccessor> next();
-
-    Count count();
-
-    EdgeIterator &operator->() { return *this; }
-};
-
-class VertexPropertyKey : private Sized<8, 8>
-{
-public:
-    template <class T>
-    VertexPropertyKey(T &&d);
-
-    VertexPropertyKey(const VertexPropertyKey &other) = default;
-    VertexPropertyKey(VertexPropertyKey &&other) = default;
-    ~VertexPropertyKey();
-
-    VertexPropertyKey &operator=(const VertexPropertyKey &other) = default;
-    VertexPropertyKey &operator=(VertexPropertyKey &&other) = default;
-
-    Type get_type() const;
-};
-
-class EdgePropertyKey : private Sized<8, 8>
-{
-public:
-    template <class T>
-    EdgePropertyKey(T &&d);
-
-    EdgePropertyKey(const EdgePropertyKey &other) = default;
-    EdgePropertyKey(EdgePropertyKey &&other) = default;
-    ~EdgePropertyKey();
-
-    EdgePropertyKey &operator=(const EdgePropertyKey &other) = default;
-    EdgePropertyKey &operator=(EdgePropertyKey &&other) = default;
-
-    Type get_type() const;
-};
-
-template <class K>
-class VertexPropertyType : private Sized<8, 8>
-{
-public:
-    template <class T>
-    VertexPropertyType(T &&d);
-
-    VertexPropertyType(const VertexPropertyType &other) = default;
-    VertexPropertyType(VertexPropertyType &&other) = default;
-    ~VertexPropertyType(){};
-
-    VertexPropertyType &operator=(const VertexPropertyType &other) = default;
-    VertexPropertyType &operator=(VertexPropertyType &&other) = default;
-};
-
-template <class K>
-class EdgePropertyType : private Sized<8, 8>
-{
-public:
-    template <class T>
-    EdgePropertyType(T &&d);
-
-    EdgePropertyType(const EdgePropertyType &other) = default;
-    EdgePropertyType(EdgePropertyType &&other) = default;
-    ~EdgePropertyType(){};
-
-    EdgePropertyType &operator=(const EdgePropertyType &other) = default;
-    EdgePropertyType &operator=(EdgePropertyType &&other) = default;
-};
-
-template <class Stream>
-class RecordStream : private Sized<8, 8>
-{
-public:
-    template <class T>
-    RecordStream(T &&d);
-
-    RecordStream(const RecordStream &other) = default;
-    RecordStream(RecordStream &&other) = default;
-    ~RecordStream();
-
-    RecordStream &operator=(const RecordStream &other) = default;
-    RecordStream &operator=(RecordStream &&other) = default;
-
-    void write(const VertexAccessor &vertex);
-    void write(const EdgeAccessor &edge);
-    void write(const VertexStoredProperty &prop);
-    void write(const EdgeStoredProperty &prop);
-    void write(const Null &v);
-    void write(const Bool &prop);
-    void write(const Float &prop);
-    void write(const Double &prop);
-    void write(const Int32 &prop);
-    void write(const Int64 &prop);
-    void write(const String &prop);
-    void write(const ArrayBool &);
-    void write(const ArrayInt32 &);
-    void write(const ArrayInt64 &);
-    void write(const ArrayFloat &);
-    void write(const ArrayDouble &);
-    void write(const ArrayString &);
-
-    void write_empty_fields();
-    void write_success();
-    void write_success_empty();
-    void write_ignored();
-    void write_fields(const std::vector<std::string> &fields);
-    void write_field(const std::string &field);
-    void write_list_header(size_t size);
-    void write_record();
-    void write_meta(const std::string &type);
-    void write_failure(const std::map<std::string, std::string> &data);
-    void send();
-    void chunk();
-};
-
-// ************ Here should be definitions of Unsized barrier classes
-// Original class can be Unsized barrier class if they are only used outside the
-// barrier through reference/pointer.
-// Usized barrier classes should:
-// --Have same name as original class or somethin more specific if it is
-//   partialy specialized.
-// --Inherit Unsized class from common.hpp as protected. Blueprint:
-//      class class_name: protected Unsized
-// --It should specify public methods which can be called on the original class.
-//
-// Blueprint:
-// class class_name : protected Unsized
-// {
-// public:
-//
-// };
-
-class VertexPropertyFamily : protected Unsized
-{
-public:
-    OptionPtr<VertexIndex<std::nullptr_t>> index();
-};
-
-class EdgePropertyFamily : protected Unsized
-{
-public:
-    OptionPtr<EdgeIndex<std::nullptr_t>> index();
-};
-
-class Label : protected Unsized
-{
-public:
-    VertexIndex<std::nullptr_t> &index() const;
-};
-
-class EdgeType : protected Unsized
-{
-public:
-    friend bool operator<(const EdgeType &lhs, const EdgeType &rhs);
-
-    friend bool operator==(const EdgeType &lhs, const EdgeType &rhs);
-
-    EdgeIndex<std::nullptr_t> &index() const;
-};
-
-template <class K>
-class VertexIndex : protected Unsized
-{
-public:
-    // TODO: This iterator sometimes has known type. It can be added to this
-    // border to avoid dynamic dispatch
-    VertexIterator for_range(DbAccessor &, Border<K> from = Border<K>(),
-                             Border<K> to = Border<K>());
-
-    IndexType type();
-};
-
-template <class K>
-class EdgeIndex : protected Unsized
-{
-public:
-    // TODO: This iterator has known type. It can be added to this border to
-    // avoid dynamic dispatch
-    EdgeIterator for_range(DbAccessor &, Border<K> from = Border<K>(),
-                           Border<K> to = Border<K>());
-
-    IndexType type();
-};
-
-class Db : protected Unsized
-{
-};
-}
-
-#endif

include/barrier/common.hpp

@@ -1,142 +0,0 @@
-#pragma once
-
-#ifdef BARRIER
-
-#include <cassert>
-#include <map>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-// This shoul be the only place to include code from memgraph other than
-// barrier.cpp
-#include "mvcc/id.hpp"
-#include "storage/indexes/index_definition.hpp"
-#include "storage/model/properties/all.hpp"
-#include "storage/model/properties/property.hpp"
-#include "utils/border.hpp"
-#include "utils/iterator/iterator.hpp"
-#include "utils/option_ptr.hpp"
-#include "utils/reference_wrapper.hpp"
-
-// Contains common classes and functions for barrier.hpp and barrier.cpp.
-namespace barrier
-{
-
-// This define accepts other define which accepts property type to instantiate
-// template. Recieved define will be called for all property types.
-#define INSTANTIATE_FOR_PROPERTY(x)                                            \
-    x(Int32) x(Int64) x(Float) x(Double) x(Bool) x(String) x(ArrayInt32)       \
-        x(ArrayInt64) x(ArrayFloat) x(ArrayDouble) x(ArrayBool) x(ArrayString)
-
-// **************************** HELPER FUNCTIONS **************************** //
-// CASTS FROM& -> TO&
-template <class TO, class FROM>
-TO &ref_as(FROM &ref)
-{
-    return (*reinterpret_cast<TO *>(&ref));
-}
-
-// CASTS FROM const& -> TO const&
-template <class TO, class FROM>
-TO const &ref_as(FROM const &ref)
-{
-    return (*reinterpret_cast<TO const *>(&ref));
-}
-
-// CASTS FROM* -> TO*
-template <class TO, class FROM>
-TO *ptr_as(FROM *ref)
-{
-    return (reinterpret_cast<TO *>(ref));
-}
-
-// CASTS FROM const* -> TO const*
-template <class TO, class FROM>
-TO const *ptr_as(FROM const *ref)
-{
-    return (reinterpret_cast<TO const *>(ref));
-}
-
-// CASTS FROM&& -> TO&&
-template <class TO, class FROM>
-TO &&value_as(FROM &&ref)
-{
-    static_assert(sizeof(TO) == sizeof(FROM), "Border class size mismatch");
-    static_assert(alignof(TO) == alignof(FROM),
-                  "Border class aligment mismatch");
-    return (reinterpret_cast<TO &&>(std::move(ref)));
-}
-
-// CASTS FROM const&& -> TO const&&
-template <class TO, class FROM>
-const TO &&value_as(const FROM &&ref)
-{
-    static_assert(sizeof(TO) == sizeof(FROM), "Border class size mismatch");
-    static_assert(alignof(TO) == alignof(FROM),
-                  "Border class aligment mismatch");
-    return (reinterpret_cast<TO const &&>(std::move(ref)));
-}
-
-// Barrier classes which will be used only through reference/pointer should
-// inherit this class. Outside of barrier derived classes will be used only
-// through reference/pointer.
-class Unsized
-{
-public:
-    // Deleting following constructors/destroyers and opertators  will assure
-    // that this class/derived classes can't be created,copyed,deleted or moved.
-    // This way the other side can't "accidentaly" create/copy/destroy or move
-    // objects which inherit this class because that would be erroneous.
-    Unsized() = delete;
-    Unsized(const Unsized &other) = delete;
-    Unsized(Unsized &&other) = delete;
-    ~Unsized() = delete;
-    Unsized &operator=(const Unsized &other) = delete;
-    Unsized &operator=(Unsized &&other) = delete;
-};
-
-// Barrier classes which will be used as value should inherit this class.
-// Template accepts size_B in B of object of original class from memgraph.
-// Template accepts alignment_B in B of object of original class from memgraph.
-template <std::size_t size_B, std::size_t alignment_B>
-class Sized
-{
-protected:
-    // This will ensure that this/derived class can't be instantiated.
-    // Something outside the barrier can't "accidentaly" create this/derived
-    // type because that would be erroneous.
-    Sized() = delete;
-
-    // This constructor serves as a check for correctness of size_B and
-    // alignment_B template parametars. Derived class MUST call this constructor
-    // with T which it holds where T is original class from memgraph.
-    template <class T>
-    Sized(T &&d)
-    {
-        new (ptr_as<T>(&data)) T(std::move(d));
-        static_assert(size_B == sizeof(T), "Border class size mismatch");
-        static_assert(alignment_B == alignof(T),
-                      "Border class aligment mismatch");
-    }
-
-    // This constructor serves as a check for correctness of size_B and
-    // alignment_B template parametars. Derived class MUST call this constructor
-    // with T which it holds where T is original class from memgraph.
-    template <class T>
-    Sized(const T &&d)
-    {
-        new (ptr_as<T>(&data)) T(std::move(d));
-        static_assert(size_B == sizeof(T), "Border class size mismatch");
-        static_assert(alignment_B == alignof(T),
-                      "Border class aligment mismatch");
-    }
-
-private:
-    // Here is the aligned storage which imitates size and aligment of object of
-    // original class from memgraph.
-    typename std::aligned_storage<size_B, alignment_B>::type data;
-};
-}
-
-#endif

include/barrier/trans.hpp

@@ -1,269 +0,0 @@
-#pragma once
-
-#ifdef BARRIER
-
-#include "barrier/barrier.hpp"
-
-// This is the place for imports from memgraph .hpp
-#include "communication/bolt/v1/serialization/bolt_serializer.hpp"
-#include "communication/bolt/v1/serialization/record_stream.hpp"
-#include "database/db.hpp"
-#include "database/db_accessor.hpp"
-#include "io/network/socket.hpp"
-#include "storage/edge_type/edge_type.hpp"
-#include "storage/edge_x_vertex.hpp"
-#include "storage/label/label.hpp"
-
-// This is the place for imports from memgraph .cpp
-
-// **************************** HELPER DEFINES *******************************//
-// Creates 8 functions for transformation of refereces between types x and y.
-// Where x is a border type.
-// DANGEROUS
-#define TRANSFORM_REF(x, y)                                                    \
-    x &trans(y &l) { return ref_as<x>(l); }                                    \
-    x const &trans(y const &l) { return ref_as<x const>(l); }                  \
-    y &trans(x &l) { return ref_as<y>(l); }                                    \
-    y const &trans(x const &l) { return ref_as<y const>(l); }                  \
-    x *trans(y *l) { return ptr_as<x>(l); }                                    \
-    x const *trans(y const *l) { return ptr_as<x const>(l); }                  \
-    y *trans(x *l) { return ptr_as<y>(l); }                                    \
-    y const *trans(x const *l) { return ptr_as<y const>(l); }
-
-// Creates 4 functions for transformation of refereces between types x and y.
-// Where x is a sized border type.
-// DANGEROUS
-#define TRANSFORM_REF_SIZED(x, y)                                              \
-    y &trans(x &l) { return ref_as<y>(l._data_ref()); }                        \
-    y const &trans(x const &l)                                                 \
-    {                                                                          \
-        return ref_as<y const>(l._data_ref_const());                           \
-    }                                                                          \
-    y *trans(x *l) { return ptr_as<y>(&(l->_data_ref())); }                    \
-    y const *trans(x const *l)                                                 \
-    {                                                                          \
-        return ptr_as<y const>(&(l->_data_ref_const()));                       \
-    }
-
-// Creates 8 functions for transformation of refereces between types x and y.
-// Where both x and y are templates over T. Where x is a border type.
-// DANGEROUS
-#define TRANSFORM_REF_TEMPLATED(x, y)                                          \
-    x &trans(y &l) { return ref_as<x>(l); }                                    \
-    template <class T>                                                         \
-    x const &trans(y const &l)                                                 \
-    {                                                                          \
-        return ref_as<const x>(l);                                             \
-    }                                                                          \
-    template <class T>                                                         \
-    y &trans(x &l)                                                             \
-    {                                                                          \
-        return ref_as<y>(l);                                                   \
-    }                                                                          \
-    template <class T>                                                         \
-    y const &trans(x const &l)                                                 \
-    {                                                                          \
-        return ref_as<const y>(l);                                             \
-    }                                                                          \
-    template <class T>                                                         \
-    x *trans(y *l)                                                             \
-    {                                                                          \
-        return ptr_as<x>(l);                                                   \
-    }                                                                          \
-    template <class T>                                                         \
-    const x *trans(const y *l)                                                 \
-    {                                                                          \
-        return ptr_as<const x>(l);                                             \
-    }                                                                          \
-    template <class T>                                                         \
-    y *trans(x *l)                                                             \
-    {                                                                          \
-        return ptr_as<y>(l);                                                   \
-    }                                                                          \
-    template <class T>                                                         \
-    const y *trans(const x *l)                                                 \
-    {                                                                          \
-        return ptr_as<const y>(l);                                             \
-    }
-
-// For certain classes trans evaluates into ref which doesnt work for Sized
-// constructor. This Move forces type y.
-// DANGEROUS
-#define MOVE_CONSTRUCTOR_FORCED(x, y)                                          \
-    x::x(x &&other) : Sized(value_as<y>(std::move(other))) {}
-
-// Creates constructor x(y) where x is border type and y shpuld be his original
-// type.
-// DANGEROUS
-#define VALID_CONSTRUCTION(x, y)                                               \
-    template <>                                                                \
-    barrier::x::x(y &&d) : Sized(std::move(d))                                 \
-    {                                                                          \
-    }
-
-// Creates const constructor x(y) where x is border type and y shpuld be his
-// original type.
-// DANGEROUS
-#define VALID_CONSTRUCTION_CONST(x, y)                                         \
-    template <>                                                                \
-    barrier::x::x(y const &&d) : Sized(std::move(d))                           \
-    {                                                                          \
-    }
-
-// Creates value transformation function from original type y to border type x.
-// DANGEROUS
-#define TRANSFORM_VALUE_ONE_RAW(x, y)                                          \
-    x trans(y &&d) { return x(std::move(d)); }
-
-// Creates value transformation function and constructor from original type y to
-// border type x.
-// DANGEROUS
-#define TRANSFORM_VALUE_ONE(x, y)                                              \
-    VALID_CONSTRUCTION(x, y)                                                   \
-    x trans(y &&d) { return x(std::move(d)); }
-
-// Creates value transformation functions and constructor between border type x
-// and original type y. Only mutable values.
-// DANGEROUS
-#define TRANSFORM_VALUE_MUT(x, y)                                              \
-    TRANSFORM_VALUE_ONE(x, y)                                                  \
-    y trans(x &&d) { return value_as<y>(std::move(d)); }
-
-// Creates value transformation functions and constructors between border type x
-// and original type y.
-// DANGEROUS
-#define TRANSFORM_VALUE(x, y)                                                  \
-    TRANSFORM_VALUE_MUT(x, y)                                                  \
-    VALID_CONSTRUCTION_CONST(x, y)                                             \
-    const x trans(const y &&d) { return x(std::move(d)); }                     \
-    const y trans(const x &&d) { return value_as<const y>(std::move(d)); }
-
-// Duplicates given x to call y with x and ::x
-#define DUP(x, y) y(x, ::x)
-
-// ********************** TYPES OF AUTO
-using vertex_access_iterator_t =
-    decltype(((::DbAccessor *)(std::nullptr_t()))->vertex_access());
-
-using edge_access_iterator_t =
-    decltype(((::DbAccessor *)(std::nullptr_t()))->edge_access());
-
-using out_edge_iterator_t =
-    decltype(((::VertexAccessor *)(std::nullptr_t()))->out());
-
-using in_edge_iterator_t =
-    decltype(((::VertexAccessor *)(std::nullptr_t()))->in());
-
-// ******************** OVERLOADED trans FUNCTIONS.
-// This enclosure is the only dangerous part of barrier except of Sized class in
-// common.hpp
-namespace barrier
-{
-// Blueprint for valid transformation of references:
-// TRANSFORM_REF(, ::);
-// template <class T> TRANSFORM_REF_TEMPLATED(<T>,::<T>);
-// TODO: Strongest assurance that evertyhing is correct is for all of following
-// transformation to use DUP for defining theres transformation. This would mean
-// that names of classes exported in barrier and names from real class in
-// database are equal.
-
-// ***************** TRANSFORMS of reference and pointers
-DUP(Label, TRANSFORM_REF);
-DUP(EdgeType, TRANSFORM_REF);
-DUP(VertexPropertyFamily, TRANSFORM_REF);
-DUP(EdgePropertyFamily, TRANSFORM_REF);
-DUP(VertexAccessor, TRANSFORM_REF);
-DUP(EdgeAccessor, TRANSFORM_REF);
-DUP(Db, TRANSFORM_REF);
-DUP(DbAccessor, TRANSFORM_REF);
-TRANSFORM_REF(std::vector<label_ref_t>, std::vector<::label_ref_t>);
-TRANSFORM_REF(VertexPropertyKey,
-              ::VertexPropertyFamily::PropertyType::PropertyFamilyKey);
-TRANSFORM_REF(EdgePropertyKey,
-              ::EdgePropertyFamily::PropertyType::PropertyFamilyKey);
-TRANSFORM_REF(VertexStoredProperty, ::StoredProperty<TypeGroupVertex>);
-TRANSFORM_REF(EdgeStoredProperty, ::StoredProperty<TypeGroupEdge>);
-
-// ITERATORS
-TRANSFORM_REF(VertexIterator, ::iter::Virtual<const ::VertexAccessor>);
-TRANSFORM_REF(EdgeIterator, ::iter::Virtual<const ::EdgeAccessor>);
-TRANSFORM_REF(VertexAccessIterator, vertex_access_iterator_t);
-TRANSFORM_REF(EdgeAccessIterator, edge_access_iterator_t);
-TRANSFORM_REF(OutEdgesIterator, out_edge_iterator_t);
-TRANSFORM_REF(InEdgesIterator, in_edge_iterator_t);
-
-template <class T>
-TRANSFORM_REF_TEMPLATED(VertexIndex<T>, VertexIndexBase<T>);
-template <class T>
-TRANSFORM_REF_TEMPLATED(EdgeIndex<T>, EdgeIndexBase<T>);
-template <class T>
-TRANSFORM_REF_TEMPLATED(RecordStream<T>, ::bolt::RecordStream<T>);
-
-template <class T>
-TRANSFORM_REF_TEMPLATED(
-    VertexPropertyType<T>,
-    ::VertexPropertyFamily::PropertyType::PropertyTypeKey<T>);
-
-template <class T>
-TRANSFORM_REF_TEMPLATED(EdgePropertyType<T>,
-                        ::EdgePropertyFamily::PropertyType::PropertyTypeKey<T>);
-
-// ****************** TRANSFORMS of value
-// Blueprint for valid transformation of value:
-// TRANSFORM_VALUE(, ::);
-DUP(VertexAccessor, TRANSFORM_VALUE);
-DUP(EdgeAccessor, TRANSFORM_VALUE);
-TRANSFORM_VALUE(EdgePropertyKey,
-                ::EdgePropertyFamily::PropertyType::PropertyFamilyKey);
-TRANSFORM_VALUE(VertexPropertyKey,
-                ::VertexPropertyFamily::PropertyType::PropertyFamilyKey);
-TRANSFORM_VALUE_ONE(VertexAccessIterator, vertex_access_iterator_t);
-MOVE_CONSTRUCTOR_FORCED(VertexAccessIterator, vertex_access_iterator_t);
-TRANSFORM_VALUE_ONE(EdgeAccessIterator, edge_access_iterator_t);
-MOVE_CONSTRUCTOR_FORCED(EdgeAccessIterator, edge_access_iterator_t);
-TRANSFORM_VALUE_ONE(OutEdgesIterator, out_edge_iterator_t);
-MOVE_CONSTRUCTOR_FORCED(OutEdgesIterator, out_edge_iterator_t);
-TRANSFORM_VALUE_ONE(InEdgesIterator, in_edge_iterator_t);
-MOVE_CONSTRUCTOR_FORCED(InEdgesIterator, in_edge_iterator_t);
-TRANSFORM_VALUE_ONE(VertexIterator, ::iter::Virtual<const ::VertexAccessor>);
-MOVE_CONSTRUCTOR_FORCED(VertexIterator,
-                        ::iter::Virtual<const ::VertexAccessor>);
-TRANSFORM_VALUE_ONE(EdgeIterator, ::iter::Virtual<const ::EdgeAccessor>);
-MOVE_CONSTRUCTOR_FORCED(EdgeIterator, ::iter::Virtual<const ::EdgeAccessor>);
-
-template <class T>
-TRANSFORM_VALUE_ONE_RAW(
-    VertexPropertyType<T>,
-    ::VertexPropertyFamily::PropertyType::PropertyTypeKey<T>);
-template <class T>
-TRANSFORM_VALUE_ONE_RAW(EdgePropertyType<T>,
-                        ::EdgePropertyFamily::PropertyType::PropertyTypeKey<T>)
-
-template <class T>
-TRANSFORM_VALUE_ONE_RAW(RecordStream<T>, ::bolt::RecordStream<T>)
-
-// ********************* SPECIAL CONSTRUCTORS
-#define VertexPropertyType_constructor(x)                                      \
-    template <>                                                                \
-    template <>                                                                \
-    VertexPropertyType<x>::VertexPropertyType(                                 \
-        ::VertexPropertyFamily::PropertyType::PropertyTypeKey<x> &&d)          \
-        : Sized(std::move(d))                                                  \
-    {                                                                          \
-    }
-INSTANTIATE_FOR_PROPERTY(VertexPropertyType_constructor);
-
-#define EdgePropertyType_constructor(x)                                        \
-    template <>                                                                \
-    template <>                                                                \
-    EdgePropertyType<x>::EdgePropertyType(                                     \
-        ::EdgePropertyFamily::PropertyType::PropertyTypeKey<x> &&d)            \
-        : Sized(std::move(d))                                                  \
-    {                                                                          \
-    }
-INSTANTIATE_FOR_PROPERTY(EdgePropertyType_constructor);
-
-DbAccessor::DbAccessor(Db &db) : Sized(::DbAccessor(trans(db))) {}
-}
-
-#endif

include/communication/bolt/v1/serialization/record_stream.hpp

@@ -105,10 +105,32 @@ public:
         serializer.write_failure(data);
         chunk();
     }
-    // -- BOLT SPECIFIC METHODS -----------------------------------------------
+
+    void write_count(const size_t count)
+    {
+        write_record();
+        write_list_header(1);
+        write(Int64(count));
+        chunk();
+    }
 
     void write(const VertexAccessor &vertex) { serializer.write(vertex); }
+    void write_vertex_record(const VertexAccessor& va)
+    {
+        write_record();
+        write_list_header(1);
+        write(va);
+        chunk();
+    }
+
     void write(const EdgeAccessor &edge) { serializer.write(edge); }
+    void write_edge_record(const EdgeAccessor& ea)
+    {
+        write_record();
+        write_list_header(1);
+        write(ea);
+        chunk();
+    }
 
     void write(const StoredProperty<TypeGroupEdge> &prop)
     {

include/config/config.hpp

@@ -20,8 +20,6 @@ public:
 // -- all possible Memgraph's keys --
 constexpr const char *COMPILE_CPU_PATH = "compile_cpu_path";
 constexpr const char *TEMPLATE_CPU_CPP_PATH = "template_cpu_cpp_path";
-constexpr const char *BARRIER_TEMPLATE_CPU_CPP_PATH =
-    "barrier_template_cpu_cpp_path";
 constexpr const char *SNAPSHOTS_PATH = "snapshots_path";
 constexpr const char *CLEANING_CYCLE_SEC = "cleaning_cycle_sec";
 constexpr const char *SNAPSHOT_CYCLE_SEC = "snapshot_cycle_sec";

include/data_structures/ptr_int.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <cinttypes>
+
+#include "utils/numerics/log2.hpp"
+
+template <typename PtrT>
+struct PointerPackTraits
+{
+    // here is a place to embed something like platform specific things
+    // TODO: cover more cases
+    constexpr static int free_bits = utils::log2(alignof(PtrT));
+
+    static auto get_ptr(uintptr_t value) { return (PtrT)(value); }
+};
+
+template <typename PtrT, int IntBits, typename IntT = unsigned,
+          typename PtrTraits = PointerPackTraits<PtrT>>
+class PtrInt
+{
+private:
+    constexpr static int int_shift = PtrTraits::free_bits - IntBits;
+    constexpr static uintptr_t ptr_mask =
+        ~(uintptr_t)(((intptr_t)1 << PtrTraits::free_bits) - 1);
+    constexpr static uintptr_t int_mask =
+        (uintptr_t)(((intptr_t)1 << IntBits) - 1);
+
+    uintptr_t value {0};
+
+public:
+    PtrInt(PtrT pointer, IntT integer)
+    {
+        set_ptr(pointer);
+        set_int(integer);
+    }
+
+    auto set_ptr(PtrT pointer)
+    {
+        auto integer = static_cast<uintptr_t>(get_int());
+        auto ptr = reinterpret_cast<uintptr_t>(pointer);
+        value = (ptr_mask & ptr) | (integer << int_shift);
+    }
+
+    auto set_int(IntT integer)
+    {
+        auto ptr = reinterpret_cast<uintptr_t>(get_ptr());
+        auto int_shifted = static_cast<uintptr_t>(integer << int_shift);
+        value = (int_mask & int_shifted) | ptr;
+    }
+
+    auto get_ptr() const { return PtrTraits::get_ptr(value & ptr_mask); }
+
+    auto get_int() const { return (IntT)((value >> int_shift) & int_mask); }
+};

include/database/db_accessor.hpp

@@ -49,9 +49,11 @@ class DbAccessor
 
 public:
     DbAccessor(Db &db);
-
     DbAccessor(Db &db, tx::Transaction &t);
 
+    DbAccessor(const DbAccessor& other) = delete;
+    DbAccessor(DbAccessor&& other) = delete;
+
     //*******************VERTEX METHODS
     // Returns iterator of VertexAccessor for all vertices.
     // TODO: Implement class specaily for this return
@@ -140,6 +142,7 @@ public:
             .template type_key<T>();
     }
 
+    bool update_indexes();
     // ******************** TRANSACTION METHODS
 
     // True if commit was successful, or false if transaction was aborted.

include/database/db_transaction.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "logging/loggable.hpp"
 #include "storage/indexes/index_update.hpp"
 #include "transactions/transaction.hpp"
 
@@ -13,13 +14,23 @@ using index_updates_t = std::vector<IndexUpdate>;
 // its methods.
 // Also serves as a barrier for calling methods defined public but meant for
 // internal use. That kind of method should request DbTransaction&.
-class DbTransaction
+class DbTransaction : public Loggable
 {
     friend DbAccessor;
 
 public:
+    DbTransaction() = delete;
+    ~DbTransaction() = default; 
+
+    DbTransaction(const DbTransaction& other) = delete;
+    DbTransaction(DbTransaction&& other) = default;
+
+    DbTransaction &operator=(const DbTransaction &) = delete;
+    DbTransaction &operator=(DbTransaction &&) = default;
+
     DbTransaction(Db &db);
-    DbTransaction(Db &db, tx::Transaction &trans) : db(db), trans(trans) {}
+    DbTransaction(Db &db, tx::Transaction &trans)
+        : Loggable("DbTransaction"), db(db), trans(trans) {}
 
     // Global transactional algorithms,operations and general methods meant for
     // internal use should be here or should be routed through this object.
@@ -48,14 +59,9 @@ public:
     // with call update_indexes
     template <class TG>
     void to_update_index(typename TG::vlist_t *vlist,
-                         typename TG::record_t *record)
+                         typename TG::record_t *record);
-    {
-        index_updates.push_back(make_index_update(vlist, record));
-    }
 
     index_updates_t index_updates;
-
-    tx::Transaction &trans;
-
     Db &db;
+    tx::Transaction &trans;
 };

include/logging/loggable.hpp

@@ -5,7 +5,10 @@
 class Loggable
 {
 public:
-    Loggable(const std::string& name) : logger(logging::log->logger(name)) {}
+    Loggable(std::string &&name)
+        : logger(logging::log->logger(std::forward<std::string>(name)))
+    {
+    }
 
     virtual ~Loggable() {}
 

include/logging/logger.hpp

@@ -76,8 +76,10 @@ public:
     template <class... Args>
     void debug(Args&&... args)
     {
+#ifndef NDEBUG
 #ifndef LOG_NO_DEBUG
         emit<Debug>(std::forward<Args>(args)...);
+#endif
 #endif
     }
 

include/query/backend/cpp_old/cypher.hpp

@@ -14,13 +14,8 @@ class CypherBackend
 public:
     CypherBackend() : logger(logging::log->logger("CypherBackend"))
     {
-// load template file
+        // load template file
-#ifdef BARRIER
-        std::string template_path =
-            CONFIG(config::BARRIER_TEMPLATE_CPU_CPP_PATH);
-#else
         std::string template_path = CONFIG(config::TEMPLATE_CPU_CPP_PATH);
-#endif
         template_text = utils::read_text(fs::path(template_path));
     }
 
@@ -46,11 +41,7 @@ public:
             template_text.str(), {{"class_name", "CodeCPU"},
                             {"stripped_hash", std::to_string(stripped_hash)},
                             {"query", query},
-#ifdef BARRIER
-                            {"stream", "RecordStream<::io::Socket>"},
-#else
                             {"stream", type_name<Stream>().to_string()},
-#endif
                             {"code", cpp_traverser.code}});
 
         logger.trace("generated code: {}", generated);

include/query/engine.hpp

@@ -33,10 +33,11 @@ public:
                     "Unable to execute query (executor returned false)");
             }
             return result;
+        } catch (CypherLexicalError &e) {
+            logger.error("CypherLexicalError: {}", std::string(e.what()));
+            throw e;
         } catch (QueryEngineException &e) {
-            // in this case something fatal went wrong
             logger.error("QueryEngineException: {}", std::string(e.what()));
-            // return false;
             throw e;
         } catch (std::exception &e) {
             throw e;

include/query/hardcode/dressipi.hpp

@@ -1,123 +0,0 @@
-#pragma once
-
-#include "includes.hpp"
-
-namespace hardcode
-{
-
-// TODO: decouple hashes from the code because hashes could and should be
-// tested separately
-
-auto load_dressipi_functions(Db &db)
-{
-    query_functions_t functions;
-
-    // Query: CREATE (n {garment_id: 1234, garment_category_id: 1}) RETURN n
-    // Hash: 12139093029838549530
-    functions[12139093029838549530u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-
-    // Query: CREATE (p:profile {profile_id: 111, partner_id: 55}) RETURN p
-    // Hash: 17158428452166262783
-    functions[17158428452166262783u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-
-    // Query: MATCH (g:garment {garment_id: 1234}) SET g:FF RETURN labels(g)
-    // Hash: 11123780635391515946
-    functions[11123780635391515946u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
- 
-    // Query: MATCH (p:profile {profile_id: 111, partner_id: 55})-[s:score]-(g:garment{garment_id: 1234}) SET s.score = 1550 RETURN s.score
-    // Hash: 674581607834128909
-    functions[674581607834128909u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MATCH (g:garment {garment_id: 3456}) SET g.reveals = 50 RETURN g
-    // Hash: 2839969099736071844
-    functions[2839969099736071844u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MERGE (g1:garment {garment_id: 1234})-[r:default_outfit]-(g2:garment {garment_id: 2345}) RETURN r
-    // Hash: 3782642357973971504
-    functions[3782642357973971504u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MERGE (p:profile {profile_id: 111, partner_id: 55})-[s:score]-(g.garment {garment_id: 1234}) SET s.score=1500 RETURN s
-    // Hash: 7871009397157280694
-    functions[7871009397157280694u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MATCH (p:profile {profile_id: 111, partner_id: 55})-[s:score]-(g.garment {garment_id: 1234}) DELETE s
-    // Hash: 9459600951073026137
-    functions[9459600951073026137u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MATCH (p:profile {profile_id: 113}) DELETE p
-    // Hash: 6763665709953344106
-    functions[6763665709953344106u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MATCH (n) DETACH DELETE n
-    // Hash: 4798158026600988079
-    functions[4798158026600988079u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MATCH (p:profile) RETURN p
-    // Hash: 15599970964909894866
-    functions[15599970964909894866u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
- 
-    // Query: MATCH (g:garment) RETURN COUNT(g)
-    // Hash: 11458306387621940265
-    functions[11458306387621940265u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MATCH (g:garment {garment_id: 1234}) RETURN g
-    // Hash: 7756609649964321221
-    functions[7756609649964321221u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MATCH (p:profile {partner_id: 55}) RETURN p
-    // Hash: 17506488413143988006
-    functions[17506488413143988006u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-  
-    // Query: MATCH (n) RETURN count(n)
-    // Hash: 10510787599699014973
-    functions[10510787599699014973u] = [&db](properties_t &&args) {
-        DbAccessor t(db);
-        return t.commit();
-    };
-
-    return functions;
-}
-
-}

include/query/hardcode/includes.hpp

@@ -1,38 +0,0 @@
-#pragma once
-
-#include <cassert>
-#include <iostream>
-#include <map>
-#include <map>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "communication/bolt/v1/serialization/bolt_serializer.hpp"
-#include "communication/bolt/v1/serialization/record_stream.hpp"
-#include "database/db.hpp"
-#include "database/db.hpp"
-#include "database/db_accessor.hpp"
-#include "database/db_accessor.hpp"
-#include "io/network/socket.hpp"
-#include "mvcc/id.hpp"
-#include "query/util.hpp"
-#include "storage/edge_type/edge_type.hpp"
-#include "storage/edge_x_vertex.hpp"
-#include "storage/indexes/index_definition.hpp"
-#include "storage/label/label.hpp"
-#include "storage/model/properties/all.hpp"
-#include "storage/model/properties/property.hpp"
-#include "utils/border.hpp"
-#include "utils/iterator/iterator.hpp"
-#include "utils/iterator/iterator.hpp"
-#include "utils/option_ptr.hpp"
-#include "utils/reference_wrapper.hpp"
-
-using namespace std;
-
-namespace hardcode
-{
-using query_functions_t =
-    std::map<uint64_t, std::function<bool(properties_t &&)>>;
-}

include/query/i_plan_cpu.hpp

@@ -1,25 +1,15 @@
 #pragma once
 
-#include "query/strip/stripped.hpp"
-
-#ifdef BARRIER
-#include "barrier/barrier.hpp"
-#include "io/network/socket.hpp"
-#else
 #include "communication/communication.hpp"
 #include "database/db.hpp"
 #include "database/db_accessor.hpp"
-#endif
+#include "query/strip/stripped.hpp"
 
 template <typename Stream>
 class IPlanCPU
 {
 public:
-#ifdef BARRIER
-    virtual bool run(barrier::Db &db, plan_args_t &args, Stream &stream) = 0;
-#else
     virtual bool run(Db &db, plan_args_t &args, Stream &stream) = 0;
-#endif
     virtual ~IPlanCPU() {}
 };
 

include/query/language/cypher/visitor/traverser.hpp

@@ -6,7 +6,6 @@
 class Traverser : public ast::AstVisitor
 {
 public:
-
     using uptr = std::unique_ptr<Traverser>;
     using sptr = std::shared_ptr<Traverser>;
 

include/query/plan/program_executor.hpp

@@ -12,14 +12,6 @@
 //  execution
 //  postprocess the results
 
-// BARRIER!
-#ifdef BARRIER
-namespace barrier
-{
-Db &trans(::Db &ref);
-}
-#endif
-
 template <typename Stream>
 class ProgramExecutor
 {
@@ -29,13 +21,7 @@ public:
     auto execute(QueryProgram<Stream> &program, Db &db, Stream &stream)
     {
         try {
-// TODO: return result of query/code exection
-#ifdef BARRIER
-            return program.plan->run(barrier::trans(db),
-                                     program.stripped.arguments, stream);
-#else
             return program.plan->run(db, program.stripped.arguments, stream);
-#endif
         // TODO: catch more exceptions
         } catch (...) {
             throw PlanExecutionException("");

include/query/plan/program_loader.hpp

@@ -80,6 +80,7 @@ private:
     // TODO ifdef MEMGRAPH64 problem, how to use this kind
     // of ifdef functions?
     // uint64_t depends on fnv function
+    // TODO: faster datastructure
     std::unordered_map<uint64_t, sptr_code_lib> code_libs;
 
     QueryPreprocessor preprocessor;

include/query/util.hpp

@@ -9,32 +9,17 @@
 #include "logging/default.hpp"
 #include "storage/model/properties/properties.hpp"
 #include "storage/model/properties/property.hpp"
-#include "storage/model/properties/traversers/consolewriter.hpp"
+#include "storage/model/properties/json_writer.hpp"
-#include "storage/model/properties/traversers/jsonwriter.hpp"
 #include "utils/types/byte.hpp"
 #include "utils/exceptions/basic_exception.hpp"
 
 using std::cout;
 using std::endl;
 
-template <class T>
-void print_props(const Properties<T> &properties);
-
-#ifdef NDEBUG
-#define PRINT_PROPS(_)
-#else
-#define PRINT_PROPS(_PROPS_) print_props(_PROPS_);
-#endif
-
-template <class T>
-void cout_properties(const Properties<T> &properties);
-
-template <class T>
-void cout_property(const StoredProperty<T> &property);
-
 // this is a nice way how to avoid multiple definition problem with
 // headers because it will create a unique namespace for each compilation unit
 // http://stackoverflow.com/questions/2727582/multiple-definition-in-header-file
+// but sometimes that might be a problem
 namespace
 {
 
@@ -61,9 +46,9 @@ std::string code_line(const std::string &format_str, const Args &... args)
 }
 
 using name_properties_t = std::vector<std::pair<std::string, Property>>;
+using indices_t = std::map<std::string, long>;
 
-auto query_properties(const std::map<std::string, int64_t> &indices,
+auto query_properties(indices_t &indices, properties_t &values)
-                      properties_t &values)
 {
     name_properties_t properties;
     for (auto &property_index : indices) {

include/storage/edge.hpp

@@ -2,9 +2,15 @@
 
 #include "mvcc/record.hpp"
 #include "storage/model/edge_model.hpp"
+#include "utils/string_buffer.hpp"
+#include "storage/model/properties/json_writer.hpp"
+#include "utils/handle_write.hpp"
 
 class Edge : public mvcc::Record<Edge>
 {
+    using buffer_t        = utils::StringBuffer;
+    using props_writer_t  = JsonWriter<buffer_t>;
+
 public:
     class Accessor;
 
@@ -19,4 +25,14 @@ public:
     Edge &operator=(Edge &&) = delete;
 
     EdgeModel data;
+
+    template <typename Stream>
+    void stream_repr(Stream &stream) const
+    {
+        auto props  = handle_write<buffer_t, props_writer_t>(data.props);
+
+        stream << "Edge(cre = " << tx.cre() << ", "
+               << "exp = " << tx.exp() << ", "
+               << "props = " << props.str() << ")";
+    }
 };

include/storage/edge_accessor.hpp

@@ -19,8 +19,9 @@ class EdgeAccessor : public RecordAccessor<TypeGroupEdge, EdgeAccessor>
 
 public:
     using RecordAccessor::RecordAccessor;
-    typedef Edge record_t;
+
-    typedef EdgeRecord record_list_t;
+    using record_t = Edge;
+    using record_list_t = EdgeRecord;
 
     // Removes self and disconects vertices from it.
     void remove() const;
@@ -34,4 +35,21 @@ public:
 
     // EdgeAccessor doesnt need to be filled
     VertexAccessor to() const;
+
+    template <typename Stream>
+    void stream_repr(Stream& stream) const
+    {
+        auto from_va = from();
+        auto to_va = to();
+
+        from_va.fill();
+        to_va.fill();
+
+        from_va.stream_repr(stream);
+        stream << '-';
+        this->record->stream_repr(stream);
+        stream << "->";
+        to_va.stream_repr(stream);
+        stream << '\n';
+    }
 };

include/storage/edge_x_vertex.hpp

@@ -8,6 +8,8 @@
 auto VertexAccessor::out() const
 {
     DbTransaction &t = this->db;
+    std::cout << "VA OUT" << std::endl;
+    std::cout << record->data.out.size() << std::endl;
     return iter::make_map(iter::make_iter_ref(record->data.out),
                           [&](auto e) -> auto { return EdgeAccessor(*e, t); });
 }

include/storage/indexes/index_base.hpp

@@ -7,6 +7,7 @@
 #include "mvcc/id.hpp"
 
 // #include "storage/indexes/index_record.hpp"
+#include "logging/loggable.hpp"
 #include "storage/garbage/delete_sensitive.hpp"
 #include "storage/indexes/index_definition.hpp"
 #include "utils/border.hpp"
@@ -26,13 +27,14 @@ class Transaction;
 // TG type group
 // K type of key on which records are ordered
 template <class TG, class K>
-class IndexBase : public DeleteSensitive
+class IndexBase : public DeleteSensitive, public Loggable
 {
 public:
     // Created with the database
-    IndexBase(IndexDefinition &&it);
+    IndexBase(IndexDefinition &&it, std::string &&logger_name = "IndexBase");
 
-    IndexBase(IndexDefinition &&it, const tx::Transaction &t);
+    IndexBase(IndexDefinition &&it, const tx::Transaction &t,
+              std::string &&logger_name = "IndexBase");
 
     virtual ~IndexBase(){};
 
@@ -70,6 +72,9 @@ public:
 
     const IndexDefinition &definition() const { return it; }
 
+protected:
+    Logger logger;
+
 private:
     const IndexDefinition it;
     // Id of transaction which created this index.

include/storage/label/label_collection.hpp

@@ -2,7 +2,6 @@
 
 #include <vector>
 
-// #include "storage/label/label.hpp"
 #include "utils/reference_wrapper.hpp"
 
 class Label;
@@ -11,13 +10,13 @@ using label_ref_t = ReferenceWrapper<const Label>;
 class LabelCollection
 {
 public:
-    auto begin() { return _labels.begin(); }
+    auto begin() { return labels_.begin(); }
-    auto begin() const { return _labels.begin(); }
+    auto begin() const { return labels_.begin(); }
-    auto cbegin() const { return _labels.begin(); }
+    auto cbegin() const { return labels_.begin(); }
 
-    auto end() { return _labels.end(); }
+    auto end() { return labels_.end(); }
-    auto end() const { return _labels.end(); }
+    auto end() const { return labels_.end(); }
-    auto cend() const { return _labels.end(); }
+    auto cend() const { return labels_.end(); }
 
     bool add(const Label &label);
     bool has(const Label &label) const;
@@ -26,6 +25,13 @@ public:
     void clear();
     const std::vector<label_ref_t> &operator()() const;
 
+    template <class Handler>
+    void handle(Handler &handler) const
+    {
+        for (auto &label : labels_)
+            handler.handle(label.get());
+    }
+
 private:
-    std::vector<label_ref_t> _labels;
+    std::vector<label_ref_t> labels_;
 };

include/storage/label/labels_writer.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+class Label;
+
+template <class Buffer>
+class LabelsWriter
+{
+public:
+    LabelsWriter(Buffer &buffer) : buffer_(buffer) {}
+
+    ~LabelsWriter() = default;
+
+    LabelsWriter(const LabelsWriter &) = delete;
+    LabelsWriter(LabelsWriter &&)      = delete;
+
+    LabelsWriter &operator=(const LabelsWriter &) = delete;
+    LabelsWriter &operator=(LabelsWriter &&) = delete;
+
+    void handle(const Label& label);
+    
+private:
+    Buffer& buffer_; 
+};

include/storage/model/edge_list.hpp

@@ -16,7 +16,7 @@ public:
     auto end() const { return edges.end(); }
     auto cend() const { return edges.end(); }
 
-    void add(EdgeRecord *edge) { edges.push_back(edge); }
+    void add(EdgeRecord *edge) { edges.emplace_back(edge); }
 
     size_t degree() const { return edges.size(); }
 

include/storage/model/properties/json_writer.hpp

@@ -70,30 +70,3 @@ private:
     bool first{true};
     Buffer &buffer;
 };
-
-class StringBuffer
-{
-public:
-    StringBuffer &operator<<(const std::string &str)
-    {
-        data += str;
-        return *this;
-    }
-
-    StringBuffer &operator<<(const char *str)
-    {
-        data += str;
-        return *this;
-    }
-
-    StringBuffer &operator<<(char c)
-    {
-        data += c;
-        return *this;
-    }
-
-    std::string &str() { return data; }
-
-private:
-    std::string data;
-};

include/storage/model/properties/traversers/consolewriter.hpp

@@ -1,72 +0,0 @@
-#pragma once
-
-#include <iostream>
-
-#include "storage/model/properties/properties.hpp"
-#include "storage/type_group_edge.hpp"
-#include "storage/type_group_vertex.hpp"
-
-using std::cout;
-using std::endl;
-
-class ConsoleWriter
-{
-public:
-    ConsoleWriter() {}
-
-    void handle(const StoredProperty<TypeGroupEdge> &value)
-    {
-        handle<TypeGroupEdge>(value);
-    }
-
-    void handle(const StoredProperty<TypeGroupVertex> &value)
-    {
-        handle<TypeGroupVertex>(value);
-    }
-
-    template <class T>
-    void handle(StoredProperty<T> const &value)
-    {
-        cout << "KEY: " << value.key.family_name() << "; VALUE: ";
-
-        value.accept(*this);
-
-        // value.accept(*this);
-
-        cout << endl;
-    }
-
-    void handle(const Null &v) { cout << "NULL"; }
-
-    void handle(const Bool &b) { cout << b; }
-
-    void handle(const String &s) { cout << s; }
-
-    void handle(const Int32 &int32) { cout << int32; }
-
-    void handle(const Int64 &int64) { cout << int64; }
-
-    void handle(const Float &f) { cout << f; }
-
-    void handle(const Double &d) { cout << d; }
-
-    // Not yet implemented
-    void handle(const ArrayBool &) { assert(false); }
-
-    // Not yet implemented
-    void handle(const ArrayInt32 &) { assert(false); }
-
-    // Not yet implemented
-    void handle(const ArrayInt64 &) { assert(false); }
-
-    // Not yet implemented
-    void handle(const ArrayFloat &) { assert(false); }
-
-    // Not yet implemented
-    void handle(const ArrayDouble &) { assert(false); }
-
-    // Not yet implemented
-    void handle(const ArrayString &) { assert(false); }
-
-    void finish() {}
-};

include/storage/vertex.hpp

@@ -1,11 +1,18 @@
 #pragma once
 
 #include "mvcc/record.hpp"
-#include "storage/model/properties/traversers/jsonwriter.hpp"
+#include "storage/label/labels_writer.hpp"
+#include "storage/model/properties/json_writer.hpp"
 #include "storage/model/vertex_model.hpp"
+#include "utils/handle_write.hpp"
+#include "utils/string_buffer.hpp"
 
 class Vertex : public mvcc::Record<Vertex>
 {
+    using buffer_t        = utils::StringBuffer;
+    using props_writer_t  = JsonWriter<buffer_t>;
+    using labels_writer_t = LabelsWriter<buffer_t>;
+
 public:
     class Accessor;
 
@@ -14,24 +21,22 @@ public:
     Vertex(VertexModel &&data) : data(std::move(data)) {}
 
     Vertex(const Vertex &) = delete;
-    Vertex(Vertex &&) = delete;
+    Vertex(Vertex &&)      = delete;
 
     Vertex &operator=(const Vertex &) = delete;
     Vertex &operator=(Vertex &&) = delete;
 
     VertexModel data;
+
+    template <typename Stream>
+    void stream_repr(Stream &stream) const
+    {
+        auto props  = handle_write<buffer_t, props_writer_t>(data.props);
+        auto labels = handle_write<buffer_t, labels_writer_t>(data.labels);
+
+        stream << "Vertex(cre = " << tx.cre() << ", "
+               << "exp = " << tx.exp() << ", "
+               << "props = " << props.str() << ", "
+               << "labels = " << labels.str() << ")";
+    }
 };
-
-inline std::ostream &operator<<(std::ostream &stream, const Vertex &record)
-{
-    StringBuffer buffer;
-    JsonWriter<StringBuffer> writer(buffer);
-
-    // dump properties in this buffer
-    record.data.props.handle(writer);
-    writer.finish();
-
-    return stream << "Vertex"
-                  << "(cre = " << record.tx.cre()
-                  << ", exp = " << record.tx.exp() << "): " << buffer.str();
-}

include/storage/vertex_accessor.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "storage/label/label_collection.hpp"
 #include "storage/record_accessor.hpp"
 #include "storage/vertex.hpp"
 #include "utils/iterator/iterator.hpp"
@@ -15,7 +16,7 @@ class VertexAccessor : public RecordAccessor<TypeGroupVertex, VertexAccessor>
 public:
     using RecordAccessor::RecordAccessor;
 
-    using record_t = Vertex;
+    using record_t      = Vertex;
     using record_list_t = VertexRecord;
 
     // Removes self and all edges connected to it.
@@ -51,4 +52,13 @@ public:
 
     // True if there exists edge between other vertex and this vertex.
     bool in_contains(VertexAccessor const &other) const;
+
+    template <typename Stream>
+    void stream_repr(Stream& stream) const
+    {
+        if (!this->record)
+            return;
+
+        this->record->stream_repr(stream);
+    }
 };

include/transactions/transaction_read.hpp

@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include <cstdint>

include/utils/handle_write.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+/*
+ * Source object is going to be traversed by Writer and Writer will
+ * write that data into the Destination object.
+ *
+ * Writer object defines write format.
+ */
+template <typename Destination, typename Writer, typename Source>
+Destination handle_write(const Source& source)
+{
+    Destination destination;
+    Writer writter(destination);
+    source.handle(writter);
+    return destination;
+}

include/utils/iterator/combined.hpp

@@ -6,7 +6,8 @@
 namespace iter
 {
 
-// Class which Combined two iterators IT1 and IT2. Both return values T
+// Class which Combined two iterators IT1 and IT2.
+// Both return values T
 // T - type of return value
 // IT1 - first iterator type
 // IT2 - second iterator type

include/utils/iterator/composable.hpp

@@ -116,6 +116,12 @@ public:
             move(), [](auto vr) { return vr.out().fill(); });
     }
 
+    auto in()
+    {
+        return iter::make_flat_map<Derived>(
+            move(), [](auto vr) { return vr.in().fill(); });
+    }
+
     // Filters with label on from vertex.
     template <class LABEL>
     auto from_label(LABEL const &label)
@@ -153,6 +159,12 @@ public:
             move(), [&](auto &v) mutable { t = Option<const T>(v); });
     }
 
+    // auto clone_to(Option<T> &t)
+    // {
+    //     return iter::make_inspect<Derived>(
+    //         move(), [&](auto &e) mutable { t = Option<T>(e); });
+    // }
+
     // Filters with call to method fill()
     auto fill()
     {

include/utils/iterator/inspect.hpp

@@ -6,27 +6,31 @@
 namespace iter
 {
 
-// Class which inspects values returned by I iterator before passing thenm as
+// Class which inspects values returned by I iterator
-// result.
+// before passing them as a result.
 // function.
 // T - type of return value
 // I - iterator type
 // OP - type of inspector function. OP: T&->void
 template <class T, class I, class OP>
-class Inspect : public IteratorBase<T>, public Composable<T, Inspect<T, I, OP>>
+class Inspect : public IteratorBase<T>,
+                public Composable<T, Inspect<T, I, OP>>
 {
-
 public:
     Inspect() = delete;
 
-    // Inspect operation is designed to be used in chained calls which operate
+    // Inspect operation is designed to be used
-    // on a
+    // in chained calls which operate on an
-    // iterator. Inspect will in that usecase receive other iterator by value
+    // iterator. Inspect will in that usecase 
-    // and
+    // receive other iterator by value and
     // std::move is a optimization for it.
-    Inspect(I &&iter, OP &&op) : iter(std::move(iter)), op(std::move(op)) {}
+    Inspect(I &&iter, OP &&op) : 
+        iter(std::move(iter)), 
+        op(std::move(op))
+    {}
 
-    Inspect(Inspect &&m) : iter(std::move(m.iter)), op(std::move(m.op)) {}
+    Inspect(Inspect &&m) :
+        iter(std::move(m.iter)), op(std::move(m.op)) {}
 
     ~Inspect() final {}
 
@@ -52,7 +56,7 @@ template <class I, class OP>
 auto make_inspect(I &&iter, OP &&op)
 {
     // Compiler cant deduce type T. decltype is here to help with it.
-    return Inspect<decltype(iter.next().take()), I, OP>(std::move(iter),
+    return Inspect<decltype(iter.next().take()), I, OP>
-                                                        std::move(op));
+        (std::move(iter), std::move(op));
 }
 }

include/utils/memory/stack_allocator.hpp

@@ -1,7 +1,8 @@
 #pragma once
 
 #include <cmath>
-#include "query_engine/exceptions/exceptions.hpp"
+
+#include "utils/exceptions/out_of_memory.hpp"
 #include "utils/memory/block_allocator.hpp"
 
 // http://en.cppreference.com/w/cpp/language/new
@@ -24,7 +25,8 @@ public:
         // until it eats all the memory.
         static_assert(sizeof(T) <= page_size,
                       "Cant allocate objects larger than page_size");
-        do {
+        do
+        {
             // Mask which has log2(alignof(T)) lower bits setted to 0 and the
             // rest to 1.
             // example:
@@ -56,7 +58,8 @@ public:
 
             // If the new_head is greater than end that means that there isn't
             // enough space for object T in current block of memory.
-            if (LIKELY(new_head <= end)) {
+            if (LIKELY(new_head <= end))
+            {
 
                 // All is fine, head can become new_head
                 head = new_head;
@@ -99,7 +102,8 @@ public:
     // Relases all memory.
     void free()
     {
-        while (allocated_blocks.size() > 0) {
+        while (allocated_blocks.size())
+        {
             blocks.release(allocated_blocks.back());
             allocated_blocks.pop_back();
         }
@@ -109,5 +113,5 @@ private:
     BlockAllocator<page_size> blocks;
     std::vector<void *> allocated_blocks;
     char *head = {nullptr};
-    char *end = {nullptr};
+    char *end  = {nullptr};
 };

include/utils/numerics/log2.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <cstddef>
+
+namespace utils
+{
+
+constexpr size_t log2(size_t n) { return ((n < 2) ? 0 : 1 + log2(n >> 1)); }
+
+}

include/utils/option.hpp

@@ -5,7 +5,8 @@
 #include <ext/aligned_buffer.h>
 #include <utility>
 
-// Optional object storage. It maybe has and maybe dosent have objet of type T.
+// Optional object storage. It maybe has and maybe
+// dosent have objet of type T.
 template <class T>
 class Option
 {
@@ -33,12 +34,14 @@ public:
             std::memset(data._M_addr(), 0, sizeof(T));
         }
     }
-    // Containers from std which have strong exception guarantees wont use move
+
-    // constructors and operators wihtout noexcept. "Optimized C++,2016 , Kurt
+    // Containers from std which have strong exception
-    // Guntheroth, page: 142, title: Moving instances into std::vector"
+    // guarantees wont use move constructors and operators
+    // wihtout noexcept. "Optimized C++,2016 , Kurt
+    // Guntheroth, page: 142, title: Moving instances into
+    // std::vector"
     Option(Option &&other) noexcept
     {
-
         if (other.initialized) {
             new (data._M_addr()) T(std::move(other.get()));
             other.initialized = false;
@@ -69,6 +72,7 @@ public:
 
         return *this;
     }
+
     Option &operator=(Option &&other)
     {
         if (initialized) {
@@ -180,8 +184,9 @@ public:
     explicit operator bool() const { return initialized; }
 
 private:
-    // Aligned buffer is here to ensure aligment for data of type T. It isn't
+    // Aligned buffer is here to ensure aligment for
-    // applicable to just put T field because the field has to be able to be
+    // data of type T. It isn't applicable to just put T
+    // field because the field has to be able to be
     // uninitialized to fulfill the semantics of Option class.
     __gnu_cxx::__aligned_buffer<T> data;
     bool initialized = false;

include/utils/string_buffer.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <string>
+
+namespace utils
+{
+
+class StringBuffer
+{
+public:
+    StringBuffer() = default;
+    ~StringBuffer() = default;
+
+    StringBuffer(const StringBuffer &) = delete;
+    StringBuffer(StringBuffer &&)      = default;
+
+    StringBuffer &operator=(const StringBuffer &) = delete;
+    StringBuffer &operator=(StringBuffer &&) = default;
+
+    StringBuffer(std::string::size_type count)
+    {
+        resize(count);
+    }
+
+    void resize(std::string::size_type count)
+    {
+        data.resize(count);
+    }
+
+    StringBuffer &operator<<(const std::string &str)
+    {
+        data += str;
+        return *this;
+    }
+
+    StringBuffer &operator<<(const char *str)
+    {
+        data += str;
+        return *this;
+    }
+
+    StringBuffer &operator<<(char c)
+    {
+        data += c;
+        return *this;
+    }
+
+    std::string &str() { return data; }
+
+private:
+    std::string data;
+};
+
+}

poc/astar.cpp

@@ -9,11 +9,11 @@
 #include <string>
 #include <vector>
 
+#include "communication/bolt/v1/serialization/bolt_serializer.hpp"
 #include "data_structures/map/rh_hashmap.hpp"
 #include "database/db.hpp"
 #include "database/db_accessor.cpp"
 #include "database/db_accessor.hpp"
-
 #include "import/csv_import.hpp"
 #include "logging/default.hpp"
 #include "logging/streams/stdout.hpp"
@@ -23,8 +23,6 @@
 #include "storage/indexes/impl/nonunique_unordered_index.cpp"
 #include "storage/model/properties/properties.cpp"
 #include "storage/record_accessor.cpp"
-// #include "storage/vertex_accessor.cpp"
-#include "communication/bolt/v1/serialization/bolt_serializer.hpp"
 #include "storage/vertex_accessor.hpp"
 #include "storage/vertices.cpp"
 #include "storage/vertices.hpp"
@@ -60,9 +58,10 @@ public:
 
     double sum_vertex_score()
     {
-        auto now = this;
+        auto now   = this;
         double sum = 0;
-        do {
+        do
+        {
             sum += (now->vacc.at(tkey).get())->value();
             now = now->parent;
         } while (now != nullptr);
@@ -84,8 +83,11 @@ void found_result(Node *res)
 
     std::cout << "{score: " << sum << endl;
     auto bef = res;
-    while (bef != nullptr) {
+    while (bef != nullptr)
-        std::cout << "   " << *(bef->vacc.operator->()) << endl;
+    {
+        std::cout << "   ";
+        bef->vacc.operator->()->stream_repr(std::cout);
+        std::cout << std::endl;
         bef = bef->parent;
     }
 }
@@ -113,18 +115,23 @@ bool vertex_filter_dummy(DbAccessor &t, VertexAccessor &va, Node *before)
 bool vertex_filter_contained_dummy(DbAccessor &t, VertexAccessor &v,
                                    Node *before)
 {
-    if (v.fill()) {
+    if (v.fill())
+    {
         bool found;
-        do {
+        do
-            found = false;
+        {
+            found  = false;
             before = before->parent;
-            if (before == nullptr) {
+            if (before == nullptr)
+            {
                 return true;
             }
             auto it = before->vacc.out();
-            for (auto e = it.next(); e.is_present(); e = it.next()) {
+            for (auto e = it.next(); e.is_present(); e = it.next())
+            {
                 VertexAccessor va = e.get().to();
-                if (va == v) {
+                if (va == v)
+                {
                     found = true;
                     break;
                 }
@@ -136,12 +143,15 @@ bool vertex_filter_contained_dummy(DbAccessor &t, VertexAccessor &v,
 
 bool vertex_filter_contained(DbAccessor &t, VertexAccessor &v, Node *before)
 {
-    if (v.fill()) {
+    if (v.fill())
+    {
         bool found;
-        do {
+        do
-            found = false;
+        {
+            found  = false;
             before = before->parent;
-            if (before == nullptr) {
+            if (before == nullptr)
+            {
                 return true;
             }
         } while (v.in_contains(before->vacc));
@@ -163,7 +173,9 @@ auto a_star(
     DbAccessor t(db);
 
     type_key_t<TypeGroupVertex, Double> type_key =
-        t.vertex_property_family_get("score").get(Flags::Double).type_key<Double>();
+        t.vertex_property_family_get("score")
+            .get(Flags::Double)
+            .type_key<Double>();
 
     auto best_found = new std::map<Id, Score>[max_depth];
 
@@ -177,17 +189,20 @@ auto a_star(
     Node *start = new Node(start_vr.take(), 0, type_key);
     queue.push(start);
     int count = 0;
-    do {
+    do
+    {
         auto now = queue.top();
         queue.pop();
         // if(!visited.insert(now)){
         //     continue;
         // }
 
-        if (max_depth <= now->depth) {
+        if (max_depth <= now->depth)
+        {
             best.push_back(now);
             count++;
-            if (count >= limit) {
+            if (count >= limit)
+            {
                 return best;
             }
             continue;
@@ -202,11 +217,13 @@ auto a_star(
         // }
 
         iter::for_all(now->vacc.out(), [&](auto edge) {
-            if (e_filter[now->depth](t, edge, now)) {
+            if (e_filter[now->depth](t, edge, now))
+            {
                 VertexAccessor va = edge.to();
-                if (v_filter[now->depth](t, va, now)) {
+                if (v_filter[now->depth](t, va, now))
+                {
                     auto cost = calc_heuristic_cost(type_key, edge, va);
-                    Node *n = new Node(va, now->cost + cost, now, type_key);
+                    Node *n   = new Node(va, now->cost + cost, now, type_key);
                     queue.push(n);
                 }
             }
@@ -238,15 +255,16 @@ int main(int argc, char **argv)
 
     // CONF
     std::srand(time(0));
-    auto best_n = 10;
+    auto best_n       = 10;
-    auto bench_n = 1000;
+    auto bench_n      = 1000;
     auto best_print_n = 10;
     bool pick_best_found =
         strcmp(get_argument(para, "-p", "true").c_str(), "true") == 0;
 
     double sum = 0;
     std::vector<Node *> best;
-    for (int i = 0; i < bench_n; i++) {
+    for (int i = 0; i < bench_n; i++)
+    {
         auto start_vertex_index = std::rand() % loaded.first;
 
         auto begin = clock();
@@ -260,12 +278,14 @@ int main(int argc, char **argv)
         if ((best.size() < best_print_n && found.size() > best.size()) ||
             (pick_best_found && found.size() > 0 &&
              found.front()->sum_vertex_score() >
-                 best.front()->sum_vertex_score())) {
+                 best.front()->sum_vertex_score()))
+        {
             best = found;
         }
 
         // Just to be safe
-        if (i + 1 == bench_n && best.size() == 0) {
+        if (i + 1 == bench_n && best.size() == 0)
+        {
             bench_n++;
         }
     }
@@ -274,7 +294,8 @@ int main(int argc, char **argv)
               << " results has runing time of:\n    avg: " << sum / bench_n
               << " [ms]\n";
     std::cout << "\nExample of best result:\n";
-    for (int i = 0; i < best_print_n && best.size() > 0; i++) {
+    for (int i = 0; i < best_print_n && best.size() > 0; i++)
+    {
         found_result(best.front());
         best.erase(best.begin());
     }
@@ -292,7 +313,8 @@ void add_scores(Db &db)
 
     int i = 1;
     iter::for_all(t.vertex_access(), [&](auto v) {
-        if (v.fill()) {
+        if (v.fill())
+        {
             // any random number is OK
             std::srand(i ^ 0x7482616);
             v.set(StoredProperty<TypeGroupVertex>(

poc/astar_query.cpp

@@ -1,7 +1,3 @@
-#include "queries/astar.cpp"
-
-#include "barrier/barrier.cpp"
-
 #include <chrono>
 #include <cstring>
 #include <ctime>
@@ -21,6 +17,7 @@
 #include "import/csv_import.hpp"
 #include "logging/default.hpp"
 #include "logging/streams/stdout.hpp"
+#include "queries/astar.hpp"
 #include "storage/edge_x_vertex.hpp"
 #include "storage/edges.cpp"
 #include "storage/edges.hpp"
@@ -41,21 +38,23 @@ int main(int argc, char **argv)
     auto para = all_arguments(argc, argv);
 
     Db db("astar");
-    barrier::CodeCPU cp;
+    PlanCPU plan;
     int bench_n = 1000;
 
-    do {
+    do
+    {
         double sum = 0;
-        for (int i = 0; i < bench_n; i++) {
+        for (int i = 0; i < bench_n; i++)
+        {
             auto start_vertex_index =
                 std::rand() % db.graph.vertices.access().size();
 
             auto begin = clock();
 
-            code_args_t args;
+            plan_args_t args;
             args.push_back(Property(Int64(start_vertex_index), Int64::type));
 
-            cp.run(barrier::trans(db), args, std::cout);
+            plan.run(db, args, std::cout);
 
             clock_t end = clock();
 
@@ -63,7 +62,7 @@ int main(int argc, char **argv)
             sum += elapsed_ms;
         }
 
-        std::cout << "\nSearch for best " << barrier::limit
+        std::cout << "\nSearch for best " << limit
                   << " results has runing time of:\n    avg: " << sum / bench_n
                   << " [ms]\n";
     } while (true);

poc/profile.cpp

@@ -4,9 +4,6 @@
 #include <unistd.h>
 #include <unordered_map>
 
-// TODO: remove barrier
-#include "barrier/barrier.cpp"
-
 #include "database/db.hpp"
 #include "database/db_accessor.hpp"
 #include "communication/bolt/v1/serialization/bolt_serializer.hpp"
@@ -20,7 +17,7 @@ using namespace std;
 
 // (company, {type_name, score})
 using company_profile_type =
-    pair<barrier::VertexAccessor, unordered_map<string, double>>;
+    pair<VertexAccessor, unordered_map<string, double>>;
 
 // Accepted flags for CSV import.
 // -db name # will create database with that name.
@@ -44,7 +41,7 @@ int main(int argc, char **argv)
 
         // query benchmark
         auto begin = clock();
-        int n = for_all_companys(barrier::trans(t), company_profiles);
+        int n = for_all_companys(t, company_profiles);
         clock_t end = clock();
         double elapsed_s = (double(end - begin) / CLOCKS_PER_SEC);
 
@@ -71,8 +68,8 @@ int main(int argc, char **argv)
         for (auto &company_profile : company_profiles) {
             auto prop_vertex_id = t.vertex_property_key<Int64>("company_id");
             auto db_company_id =
-                *barrier::trans(company_profile.first).at(prop_vertex_id).get();
+                company_profile.first.at(prop_vertex_id).get();
-            if (db_company_id == company_id) {
+            if (db_company_id->value() == company_id) {
                 cout << endl << "CompanyID: " << company_id << endl;
                 for (auto e : company_profile.second) {
                     cout << e.first << " = " << e.second << endl;

poc/profile.hpp

@@ -8,13 +8,10 @@
 #include <unistd.h>
 #include <unordered_map>
 
-#include "barrier/barrier.hpp"
+#include "storage/edge_x_vertex.hpp"
 
 using namespace std;
 
-namespace barrier
-{
-
 // TODO: Turn next template, expand on it, standardize it, and use it for query
 // generation.
 
@@ -334,10 +331,9 @@ size_t for_all_companys(
     int i = 0;
     iter::for_all_fill(
         t.label_find_or_create("Company").index().for_range(t), [&](auto v) {
-            coll.push_back(make_pair(v, barrier::query(t, v.id())));
+            coll.push_back(make_pair(v, query(t, v.id())));
             i++;
             return false;
         });
     return i;
 }
-}

poc/queries/astar.hpp

@@ -3,8 +3,10 @@
 #include <string>
 #include <vector>
 
-#include "query/i_code_cpu.hpp"
+#include "query/i_plan_cpu.hpp"
 #include "storage/model/properties/all.hpp"
+#include "storage/vertex_accessor.hpp"
+#include "storage/edge_x_vertex.hpp"
 #include "utils/memory/stack_allocator.hpp"
 
 using std::cout;
@@ -12,15 +14,10 @@ using std::endl;
 
 // Dressipi astar query of 4 clicks.
 
-// BARRIER!
+using Stream = std::ostream;
-namespace barrier
-{
-
-using STREAM = std::ostream;
-// using STREAM = RecordStream<::io::Socket>;
 
 constexpr size_t max_depth = 3;
-constexpr size_t limit = 10;
+constexpr size_t limit     = 10;
 
 class Node
 {
@@ -45,9 +42,10 @@ public:
 
     double sum_vertex_score()
     {
-        auto now = this;
+        auto now   = this;
         double sum = 0;
-        do {
+        do
+        {
             sum += (now->vacc.at(tkey).get())->value();
             now = now->parent;
         } while (now != nullptr);
@@ -57,12 +55,15 @@ public:
 
 bool vertex_filter_contained(DbAccessor &t, VertexAccessor &v, Node *before)
 {
-    if (v.fill()) {
+    if (v.fill())
+    {
         bool found;
-        do {
+        do
-            found = false;
+        {
+            found  = false;
             before = before->parent;
-            if (before == nullptr) {
+            if (before == nullptr)
+            {
                 return true;
             }
         } while (v.in_contains(before->vacc));
@@ -70,7 +71,7 @@ bool vertex_filter_contained(DbAccessor &t, VertexAccessor &v, Node *before)
     return false;
 }
 
-void astar(DbAccessor &t, code_args_t &args, STREAM &stream)
+void astar(DbAccessor &t, plan_args_t &args, Stream &stream)
 {
     StackAllocator stack;
     VertexPropertyType<Double> tkey = t.vertex_property_key<Double>("score");
@@ -79,7 +80,8 @@ void astar(DbAccessor &t, code_args_t &args, STREAM &stream)
     std::priority_queue<Node *, std::vector<Node *>, decltype(cmp)> queue(cmp);
 
     auto start_vr = t.vertex_find(Id(args[0].as<Int64>().value()));
-    if (!start_vr.is_present()) {
+    if (!start_vr.is_present())
+    {
         // stream.write_failure({{}});
         return;
     }
@@ -89,15 +91,18 @@ void astar(DbAccessor &t, code_args_t &args, STREAM &stream)
     queue.push(start);
 
     int count = 0;
-    do {
+    do
+    {
         auto now = queue.top();
         queue.pop();
 
-        if (max_depth <= now->depth) {
+        if (max_depth <= now->depth)
+        {
             // stream.write_success_empty();
             // best.push_back(now);
             count++;
-            if (count >= limit) {
+            if (count >= limit)
+            {
                 break;
             }
             continue;
@@ -105,9 +110,10 @@ void astar(DbAccessor &t, code_args_t &args, STREAM &stream)
 
         iter::for_all(now->vacc.out(), [&](auto edge) {
             VertexAccessor va = edge.to();
-            if (vertex_filter_contained(t, va, now)) {
+            if (vertex_filter_contained(t, va, now))
+            {
                 auto cost = 1 - va.at(tkey).get()->value();
-                Node *n = new (stack.allocate<Node>())
+                Node *n   = new (stack.allocate<Node>())
                     Node(va, now->cost + cost, now, tkey);
                 queue.push(n);
             }
@@ -117,10 +123,10 @@ void astar(DbAccessor &t, code_args_t &args, STREAM &stream)
     stack.free();
 }
 
-class CodeCPU : public ICodeCPU<STREAM>
+class PlanCPU : public IPlanCPU<Stream>
 {
 public:
-    bool run(Db &db, code_args_t &args, STREAM &stream) override
+    bool run(Db &db, plan_args_t &args, Stream &stream) override
     {
         DbAccessor t(db);
 
@@ -129,14 +135,9 @@ public:
         return t.commit();
     }
 
-    ~CodeCPU() {}
+    ~PlanCPU() {}
 };
-}
 
-extern "C" ICodeCPU<barrier::STREAM> *produce()
+extern "C" IPlanCPU<Stream> *produce() { return new PlanCPU(); }
-{
-    // BARRIER!
-    return new barrier::CodeCPU();
-}
 
-extern "C" void destruct(ICodeCPU<barrier::STREAM> *p) { delete p; }
+extern "C" void destruct(IPlanCPU<Stream> *p) { delete p; }

poc/size_aligment.cpp

@@ -11,8 +11,6 @@
 #include "storage/edge_x_vertex.hpp"
 #include "storage/indexes/impl/nonunique_unordered_index.cpp"
 #include "storage/model/properties/properties.cpp"
-// #include "storage/record_accessor.cpp"
-// #include "storage/vertex_accessor.cpp"
 #include "utils/command_line/arguments.hpp"
 
 using namespace std;

release/alpha.sh

@@ -37,7 +37,10 @@ cp -r include ../release/${exe_name}/include
 cp -r template ../release/${exe_name}/template
 cp -r ../config ../release/${exe_name}/config
 
-mkdir -p ../release/${exe_name}/compiled/cpu
+# create compiled folder and copy hard coded queries
+mkdir -p ../release/${exe_name}/compiled/cpu/hardcode
+cp ../tests/integration/hardcoded_query/*.cpp ../release/${exe_name}/compiled/cpu/hardcode
+cp ../tests/integration/hardcoded_query/*.hpp ../release/${exe_name}/compiled/cpu/hardcode
 
 echo "Memgraph Release Building DONE"
 

release/barrier.dockerfile

@@ -1,16 +0,0 @@
-FROM ubuntu:16.04
-
-RUN apt-get update \
-    && apt-get install -y clang libssl-dev \
-    && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
-
-RUN mkdir -p /libs
-
-ENV BINARY_NAME memgraph_414_dba2610_dev_debug
-
-COPY barrier_$BINARY_NAME /memgraph
-COPY libs/fmt /libs/fmt
-
-WORKDIR /memgraph
-
-CMD ./$BINARY_NAME

release/barrier.sh

@@ -1,54 +0,0 @@
-#!/bin/bash
-
-binary_name=$1
-
-cd ..
-
-release_folder="barrier_$binary_name"
-release_path="release/$release_folder"
-compile_template_path="template/barrier_template_code_cpu.cpp"
-
-mkdir -p $release_path/compiled/cpu
-
-mkdir -p $release_path/include/barrier
-mkdir -p $release_path/include/query/strip
-mkdir -p $release_path/include/query/exception
-mkdir -p $release_path/include/io/network
-mkdir -p $release_path/include/logging
-mkdir -p $release_path/include/mvcc
-mkdir -p $release_path/include/storage/indexes
-mkdir -p $release_path/include/storage/model/properties/traversers
-mkdir -p $release_path/include/storage/model/properties/utils
-mkdir -p $release_path/include/utils/datetime
-mkdir -p $release_path/include/utils/exceptions
-mkdir -p $release_path/include/utils/iterator
-mkdir -p $release_path/include/utils/memory
-mkdir -p $release_path/include/utils/numerics
-
-mkdir -p $release_path/template
-
-# COPY
-# dressipi query
-# TODO: for loop
-# hardcoded_queries="135757557963690525.cpp"
-# for query in $hardcoded_queries
-# do
-#     cp build/compiled/cpu/hardcode/$query $release_path/compiled/cpu/hardcode/$query
-# done
-
-cp src/query_engine/$compile_template_path $release_path/$compile_template_path
-
-paths="barrier/barrier.hpp barrier/common.hpp storage/model/properties/floating.hpp storage/model/properties/all.hpp storage/model/properties/bool.hpp storage/model/properties/traversers/consolewriter.hpp storage/model/properties/traversers/jsonwriter.hpp storage/model/properties/array.hpp storage/model/properties/property_family.hpp storage/model/properties/property.hpp storage/model/properties/properties.hpp storage/model/properties/integral.hpp storage/model/properties/double.hpp storage/model/properties/string.hpp storage/model/properties/utils/math_operations.hpp storage/model/properties/utils/unary_negation.hpp storage/model/properties/utils/modulo.hpp storage/model/properties/property_holder.hpp storage/model/properties/float.hpp storage/model/properties/null.hpp storage/model/properties/flags.hpp storage/model/properties/int32.hpp storage/model/properties/number.hpp storage/model/properties/int64.hpp logging/default.hpp logging/log.hpp logging/logger.hpp logging/levels.hpp io/network/addrinfo.hpp io/network/network_error.hpp io/network/socket.hpp mvcc/id.hpp utils/exceptions/basic_exception.hpp utils/border.hpp utils/total_ordering.hpp utils/auto_scope.hpp utils/crtp.hpp utils/order.hpp utils/likely.hpp utils/option.hpp utils/option_ptr.hpp utils/memory/block_allocator.hpp utils/memory/stack_allocator.hpp utils/iterator/query.hpp utils/iterator/composable.hpp utils/iterator/for_all.hpp utils/iterator/range_iterator.hpp utils/iterator/limited_map.hpp utils/iterator/iterator_accessor.hpp utils/iterator/count.hpp utils/iterator/iterator_base.hpp utils/iterator/filter.hpp utils/iterator/inspect.hpp utils/iterator/accessor.hpp utils/iterator/map.hpp utils/iterator/virtual_iter.hpp utils/iterator/flat_map.hpp utils/iterator/combined.hpp utils/iterator/lambda_iterator.hpp utils/iterator/iterator.hpp utils/array_store.hpp utils/void.hpp storage/indexes/index_definition.hpp utils/stacktrace.hpp utils/datetime/datetime_error.hpp utils/datetime/timestamp.hpp utils/reference_wrapper.hpp utils/underlying_cast.hpp utils/numerics/saturate.hpp query/i_plan_cpu.hpp query/property_util.hpp query/strip/stripped.hpp query/exception/cpp_code_generator.hpp query/exception/decoder_exception.hpp query/exception/out_of_memory.hpp query/exception/plan_compilation.hpp query/exception/plan_execution.hpp query/exception/query_engine.hpp"
-
-for path in $paths
-do
-    cp include/$path $release_path/include/$path
-done
-
-cp config/memgraph.yaml $release_path/config.yaml
-
-cp build/$binary_name $release_path/$binary_name
-cp build/libmemgraph_pic.a $release_path/libmemgraph_pic.a
-cp build/libbarrier_pic.a $release_path/libbarrier_pic.a
-
-echo "DONE"

src/barrier/barrier.cpp

@@ -1,766 +0,0 @@
-#include "barrier/trans.hpp"
-
-// ************************* Implementations
-// This file should contain all implementations of methods from barrier classes
-// defined in barrier.hpp.
-// Implementations should follow the form:
-// border_return_type border_class::method_name(arguments){
-//      return
-//      CALL(method_name(trans(arguments)))
-//      or
-//      HALF_CALL(method_name(trans(arguments)));
-// }
-
-// **************************** HELPER DEFINES *******************************//
-// returns transformed this pointer
-#define THIS (trans(this))
-// In border class performs call x on original class.
-#define HALF_CALL(x) (THIS->x)
-// In border class performs call x on original class and produces transformed
-// output.
-#define CALL(x) trans(HALF_CALL(x))
-
-// Creates destructor for border type x which is original type y.
-#define DESTRUCTOR(x, y)                                                       \
-    x::~x() { HALF_CALL(~y()); }
-
-// Creates copy constructor for mutable ref to border class x which is original
-// class y.
-#define COPY_CONSTRUCTOR_MUT(x, y)                                             \
-    x::x(x &other) : Sized(y(trans(other))) {}
-
-// Creates copy constructor for const ref to border class x which is original
-// class y.
-#define COPY_CONSTRUCTOR(x, y)                                                 \
-    x::x(const x &other) : Sized(y(trans(other))) {}
-
-// Creates move constructor for mutable border type x.
-#define MOVE_CONSTRUCTOR(x)                                                    \
-    x::x(x &&other) : Sized(trans(std::move(other))) {}
-
-// Creates move constructor for const border type x.
-#define MOVE_CONST_CONSTRUCTOR(x)                                              \
-    x::x(x const &&other) : Sized(trans(std::move(other))) {}
-
-// Creates copy operator for border type x.
-#define COPY_OPERATOR(x)                                                       \
-    x &x::operator=(const x &other)                                            \
-    {                                                                          \
-        HALF_CALL(operator=(trans(other)));                                    \
-        return *this;                                                          \
-    }
-
-// Creates move operator for border type x.
-#define MOVE_OPERATOR(x)                                                       \
-    x &x::operator=(x &&other)                                                 \
-    {                                                                          \
-        HALF_CALL(operator=(trans(std::move(other))));                         \
-        return *this;                                                          \
-    }
-
-namespace barrier
-{
-
-// ***************** Label
-VertexIndex<std::nullptr_t> &Label::index() const { return CALL(index()); }
-
-// **************** EdgeType
-bool operator<(const EdgeType &lhs, const EdgeType &rhs)
-{
-    return trans(lhs) < trans(rhs);
-}
-
-bool operator==(const EdgeType &lhs, const EdgeType &rhs)
-{
-    return trans(lhs) == trans(rhs);
-}
-
-EdgeIndex<std::nullptr_t> &EdgeType::index() const { return CALL(index()); }
-
-// **************** VertexIndex
-template <class K>
-VertexIterator VertexIndex<K>::for_range(DbAccessor &t, Border<K> from,
-                                         Border<K> to)
-{
-    return CALL(for_range(trans(t), std::move(from), std::move(to)));
-}
-
-template <class K>
-IndexType VertexIndex<K>::type()
-{
-    return HALF_CALL(type());
-}
-
-// INSTANCES OF VERTEX INDEX
-template class VertexIndex<std::nullptr_t>;
-
-// **************** EdgeIndex
-template <class K>
-EdgeIterator EdgeIndex<K>::for_range(DbAccessor &t, Border<K> from,
-                                     Border<K> to)
-{
-    return CALL(for_range(trans(t), std::move(from), std::move(to)));
-}
-
-template <class K>
-IndexType EdgeIndex<K>::type()
-{
-    return HALF_CALL(type());
-}
-
-// INSTANCES OF EDGE INDEX
-template class EdgeIndex<std::nullptr_t>;
-
-// ************************* DbAccessor
-DESTRUCTOR(DbAccessor, DbAccessor);
-
-VertexAccessIterator DbAccessor::vertex_access()
-{
-    return CALL(vertex_access());
-}
-
-Option<const VertexAccessor> DbAccessor::vertex_find(const Id &id)
-{
-    return HALF_CALL(vertex_find(id)).map<const VertexAccessor>();
-}
-
-VertexAccessor DbAccessor::vertex_insert() { return CALL(vertex_insert()); }
-
-EdgeAccessIterator DbAccessor::edge_access() { return CALL(edge_access()); }
-
-Option<const EdgeAccessor> DbAccessor::edge_find(const Id &id)
-{
-    return HALF_CALL(edge_find(id)).map<const EdgeAccessor>();
-}
-
-EdgeAccessor DbAccessor::edge_insert(VertexAccessor const &from,
-                                     VertexAccessor const &to)
-{
-    return CALL(edge_insert(trans(from), trans(to)));
-}
-
-const Label &DbAccessor::label_find_or_create(const char *name)
-{
-    return CALL(label_find_or_create(name));
-}
-
-bool DbAccessor::label_contains(const char *name)
-{
-    return HALF_CALL(label_contains(name));
-}
-
-const EdgeType &DbAccessor::type_find_or_create(const char *name)
-{
-    return CALL(type_find_or_create(name));
-}
-
-bool DbAccessor::type_contains(const char *name)
-{
-    return HALF_CALL(type_contains(name));
-}
-
-VertexPropertyFamily &
-DbAccessor::vertex_property_family_get(const std::string &name)
-{
-    return CALL(vertex_property_family_get(name));
-}
-
-EdgePropertyFamily &
-DbAccessor::edge_property_family_get(const std::string &name)
-{
-    return CALL(edge_property_family_get(name));
-}
-
-VertexPropertyKey DbAccessor::vertex_property_key(const std::string &name,
-                                                  Type type)
-{
-    return CALL(vertex_property_key(name, type));
-}
-
-EdgePropertyKey DbAccessor::edge_property_key(const std::string &name,
-                                              Type type)
-{
-    return CALL(edge_property_key(name, type));
-}
-
-template <class T>
-VertexPropertyType<T> DbAccessor::vertex_property_key(const std::string &name)
-{
-    return CALL(vertex_property_key<T>(name));
-}
-#define DbAccessor_vertex_property_key(x)                                      \
-    template VertexPropertyType<x> DbAccessor::vertex_property_key<x>(         \
-        const std::string &name);
-INSTANTIATE_FOR_PROPERTY(DbAccessor_vertex_property_key)
-
-template <class T>
-EdgePropertyType<T> DbAccessor::edge_property_key(const std::string &name)
-{
-    return CALL(edge_property_key<T>(name));
-}
-#define DbAccessor_edge_property_key(x)                                        \
-    template EdgePropertyType<x> DbAccessor::edge_property_key<x>(             \
-        const std::string &name);
-INSTANTIATE_FOR_PROPERTY(DbAccessor_edge_property_key)
-
-bool DbAccessor::commit() { return HALF_CALL(commit()); }
-void DbAccessor::abort() { HALF_CALL(abort()); }
-
-// ************************** VertexAccessor
-DUP(VertexAccessor, COPY_CONSTRUCTOR);
-DUP(VertexAccessor, COPY_CONSTRUCTOR_MUT);
-MOVE_CONSTRUCTOR(VertexAccessor);
-MOVE_CONST_CONSTRUCTOR(VertexAccessor);
-DESTRUCTOR(VertexAccessor, VertexAccessor);
-COPY_OPERATOR(VertexAccessor);
-MOVE_OPERATOR(VertexAccessor);
-
-bool VertexAccessor::isolated() const { return HALF_CALL(isolated()); }
-
-size_t VertexAccessor::out_degree() const { return HALF_CALL(out_degree()); }
-
-size_t VertexAccessor::in_degree() const { return HALF_CALL(in_degree()); }
-
-size_t VertexAccessor::degree() const { return HALF_CALL(degree()); }
-
-bool VertexAccessor::add_label(const Label &label)
-{
-    return HALF_CALL(add_label(trans(label)));
-}
-
-bool VertexAccessor::remove_label(const Label &label)
-{
-    return HALF_CALL(remove_label(trans(label)));
-}
-
-bool VertexAccessor::has_label(const Label &label) const
-{
-    return HALF_CALL(has_label(trans(label)));
-}
-
-const std::vector<label_ref_t> &VertexAccessor::labels() const
-{
-    return CALL(labels());
-}
-
-OutEdgesIterator VertexAccessor::out() const { return CALL(out()); }
-
-InEdgesIterator VertexAccessor::in() const { return CALL(in()); }
-
-bool VertexAccessor::in_contains(VertexAccessor const &other) const
-{
-    return HALF_CALL(in_contains(trans(other)));
-}
-
-bool VertexAccessor::empty() const { return HALF_CALL(empty()); }
-
-bool VertexAccessor::fill() const { return HALF_CALL(fill()); }
-
-const Id &VertexAccessor::id() const { return HALF_CALL(id()); }
-
-VertexAccessor VertexAccessor::update() const { return CALL(update()); }
-
-void VertexAccessor::remove() const { HALF_CALL(remove()); }
-
-const VertexStoredProperty &VertexAccessor::at(VertexPropertyFamily &key) const
-{
-    return CALL(at(trans(key)));
-}
-
-const VertexStoredProperty &VertexAccessor::at(VertexPropertyKey &key) const
-{
-    return CALL(at(trans(key)));
-}
-
-// template <class TG>
-// bool VertexAccessor::contains(property_key<TG> &key) const
-// {
-//     return HALF_CALL(contains<TG>(key));
-// }
-
-template <class V>
-OptionPtr<const V> VertexAccessor::at(VertexPropertyType<V> &key) const
-{
-    return HALF_CALL(at(trans<V>(key)));
-}
-#define VertexAccessor_at(x)                                                   \
-    template OptionPtr<const x> VertexAccessor::at(VertexPropertyType<x> &key) \
-        const;
-INSTANTIATE_FOR_PROPERTY(VertexAccessor_at);
-
-void VertexAccessor::set(VertexPropertyKey &key, Property &&value)
-{
-    HALF_CALL(set(trans(key), std::move(value)));
-}
-
-void VertexAccessor::clear(VertexPropertyKey &key)
-{
-    HALF_CALL(clear(trans(key)));
-}
-
-void VertexAccessor::clear(VertexPropertyFamily &key)
-{
-    HALF_CALL(clear(trans(key)));
-}
-
-// NOTE: I am not quite sure if this method will have any use
-template <class Handler>
-void VertexAccessor::accept(Handler &handler) const
-{
-    HALF_CALL(accept(handler));
-}
-
-VertexAccessor::operator bool() const { return HALF_CALL(operator bool()); }
-
-bool operator==(const VertexAccessor &a, const VertexAccessor &b)
-{
-    return trans(a) == trans(b);
-}
-
-bool operator!=(const VertexAccessor &a, const VertexAccessor &b)
-{
-    return trans(a) != trans(b);
-}
-
-// ************************** EdgeAccessor
-DUP(EdgeAccessor, COPY_CONSTRUCTOR);
-DUP(EdgeAccessor, COPY_CONSTRUCTOR_MUT);
-MOVE_CONSTRUCTOR(EdgeAccessor);
-MOVE_CONST_CONSTRUCTOR(EdgeAccessor);
-DESTRUCTOR(EdgeAccessor, EdgeAccessor);
-COPY_OPERATOR(EdgeAccessor);
-MOVE_OPERATOR(EdgeAccessor);
-
-void EdgeAccessor::edge_type(const EdgeType &edge_type)
-{
-    HALF_CALL(edge_type(trans(edge_type)));
-}
-
-const EdgeType &EdgeAccessor::edge_type() const { return CALL(edge_type()); }
-
-const VertexAccessor EdgeAccessor::from() const { return CALL(from()); }
-
-const VertexAccessor EdgeAccessor::to() const { return CALL(to()); }
-
-bool EdgeAccessor::empty() const { return HALF_CALL(empty()); }
-
-bool EdgeAccessor::fill() const { return HALF_CALL(fill()); }
-
-const Id &EdgeAccessor::id() const { return HALF_CALL(id()); }
-
-EdgeAccessor EdgeAccessor::update() const { return CALL(update()); }
-
-void EdgeAccessor::remove() const { HALF_CALL(remove()); }
-
-const EdgeStoredProperty &EdgeAccessor::at(EdgePropertyFamily &key) const
-{
-    return CALL(at(trans(key)));
-}
-
-const EdgeStoredProperty &EdgeAccessor::at(EdgePropertyKey &key) const
-{
-    return CALL(at(trans(key)));
-}
-
-template <class V>
-OptionPtr<const V> EdgeAccessor::at(EdgePropertyType<V> &key) const
-{
-    return HALF_CALL(at(trans<V>(key)));
-}
-#define EdgeAccessor_at(x)                                                     \
-    template OptionPtr<const x> EdgeAccessor::at(EdgePropertyType<x> &key)     \
-        const;
-INSTANTIATE_FOR_PROPERTY(EdgeAccessor_at);
-
-void EdgeAccessor::set(EdgePropertyKey &key, Property &&value)
-{
-    HALF_CALL(set(trans(key), std::move(value)));
-}
-
-void EdgeAccessor::clear(EdgePropertyKey &key) { HALF_CALL(clear(trans(key))); }
-
-void EdgeAccessor::clear(EdgePropertyFamily &key)
-{
-    HALF_CALL(clear(trans(key)));
-}
-
-// NOTE: I am not quite sure if this method will have any use
-template <class Handler>
-void EdgeAccessor::accept(Handler &handler) const
-{
-    HALF_CALL(accept(handler));
-}
-
-EdgeAccessor::operator bool() const { return HALF_CALL(operator bool()); }
-
-bool operator==(const EdgeAccessor &a, const EdgeAccessor &b)
-{
-    return trans(a) == trans(b);
-}
-
-bool operator!=(const EdgeAccessor &a, const EdgeAccessor &b)
-{
-    return trans(a) != trans(b);
-}
-
-// ************************* VertexIterator
-DESTRUCTOR(VertexIterator, Virtual);
-
-Option<const VertexAccessor> VertexIterator::next()
-{
-    return HALF_CALL(next()).map<const VertexAccessor>();
-}
-
-Count VertexIterator::count() { return HALF_CALL(count()); }
-
-// ************************* EdgeIterator
-DESTRUCTOR(EdgeIterator, Virtual);
-
-Option<const EdgeAccessor> EdgeIterator::next()
-{
-    return HALF_CALL(next()).map<const EdgeAccessor>();
-}
-
-Count EdgeIterator::count() { return HALF_CALL(count()); }
-
-// ************************* OutEdgesIterator
-DESTRUCTOR(OutEdgesIterator, out_edge_iterator_t);
-
-Option<const EdgeAccessor> OutEdgesIterator::next()
-{
-    return HALF_CALL(next()).map<const EdgeAccessor>();
-}
-
-Count OutEdgesIterator::count() { return HALF_CALL(count()); }
-
-// ************************* InEdgesIterator
-DESTRUCTOR(InEdgesIterator, in_edge_iterator_t);
-
-Option<const EdgeAccessor> InEdgesIterator::next()
-{
-    return HALF_CALL(next()).map<const EdgeAccessor>();
-}
-
-Count InEdgesIterator::count() { return HALF_CALL(count()); }
-
-// ************************* VertexAccessIterator
-DESTRUCTOR(VertexAccessIterator, vertex_access_iterator_t);
-
-Option<const VertexAccessor> VertexAccessIterator::next()
-{
-    return HALF_CALL(next()).map<const VertexAccessor>();
-}
-
-Count VertexAccessIterator::count() { return HALF_CALL(count()); }
-
-// ************************* EdgeAccessIterator
-DESTRUCTOR(EdgeAccessIterator, edge_access_iterator_t);
-
-Option<const EdgeAccessor> EdgeAccessIterator::next()
-{
-    return HALF_CALL(next()).map<const EdgeAccessor>();
-}
-
-Count EdgeAccessIterator::count() { return HALF_CALL(count()); }
-
-// ************************* VertexPropertyKey
-DESTRUCTOR(VertexPropertyKey, PropertyFamilyKey);
-
-Type VertexPropertyKey::get_type() const { return HALF_CALL(get_type()); }
-
-// ************************* EdgePropertyKey
-DESTRUCTOR(EdgePropertyKey, PropertyFamilyKey);
-
-Type EdgePropertyKey::get_type() const { return HALF_CALL(get_type()); }
-
-// ************************* VertexPropertyType
-#define VERTEX_PROPERTY_TYPE(x) template class VertexPropertyType<x>;
-INSTANTIATE_FOR_PROPERTY(VERTEX_PROPERTY_TYPE)
-
-// ************************* VertexPropertyFamily
-OptionPtr<VertexIndex<std::nullptr_t>> VertexPropertyFamily::index()
-{
-    OptionPtr<IndexBase<TypeGroupVertex, std::nullptr_t>> ret =
-        THIS->index.get_read();
-    if (ret.is_present()) {
-        return OptionPtr<VertexIndex<std::nullptr_t>>(&trans(*ret.get()));
-    } else {
-        return OptionPtr<VertexIndex<std::nullptr_t>>();
-    }
-}
-
-// ************************* VertexPropertyFamily
-OptionPtr<EdgeIndex<std::nullptr_t>> EdgePropertyFamily::index()
-{
-    OptionPtr<IndexBase<TypeGroupEdge, std::nullptr_t>> ret =
-        THIS->index.get_read();
-    if (ret.is_present()) {
-        return OptionPtr<EdgeIndex<std::nullptr_t>>(&trans(*ret.get()));
-    } else {
-        return OptionPtr<EdgeIndex<std::nullptr_t>>();
-    }
-}
-
-// ************************* BOLT SERIALIZER
-template <class Stream>
-RecordStream<Stream>::~RecordStream()
-{
-    // TODO: solve this
-    // THIS->~RecordStream();
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const VertexAccessor &vertex)
-{
-    HALF_CALL(write(trans(vertex)));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const EdgeAccessor &edge)
-{
-    HALF_CALL(write(trans(edge)));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const VertexStoredProperty &prop)
-{
-    HALF_CALL(write(trans(prop)));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const EdgeStoredProperty &prop)
-{
-    HALF_CALL(write(trans(prop)));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const Null &v)
-{
-    HALF_CALL(write(v));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const Bool &prop)
-{
-    HALF_CALL(write(prop));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const Float &prop)
-{
-    HALF_CALL(write(prop));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const Double &prop)
-{
-    HALF_CALL(write(prop));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const Int32 &prop)
-{
-    HALF_CALL(write(prop));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const Int64 &prop)
-{
-    HALF_CALL(write(prop));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const String &value)
-{
-    HALF_CALL(write(value));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const ArrayBool &arr)
-{
-    HALF_CALL(write(arr));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const ArrayInt32 &arr)
-{
-    HALF_CALL(write(arr));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const ArrayInt64 &arr)
-{
-    HALF_CALL(write(arr));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const ArrayFloat &arr)
-{
-    HALF_CALL(write(arr));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const ArrayDouble &arr)
-{
-    HALF_CALL(write(arr));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write(const ArrayString &arr)
-{
-    HALF_CALL(write(arr));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_empty_fields()
-{
-    HALF_CALL(write_empty_fields());
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_success()
-{
-    HALF_CALL(write_success());
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_success_empty()
-{
-    HALF_CALL(write_success_empty());
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_ignored()
-{
-    HALF_CALL(write_ignored());
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_fields(const std::vector<std::string> &fields)
-{
-    HALF_CALL(write_fields(fields));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_field(const std::string &field)
-{
-    HALF_CALL(write_field(field));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_list_header(size_t size)
-{
-    HALF_CALL(write_list_header(size));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_record()
-{
-    HALF_CALL(write_record());
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_meta(const std::string &type)
-{
-    HALF_CALL(write_meta(type));
-}
-
-template <class Stream>
-void RecordStream<Stream>::write_failure(
-    const std::map<std::string, std::string> &data)
-{
-    HALF_CALL(write_failure(data));
-}
-
-template <class Stream>
-void RecordStream<Stream>::send()
-{
-    HALF_CALL(send());
-}
-
-template <class Stream>
-void RecordStream<Stream>::chunk()
-{
-    HALF_CALL(chunk());
-}
-
-template class RecordStream<io::Socket>;
-}
-
-// **************************** ERROR EXAMPLES ****************************** //
-// **************************** COMPILE TIME
-/*
-### error:
-../libmemgraph.a(barrier.cpp.o): In function `Option<barrier::VertexAccessor
-const> Option<VertexAccessor const>::map<barrier::VertexAccessor const>()':
-/home/ktf/Workspace/memgraph/include/utils/option.hpp:111: undefined reference
-to `barrier::VertexAccessor::VertexAccessor<VertexAccessor const>(VertexAccessor
-const&&)'
-
-# description:
-Constructor VertexAccessor<::VertexAccessor const>(::VertexAccessor const&&)
-isn't written.
-
-
-### error:
-../libmemgraph.a(barrier.cpp.o): In function `barrier::EdgeAccessor::from()
-const':
-/home/ktf/Workspace/memgraph/src/barrier/barrier.cpp:501: undefined reference to
-`barrier::VertexAccessor::VertexAccessor<barrier::VertexAccessor
-const>(barrier::VertexAccessor const&&)'
-
-# description:
-Move constructor VertexAccessor<VertexAccessor const>(VertexAccessor const&&)
-isn't defined.
-
-
-### error:
-/home/ktf/Workspace/memgraph/src/barrier/barrier.cpp:282:12: error: call to
-'trans' is ambiguous
-    return CALL(at(trans(key)));
-           ^~~~~~~~~~~~~~~~~~~~
-/home/ktf/Workspace/memgraph/src/barrier/barrier.cpp:18:17: note: expanded from
-macro 'CALL'
-#define CALL(x) trans(HALF_CALL(x))
-                ^~~~~
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:208:21: note: candidate
-function
-DUP(VertexAccessor, TRANSFORM_VALUE);
-                    ^
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:169:21: note: candidate
-function
-DUP(VertexAccessor, TRANSFORM_REF);
-                    ^
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:170:19: note: candidate
-function
-DUP(EdgeAccessor, TRANSFORM_REF);
-                  ^
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:174:1: note: candidate
-function
-TRANSFORM_REF(VertexPropertyKey,
-^
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:25:14: note: expanded
-from macro 'TRANSFORM_REF'
-    y const &trans(x const &l) { return ref_as<y const>(l); }                  \
-             ^
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:176:1: note: candidate
-function
-TRANSFORM_REF(EdgePropertyKey,
-^
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:25:14: note: expanded
-from macro 'TRANSFORM_REF'
-    y const &trans(x const &l) { return ref_as<y const>(l); }                  \
-             ^
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:182:1: note: candidate
-function
-TRANSFORM_REF(VertexIterator, ::iter::Virtual<const ::VertexAccessor>);
-^
-/home/ktf/Workspace/memgraph/include/barrier/trans.hpp:23:14: note: expanded
-from macro 'TRANSFORM_REF'
-    x const &trans(y const &l) { return ref_as<x const>(l); }                  \
-...
-
-# description:
-There is no valid transformation for types on which trans is called.
-
-*/

src/communication/bolt/v1/states/executor.cpp

@@ -31,13 +31,27 @@ State *Executor::run(Session &session)
             return this->run(session, q);
             // TODO: RETURN success MAYBE
         }
-        catch (QueryEngineException &e)
+        catch (const CypherLexicalError &e)
+        {
+            session.output_stream.write_failure(
+                {{"code", "Memgraph.CypherLexicalError"},
+                 {"message", e.what()}});
+            session.output_stream.send();
+            return session.bolt.states.error.get();
+        }
+        catch (const QueryEngineException &e)
         {
             session.output_stream.write_failure(
                 {{"code", "Memgraph.QueryEngineException"},
                  {"message", e.what()}});
             session.output_stream.send();
             return session.bolt.states.error.get();
+        } catch (std::exception &e) {
+            session.output_stream.write_failure(
+                {{"code", "Memgraph.Exception"},
+                 {"message", e.what()}});
+            session.output_stream.send();
+            return session.bolt.states.error.get();
         }
     }
     else if (message_type == MessageCode::PullAll)

src/communication/bolt/v1/transport/bolt_decoder.cpp

@@ -90,7 +90,7 @@ std::string BoltDecoder::read_string()
         size = marker & 0x0F;
     }
     // if the marker is 0xD0, size is an 8-bit unsigned integer
-    if (marker == pack::String8) {
+    else if (marker == pack::String8) {
         size = read_byte();
     }
     // if the marker is 0xD1, size is a 16-bit big-endian unsigned integer

src/database/db_accessor.cpp

@@ -3,12 +3,12 @@
 #include "utils/iterator/iterator.hpp"
 
 DbAccessor::DbAccessor(Db &db)
-    : db_transaction(DbTransaction(db, db.tx_engine.begin()))
+    : db_transaction(std::move(DbTransaction(db, db.tx_engine.begin())))
 {
 }
 
 DbAccessor::DbAccessor(Db &db, tx::Transaction &t)
-    : db_transaction(DbTransaction(db, t))
+    : db_transaction(std::move(DbTransaction(db, t)))
 {
 }
 
@@ -105,6 +105,11 @@ DbAccessor::edge_property_key(const std::string &name, Type type)
     return edge_property_family_get(name).get(type).family_key();
 }
 
+bool DbAccessor::update_indexes()
+{
+    return db_transaction.update_indexes();
+}
+
 // TRANSACTION METHODS
 bool DbAccessor::commit()
 {