From ae4e52ff698b71bb2a928fc55584557edbd175f9 Mon Sep 17 00:00:00 2001 From: Kruno Tomola Fabro Date: Tue, 30 Aug 2016 18:13:23 +0100 Subject: [PATCH] Extracted class Composable from BaseIterator. Added iter::Virtual. Indexes::for_all now return iter::Virtual --- include/barrier/barrier.hpp | 52 ++++--- include/barrier/trans.hpp | 36 ++--- include/query_engine/hardcode/queries.hpp | 4 +- .../impl/nonunique_unordered_index.hpp | 2 +- .../indexes/impl/unique_ordered_index.hpp | 2 +- include/storage/indexes/index_base.hpp | 4 +- include/utils/iterator/composable.hpp | 146 ++++++++++++++++++ include/utils/iterator/count.hpp | 6 +- include/utils/iterator/filter.hpp | 4 +- include/utils/iterator/flat_map.hpp | 6 +- include/utils/iterator/inspect.hpp | 4 +- include/utils/iterator/iterator.hpp | 1 + include/utils/iterator/iterator_accessor.hpp | 5 +- include/utils/iterator/iterator_base.hpp | 130 +--------------- include/utils/iterator/lambda_iterator.hpp | 4 +- include/utils/iterator/limited_map.hpp | 5 +- include/utils/iterator/map.hpp | 4 +- include/utils/iterator/virtual_iter.hpp | 48 ++++++ src/barrier/barrier.cpp | 12 +- .../impl/nonunique_unordered_index.cpp | 5 +- .../indexes/impl/unique_ordered_index.cpp | 5 +- tests/integration/queries.cpp | 15 +- tests/integration/transaction_db.cpp | 14 ++ tests/integration/transaction_delete.cpp | 0 tests/integration/transaction_delete.hpp | 0 25 files changed, 304 insertions(+), 210 deletions(-) create mode 100644 include/utils/iterator/composable.hpp create mode 100644 include/utils/iterator/virtual_iter.hpp create mode 100644 tests/integration/transaction_db.cpp create mode 100644 tests/integration/transaction_delete.cpp create mode 100644 tests/integration/transaction_delete.hpp diff --git a/include/barrier/barrier.hpp b/include/barrier/barrier.hpp index fe848c88d..74b645a67 100644 --- a/include/barrier/barrier.hpp +++ b/include/barrier/barrier.hpp @@ -283,8 +283,9 @@ public: void abort(); }; -class VertexIterator : public Sized<8, 8>, - public IteratorBase +class VertexIterator + : public Sized<8, 8>, + public iter::Composable { public: template @@ -296,14 +297,15 @@ public: VertexIterator &operator=(const VertexIterator &other) = delete; VertexIterator &operator=(VertexIterator &&other) = delete; - Option next() final; + Option next(); - Count count() final; + Count count(); }; // TODO: Find reasons of such great size ant try to decrease it. -class VertexAccessIterator : public Sized<560, 8>, - public IteratorBase +class VertexAccessIterator + : public Sized<560, 8>, + public iter::Composable { public: template @@ -315,14 +317,15 @@ public: VertexAccessIterator &operator=(const VertexAccessIterator &other) = delete; VertexAccessIterator &operator=(VertexAccessIterator &&other) = delete; - Option next() final; + Option next(); - Count count() final; + Count count(); }; // TODO: Find reasons of such great size ant try to decrease it. -class EdgeAccessIterator : public Sized<560, 8>, - public IteratorBase +class EdgeAccessIterator + : public Sized<560, 8>, + public iter::Composable { public: template @@ -334,13 +337,14 @@ public: EdgeAccessIterator &operator=(const EdgeAccessIterator &other) = delete; EdgeAccessIterator &operator=(EdgeAccessIterator &&other) = delete; - Option next() final; + Option next(); - Count count() final; + Count count(); }; -class OutEdgesIterator : public Sized<48, 8>, - public IteratorBase +class OutEdgesIterator + : public Sized<48, 8>, + public iter::Composable { public: template @@ -352,13 +356,14 @@ public: OutEdgesIterator &operator=(const OutEdgesIterator &other) = delete; OutEdgesIterator &operator=(OutEdgesIterator &&other) = delete; - Option next() final; + Option next(); - Count count() final; + Count count(); }; -class InEdgesIterator : public Sized<64, 8>, - public IteratorBase +class InEdgesIterator + : public Sized<64, 8>, + public iter::Composable { public: template @@ -370,12 +375,13 @@ public: InEdgesIterator &operator=(const InEdgesIterator &other) = delete; InEdgesIterator &operator=(InEdgesIterator &&other) = delete; - Option next() final; + Option next(); - Count count() final; + Count count(); }; -class EdgeIterator : public Sized<8, 8>, public IteratorBase +class EdgeIterator : public Sized<8, 8>, + public iter::Composable { public: template @@ -387,9 +393,9 @@ public: EdgeIterator &operator=(const EdgeIterator &other) = delete; EdgeIterator &operator=(EdgeIterator &&other) = delete; - Option next() final; + Option next(); - Count count() final; + Count count(); EdgeIterator &operator->() { return *this; } }; diff --git a/include/barrier/trans.hpp b/include/barrier/trans.hpp index 1e474903f..0552138e5 100644 --- a/include/barrier/trans.hpp +++ b/include/barrier/trans.hpp @@ -177,14 +177,12 @@ TRANSFORM_REF(EdgePropertyKey, ::EdgePropertyFamily::PropertyType::PropertyFamilyKey); // ITERATORS -TRANSFORM_REF_SIZED(VertexIterator, - std::unique_ptr>); -TRANSFORM_REF_SIZED(EdgeIterator, - std::unique_ptr>); -TRANSFORM_REF_SIZED(VertexAccessIterator, vertex_access_iterator_t); -TRANSFORM_REF_SIZED(EdgeAccessIterator, edge_access_iterator_t); -TRANSFORM_REF_SIZED(OutEdgesIterator, out_edge_iterator_t); -TRANSFORM_REF_SIZED(InEdgesIterator, in_edge_iterator_t); +TRANSFORM_REF(VertexIterator, ::iter::Virtual); +TRANSFORM_REF(EdgeIterator, ::iter::Virtual); +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 TRANSFORM_REF_TEMPLATED(VertexIndex, VertexIndexBase); @@ -212,22 +210,18 @@ TRANSFORM_VALUE(EdgePropertyKey, TRANSFORM_VALUE(VertexPropertyKey, ::VertexPropertyFamily::PropertyType::PropertyFamilyKey); TRANSFORM_VALUE_ONE(VertexAccessIterator, vertex_access_iterator_t); -// MOVE_CONSTRUCTOR_FORCED(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); +MOVE_CONSTRUCTOR_FORCED(EdgeAccessIterator, edge_access_iterator_t); TRANSFORM_VALUE_ONE(OutEdgesIterator, out_edge_iterator_t); -// MOVE_CONSTRUCTOR_FORCED(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, - std::unique_ptr>); -// MOVE_CONSTRUCTOR_FORCED(VertexIterator, -// std::unique_ptr>); -TRANSFORM_VALUE_ONE(EdgeIterator, - std::unique_ptr>); -// MOVE_CONSTRUCTOR_FORCED(EdgeIterator, -// std::unique_ptr>); +MOVE_CONSTRUCTOR_FORCED(InEdgesIterator, in_edge_iterator_t); +TRANSFORM_VALUE_ONE(VertexIterator, ::iter::Virtual); +MOVE_CONSTRUCTOR_FORCED(VertexIterator, + ::iter::Virtual); +TRANSFORM_VALUE_ONE(EdgeIterator, ::iter::Virtual); +MOVE_CONSTRUCTOR_FORCED(EdgeIterator, ::iter::Virtual); template TRANSFORM_VALUE_ONE_RAW( diff --git a/include/query_engine/hardcode/queries.hpp b/include/query_engine/hardcode/queries.hpp index 6424b745a..f67b72fcd 100644 --- a/include/query_engine/hardcode/queries.hpp +++ b/include/query_engine/hardcode/queries.hpp @@ -405,8 +405,8 @@ auto load_queries(Db &db) queries[14897166600223619735u] = match_edge_all_delete; queries[16888549834923624215u] = match_edge_type_delete; queries[11675960684124428508u] = match_id_type_return; - queries[1554436524951961398u] = match_name_type_return; - queries[8537338362659537296u] = match_name_type_return_cross; + queries[15698881472054193835u] = match_name_type_return; + queries[12595102442911913761u] = match_name_type_return_cross; queries[8918221081398321263u] = match_label_type_return; return queries; diff --git a/include/storage/indexes/impl/nonunique_unordered_index.hpp b/include/storage/indexes/impl/nonunique_unordered_index.hpp index 6cd52ae55..6fba48e75 100644 --- a/include/storage/indexes/impl/nonunique_unordered_index.hpp +++ b/include/storage/indexes/impl/nonunique_unordered_index.hpp @@ -24,7 +24,7 @@ public: // Returns iterator which returns valid records in range. // ordered==None => doesn't guarantee any order of submitting records. - std::unique_ptr> + iter::Virtual for_range(DbAccessor &t, Border from = Border(), Border to = Border()) final; diff --git a/include/storage/indexes/impl/unique_ordered_index.hpp b/include/storage/indexes/impl/unique_ordered_index.hpp index d4519e6d9..bdc0f560f 100644 --- a/include/storage/indexes/impl/unique_ordered_index.hpp +++ b/include/storage/indexes/impl/unique_ordered_index.hpp @@ -22,7 +22,7 @@ public: // Returns iterator which returns valid records in range. // ordered==None => doesn't guarantee any order of submitting records. - std::unique_ptr> + iter::Virtual for_range(DbAccessor &t, Border from = Border(), Border to = Border()) final; diff --git a/include/storage/indexes/index_base.hpp b/include/storage/indexes/index_base.hpp index be4d98612..08270d5ab 100644 --- a/include/storage/indexes/index_base.hpp +++ b/include/storage/indexes/index_base.hpp @@ -8,7 +8,7 @@ // #include "storage/indexes/index_record.hpp" #include "storage/garbage/delete_sensitive.hpp" #include "utils/border.hpp" -#include "utils/iterator/iterator_base.hpp" +#include "utils/iterator/virtual_iter.hpp" #include "utils/order.hpp" template @@ -50,7 +50,7 @@ public: // order==Descending => guarantees order of returned records will be from // largest to smallest. // Range must be from<=to - virtual std::unique_ptr> + virtual iter::Virtual for_range(DbAccessor &, Border from = Border(), Border to = Border()) = 0; diff --git a/include/utils/iterator/composable.hpp b/include/utils/iterator/composable.hpp new file mode 100644 index 000000000..857dbd4f8 --- /dev/null +++ b/include/utils/iterator/composable.hpp @@ -0,0 +1,146 @@ +#pragma once + +#include "utils/crtp.hpp" +#include "utils/iterator/count.hpp" +#include "utils/option.hpp" + +// class EdgeType; + +namespace iter +{ +template +auto make_map(I &&iter, OP &&op); + +template +auto make_filter(I &&iter, OP &&op); + +template +void for_all(I &&iter, C &&consumer); + +template +auto make_flat_map(I &&iter, OP &&op); + +template +auto make_inspect(I &&iter, OP &&op); + +template +auto make_limited_map(I &&iter, OP &&op); + +template +auto make_virtual(I &&iter); + +// Class for creating easy composable iterators fo querying. +// Derived - type of derived class +// T - return type +template +class Composable : public Crtp +{ + // Moves self + Derived &&move() { return std::move(this->derived()); } +public: + auto virtualize() { return iter::make_virtual(move()); } + + template + auto map(OP &&op) + { + return iter::make_map(move(), std::move(op)); + } + + template + auto filter(OP &&op) + { + return iter::make_filter(move(), std::move(op)); + } + + // Replaces every item with item taken from n if it exists. + template + auto replace(Option &n) + { + return iter::make_limited_map( + move(), [&](auto v) mutable { return std::move(n); }); + } + + // Maps with call to method to() and filters with call to fill. + auto to() + { + return map([](auto er) { return er.to(); }).fill(); + } + + // Maps with call to method from() and filters with call to fill. + auto from() + { + return map([](auto er) { return er.from(); }).fill(); + } + + // Combines out iterators into one iterator. + auto out() + { + return iter::make_flat_map( + move(), [](auto vr) { return vr.out().fill(); }); + } + + // Filters with label on from vertex. + template + auto from_label(LABEL const &label) + { + return filter([&](auto &ra) { + auto va = ra.from(); + return va.fill() && va.has_label(label); + }); + } + + // Filters with property under given key + template + auto has_property(KEY &key, PROP const &prop) + { + return filter([&](auto &va) { return va.at(key) == prop; }); + } + + // Copy-s all pasing value to t before they are returned. + // auto clone_to(Option &t) + // { + // return iter::make_inspect( + // std::move(*this), [&](auto &v) { t = Option(v); }); + // } + + // Copy-s pasing value to t before they are returned. + auto clone_to(Option &t) + { + return iter::make_inspect( + move(), [&](auto &v) mutable { t = Option(v); }); + } + + // Filters with call to method fill() + auto fill() + { + return filter([](auto &ra) { return ra.fill(); }); + } + + // Filters with type + template + auto type(TYPE const &type) + { + return filter([&](auto &ra) { return ra.edge_type() == type; }); + } + + // Filters with label. + template + auto label(LABEL const &label) + { + return filter([&](auto &va) { return va.has_label(label); }); + } + + // Filters out vertices which are connected. + auto isolated() + { + return filter([&](auto &ra) { return ra.isolated(); }); + } + + // For all items calls OP. + template + void for_all(OP &&op) + { + iter::for_all(move(), std::move(op)); + } +}; +} diff --git a/include/utils/iterator/count.hpp b/include/utils/iterator/count.hpp index 074f4a44d..7beffb1a0 100644 --- a/include/utils/iterator/count.hpp +++ b/include/utils/iterator/count.hpp @@ -12,11 +12,7 @@ public: Count(size_t min, size_t max) : min(min), max(max) {} - Count &min_zero() - { - min = 0; - return *this; - } + Count min_zero() const { return Count(0, max); } size_t avg() const { return ((max - min) >> 1) + min; } diff --git a/include/utils/iterator/filter.hpp b/include/utils/iterator/filter.hpp index f0c430309..2c87bbf46 100644 --- a/include/utils/iterator/filter.hpp +++ b/include/utils/iterator/filter.hpp @@ -1,7 +1,7 @@ #pragma once +#include "utils/iterator/composable.hpp" #include "utils/iterator/iterator_base.hpp" -#include "utils/option.hpp" namespace iter { @@ -12,7 +12,7 @@ namespace iter // I - iterator type // OP - type of filter function. OP: T& -> bool template -class Filter : public IteratorBase +class Filter : public IteratorBase, public Composable> { public: diff --git a/include/utils/iterator/flat_map.hpp b/include/utils/iterator/flat_map.hpp index 9fc748740..655d4b226 100644 --- a/include/utils/iterator/flat_map.hpp +++ b/include/utils/iterator/flat_map.hpp @@ -1,5 +1,8 @@ #pragma once +#include "utils/iterator/composable.hpp" +#include "utils/iterator/iterator_base.hpp" + namespace iter { @@ -12,7 +15,8 @@ namespace iter // J - iterator type returned from OP // OP - type of mapper function template -class FlatMap : public IteratorBase +class FlatMap : public IteratorBase, + public Composable> { public: diff --git a/include/utils/iterator/inspect.hpp b/include/utils/iterator/inspect.hpp index 8fba73b37..73c30088f 100644 --- a/include/utils/iterator/inspect.hpp +++ b/include/utils/iterator/inspect.hpp @@ -1,7 +1,7 @@ #pragma once +#include "utils/iterator/composable.hpp" #include "utils/iterator/iterator_base.hpp" -#include "utils/option.hpp" namespace iter { @@ -13,7 +13,7 @@ namespace iter // I - iterator type // OP - type of inspector function. OP: T&->void template -class Inspect : public IteratorBase +class Inspect : public IteratorBase, public Composable> { public: diff --git a/include/utils/iterator/iterator.hpp b/include/utils/iterator/iterator.hpp index 44091046b..a540dff0d 100644 --- a/include/utils/iterator/iterator.hpp +++ b/include/utils/iterator/iterator.hpp @@ -12,3 +12,4 @@ #include "utils/iterator/limited_map.hpp" #include "utils/iterator/map.hpp" #include "utils/iterator/range_iterator.hpp" +#include "utils/iterator/virtual_iter.hpp" diff --git a/include/utils/iterator/iterator_accessor.hpp b/include/utils/iterator/iterator_accessor.hpp index 2acd960d3..32d496102 100644 --- a/include/utils/iterator/iterator_accessor.hpp +++ b/include/utils/iterator/iterator_accessor.hpp @@ -1,7 +1,7 @@ #pragma once +#include "utils/iterator/composable.hpp" #include "utils/iterator/iterator_base.hpp" -#include "utils/option.hpp" namespace iter { @@ -11,7 +11,8 @@ namespace iter // I - iterator type gotten from accessor // A - accessor type template -class IteratorAccessor : public IteratorBase +class IteratorAccessor : public IteratorBase, + public Composable> { public: IteratorAccessor() = delete; diff --git a/include/utils/iterator/iterator_base.hpp b/include/utils/iterator/iterator_base.hpp index 019aeb5f2..610126901 100644 --- a/include/utils/iterator/iterator_base.hpp +++ b/include/utils/iterator/iterator_base.hpp @@ -3,29 +3,6 @@ #include "utils/iterator/count.hpp" #include "utils/option.hpp" -class EdgeType; - -namespace iter -{ -template -auto make_map(I &&iter, OP &&op); - -template -auto make_filter(I &&iter, OP &&op); - -template -void for_all(I &&iter, C &&consumer); - -template -auto make_flat_map(I &&iter, OP &&op); - -template -auto make_inspect(I &&iter, OP &&op); - -template -auto make_limited_map(I &&iter, OP &&op); -} - // Base iterator for next() kind iterator. // T - type of return value template @@ -36,110 +13,5 @@ public: virtual Option next() = 0; - virtual Count count() { return Count(0, ~((size_t)0)); } - - template - auto map(OP &&op) - { - return iter::make_map(std::move(*this), - std::move(op)); - } - - template - auto filter(OP &&op) - { - return iter::make_filter( - std::move(*this), std::move(op)); - } - - // Replaces every item with item taken from n if it exists. - template - auto replace(Option &n) - { - return iter::make_limited_map( - std::move(*this), [&](auto v) mutable { return std::move(n); }); - } - - // Maps with call to method to() and filters with call to fill. - auto to() - { - return map([](auto er) { return er.to(); }).fill(); - } - - // Maps with call to method from() and filters with call to fill. - auto from() - { - return map([](auto er) { return er.from(); }).fill(); - } - - // Combines out iterators into one iterator. - auto out() - { - return iter::make_flat_map( - std::move(*this), [](auto vr) { return vr.out().fill(); }); - } - - // Filters with label on from vertex. - template - auto from_label(LABEL const &label) - { - return filter([&](auto &ra) { - auto va = ra.from(); - return va.fill() && va.has_label(label); - }); - } - - // Filters with property under given key - template - auto has_property(KEY &key, PROP const &prop) - { - return filter([&](auto &va) { return va.at(key) == prop; }); - } - - // Copy-s all pasing value to t before they are returned. - // auto clone_to(Option &t) - // { - // return iter::make_inspect( - // std::move(*this), [&](auto &v) { t = Option(v); }); - // } - - // Copy-s pasing value to t before they are returned. - auto clone_to(Option &t) - { - return iter::make_inspect( - std::move(*this), [&](auto &v) mutable { t = Option(v); }); - } - - // Filters with call to method fill() - auto fill() - { - return filter([](auto &ra) { return ra.fill(); }); - } - - // Filters with type - template - auto type(TYPE const &type) - { - return filter([&](auto &ra) { return ra.edge_type() == type; }); - } - - // Filters with label. - template - auto label(LABEL const &label) - { - return filter([&](auto &va) { return va.has_label(label); }); - } - - // Filters out vertices which are connected. - auto isolated() - { - return filter([&](auto &ra) { return ra.isolated(); }); - } - - // For all items calls OP. - template - void for_all(OP &&op) - { - iter::for_all(std::move(*this), std::move(op)); - } + virtual Count count() = 0; }; diff --git a/include/utils/iterator/lambda_iterator.hpp b/include/utils/iterator/lambda_iterator.hpp index cd130af31..cfae1c3d5 100644 --- a/include/utils/iterator/lambda_iterator.hpp +++ b/include/utils/iterator/lambda_iterator.hpp @@ -1,5 +1,6 @@ #pragma once +#include "utils/iterator/composable.hpp" #include "utils/iterator/iterator_base.hpp" namespace iter @@ -8,7 +9,8 @@ namespace iter // T - type of return value // F - type of wraped lambda template -class LambdaIterator : public IteratorBase +class LambdaIterator : public IteratorBase, + public Composable> { public: LambdaIterator(F &&f, size_t count) : func(std::move(f)), _count(count) {} diff --git a/include/utils/iterator/limited_map.hpp b/include/utils/iterator/limited_map.hpp index 83d4402e4..db2fb7333 100644 --- a/include/utils/iterator/limited_map.hpp +++ b/include/utils/iterator/limited_map.hpp @@ -1,7 +1,7 @@ #pragma once +#include "utils/iterator/composable.hpp" #include "utils/iterator/iterator_base.hpp" -#include "utils/option.hpp" namespace iter { @@ -12,7 +12,8 @@ namespace iter // I - iterator type // OP - type of mapper function. OP: V -> Option template -class LimitedMap : public IteratorBase +class LimitedMap : public IteratorBase, + public Composable> { public: diff --git a/include/utils/iterator/map.hpp b/include/utils/iterator/map.hpp index 53cf52f46..df9f6b174 100644 --- a/include/utils/iterator/map.hpp +++ b/include/utils/iterator/map.hpp @@ -1,7 +1,7 @@ #pragma once +#include "utils/iterator/composable.hpp" #include "utils/iterator/iterator_base.hpp" -#include "utils/option.hpp" namespace iter { @@ -12,7 +12,7 @@ namespace iter // I - iterator type // OP - type of mapper function template -class Map : public IteratorBase +class Map : public IteratorBase, public Composable> { public: diff --git a/include/utils/iterator/virtual_iter.hpp b/include/utils/iterator/virtual_iter.hpp new file mode 100644 index 000000000..6bee1c73d --- /dev/null +++ b/include/utils/iterator/virtual_iter.hpp @@ -0,0 +1,48 @@ +#pragma once + +#include "utils/iterator/composable.hpp" +#include "utils/iterator/iterator_base.hpp" + +namespace iter +{ + +// Class which wraps iterator and hides it's type. It actualy does this by +// dynamicly allocating iterator on heap. +// T - type of return value +template +class Virtual : public Composable> +{ + +public: + Virtual() = delete; + + // Virtual operation is designed to be used in chained calls which operate + // on a + // iterator. Virtual will in that usecase receive other iterator by value + // and + // std::move is a optimization for it. + + template + Virtual(I &&iter) : it(std::make_unique(std::move(iter))) + { + } + + Virtual(Virtual &&m) : it(std::move(m.it)) {} + + ~Virtual() {} + + Option next() { return it.get()->next(); } + + Count count() { return it.get()->count(); } + +private: + std::unique_ptr> it; +}; + +template +auto make_virtual(I &&iter) +{ + // Compiler cant deduce type T. decltype is here to help with it. + return Virtual(std::move(iter)); +} +} diff --git a/src/barrier/barrier.cpp b/src/barrier/barrier.cpp index 65fc1f710..8287b77d7 100644 --- a/src/barrier/barrier.cpp +++ b/src/barrier/barrier.cpp @@ -432,24 +432,24 @@ bool operator!=(const EdgeAccessor &a, const EdgeAccessor &b) } // ************************* VertexIterator -DESTRUCTOR(VertexIterator, unique_ptr); +DESTRUCTOR(VertexIterator, Virtual); Option VertexIterator::next() { - return HALF_CALL(get()->next()).map(); + return HALF_CALL(next()).map(); } -Count VertexIterator::count() { return HALF_CALL(get()->count()); } +Count VertexIterator::count() { return HALF_CALL(count()); } // ************************* EdgeIterator -DESTRUCTOR(EdgeIterator, unique_ptr); +DESTRUCTOR(EdgeIterator, Virtual); Option EdgeIterator::next() { - return HALF_CALL(get()->next()).map(); + return HALF_CALL(next()).map(); } -Count EdgeIterator::count() { return HALF_CALL(get()->count()); } +Count EdgeIterator::count() { return HALF_CALL(count()); } // ************************* OutEdgesIterator DESTRUCTOR(OutEdgesIterator, out_edge_iterator_t); diff --git a/src/storage/indexes/impl/nonunique_unordered_index.cpp b/src/storage/indexes/impl/nonunique_unordered_index.cpp index 006ae702a..5a11ee8f5 100644 --- a/src/storage/indexes/impl/nonunique_unordered_index.cpp +++ b/src/storage/indexes/impl/nonunique_unordered_index.cpp @@ -32,12 +32,11 @@ bool NonUniqueUnorderedIndex::insert(IndexRecord &&value) } template -std::unique_ptr> +iter::Virtual NonUniqueUnorderedIndex::for_range(DbAccessor &t, Border from, Border to) { - return std::make_unique( + return iter::make_virtual( for_range_exact(t, std::move(from), std::move(to))); } diff --git a/src/storage/indexes/impl/unique_ordered_index.cpp b/src/storage/indexes/impl/unique_ordered_index.cpp index dc2e6ec83..9d4add4d0 100644 --- a/src/storage/indexes/impl/unique_ordered_index.cpp +++ b/src/storage/indexes/impl/unique_ordered_index.cpp @@ -39,11 +39,10 @@ bool UniqueOrderedIndex::insert(IndexRecord &&value) } template -std::unique_ptr> +iter::Virtual UniqueOrderedIndex::for_range(DbAccessor &t, Border from, Border to) { - return std::make_unique( + return iter::make_virtual( for_range_exact(t, std::move(from), std::move(to))); } diff --git a/tests/integration/queries.cpp b/tests/integration/queries.cpp index f8d94f8c9..b242d9314 100644 --- a/tests/integration/queries.cpp +++ b/tests/integration/queries.cpp @@ -2,9 +2,9 @@ #include "barrier/barrier.cpp" +#include "communication/bolt/v1/serialization/bolt_serializer.hpp" #include "database/db.hpp" #include "query_engine/query_stripper.hpp" -#include "communication/bolt/v1/serialization/bolt_serializer.hpp" // #include "storage/edges.cpp" // #include "storage/edges.hpp" // #include "storage/vertices.cpp" @@ -35,10 +35,21 @@ int main(void) "MATCH (n: {id: 0}) SET n.name = \"TEST100\" RETURN n", "MATCH (n: {id: 1}) SET n.name = \"TEST101\" RETURN n", "MATCH (n: {id: 0}) SET n.name = \"TEST102\" RETURN n", - "MATCH (n:LABEL) RETURN n"}; + "MATCH (n:LABEL) RETURN n", "MATCH (n1), (n2) WHERE ID(n1)=0 AND " + "ID(n2)=1 CREATE (n1)<-[r:IS {age: " + "25,weight: 70}]-(n2) RETURN r", + "MATCH (n) RETURN n", "MATCH (n:LABEL) RETURN n", "MATCH (n) DELETE n ", + "MATCH (n:LABEL) DELETE n", "MATCH (n) WHERE ID(n) = 0 DELETE n", + "MATCH ()-[r]-() WHERE ID(r) = 0 DELETE r", "MATCH ()-[r]-() DELETE r", + "MATCH ()-[r:TYPE]-() DELETE r", + "MATCH (n)-[:TYPE]->(m) WHERE ID(n) = 0 RETURN m", + "MATCH (n)-[:TYPE]->(m) WHERE n.name = \"kruno\" RETURN m", + "MATCH (n)-[:TYPE]->(m) WHERE n.name = \"kruno\" RETURN n,m", + "MATCH (n:LABEL)-[:TYPE]->(m) RETURN n"}; for (auto &query : queries) { auto stripped = stripper.strip(query); + std::cout << "Query hash: " << stripped.hash << std::endl; auto result = query_functions[stripped.hash](stripped.arguments); permanent_assert(result == true, "Result retured from query function is not true"); diff --git a/tests/integration/transaction_db.cpp b/tests/integration/transaction_db.cpp new file mode 100644 index 000000000..caad9d9b8 --- /dev/null +++ b/tests/integration/transaction_db.cpp @@ -0,0 +1,14 @@ + +#include "database/db.hpp" +// #include "storage/edges.cpp" +// #include "storage/edges.hpp" +// #include "storage/vertices.cpp" +// #include "storage/vertices.hpp" +// #include "utils/assert.hpp" + +int main(void) +{ + Db db; + + return 0; +} diff --git a/tests/integration/transaction_delete.cpp b/tests/integration/transaction_delete.cpp new file mode 100644 index 000000000..e69de29bb diff --git a/tests/integration/transaction_delete.hpp b/tests/integration/transaction_delete.hpp new file mode 100644 index 000000000..e69de29bb