diff --git a/CMakeLists.txt b/CMakeLists.txt
index 40dc465c8..0813af66a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -429,8 +429,14 @@ set(memgraph_src_files
${src_dir}/storage/model/properties/array.cpp
${src_dir}/storage/model/properties/properties.cpp
${src_dir}/storage/model/properties/property_family.cpp
+ ${src_dir}/storage/indexes/index_base.cpp
+ ${src_dir}/storage/indexes/index_record.cpp
+ ${src_dir}/storage/indexes/index_update.cpp
+ ${src_dir}/storage/indexes/index_holder.cpp
+ ${src_dir}/storage/indexes/impl/unique_ordered_index.cpp
${src_dir}/storage/indexes/impl/nonunique_unordered_index.cpp
${src_dir}/storage/locking/record_lock.cpp
+ ${src_dir}/storage/garbage/garbage.cpp
${src_dir}/storage/vertex_accessor.cpp
${src_dir}/transactions/transaction.cpp
${src_dir}/template_engine/engine.cpp
@@ -442,6 +448,7 @@ set(memgraph_src_files
${src_dir}/logging/log.cpp
${src_dir}/io/network/tls.cpp
${src_dir}/database/db.cpp
+ ${src_dir}/database/db_transaction.cpp
${src_dir}/database/db_accessor.cpp
${src_dir}/storage/edge_accessor.cpp
${src_dir}/storage/record_accessor.cpp
diff --git a/include/communication/bolt/v1/serialization/bolt_serializer.hpp b/include/communication/bolt/v1/serialization/bolt_serializer.hpp
index d05609645..4e01b7948 100644
--- a/include/communication/bolt/v1/serialization/bolt_serializer.hpp
+++ b/include/communication/bolt/v1/serialization/bolt_serializer.hpp
@@ -33,7 +33,7 @@ public:
* }
*
*/
- void write(const Vertex::Accessor &vertex)
+ void write(const VertexAccessor &vertex)
{
// write signatures for the node struct and node data type
encoder.write_struct_header(3);
@@ -72,7 +72,7 @@ public:
* }
*
*/
- void write(const Edge::Accessor &edge)
+ void write(const EdgeAccessor &edge)
{
// write signatures for the edge struct and edge data type
encoder.write_struct_header(5);
diff --git a/include/communication/bolt/v1/serialization/record_stream.hpp b/include/communication/bolt/v1/serialization/record_stream.hpp
index aa4ab438f..39c5534ea 100644
--- a/include/communication/bolt/v1/serialization/record_stream.hpp
+++ b/include/communication/bolt/v1/serialization/record_stream.hpp
@@ -78,8 +78,8 @@ public:
}
// -- BOLT SPECIFIC METHODS -----------------------------------------------
- void write(const Vertex::Accessor &vertex) { serializer.write(vertex); }
- void write(const Edge::Accessor &edge) { serializer.write(edge); }
+ void write(const VertexAccessor &vertex) { serializer.write(vertex); }
+ void write(const EdgeAccessor &edge) { serializer.write(edge); }
void write(const Property &prop) { serializer.write(prop); }
void write(const Bool& prop) { serializer.write(prop); }
diff --git a/include/data_structures/concurrent/concurrent_list.hpp b/include/data_structures/concurrent/concurrent_list.hpp
index 76e547eda..04e221220 100644
--- a/include/data_structures/concurrent/concurrent_list.hpp
+++ b/include/data_structures/concurrent/concurrent_list.hpp
@@ -2,6 +2,7 @@
#include <atomic>
#include <cassert>
+#include <utility>
#include "utils/crtp.hpp"
template <class T>
diff --git a/include/data_structures/concurrent/concurrent_map.hpp b/include/data_structures/concurrent/concurrent_map.hpp
index 4e751a109..ae24568f1 100644
--- a/include/data_structures/concurrent/concurrent_map.hpp
+++ b/include/data_structures/concurrent/concurrent_map.hpp
@@ -8,53 +8,66 @@ using std::pair;
template <typename K, typename T>
class ConcurrentMap
{
- typedef Item<K, T> item_t;
- typedef SkipList<item_t> list;
- typedef typename SkipList<item_t>::Iterator list_it;
- typedef typename SkipList<item_t>::ConstIterator list_it_con;
-
- public:
- ConcurrentMap() {}
-
- class Accessor : public AccessorBase<item_t>
- {
- friend class ConcurrentMap;
-
- using AccessorBase<item_t>::AccessorBase;
-
-private:
- using AccessorBase<item_t>::accessor;
+ typedef Item<K, T> item_t;
+ typedef SkipList<item_t> list;
+ typedef typename SkipList<item_t>::Iterator list_it;
+ typedef typename SkipList<item_t>::ConstIterator list_it_con;
public:
- std::pair<list_it, bool> insert(const K &key, const T &data)
+ ConcurrentMap() {}
+
+ class Accessor : public AccessorBase<item_t>
{
- return accessor.insert(item_t(key, data));
- }
+ friend class ConcurrentMap;
- std::pair<list_it, bool> insert(const K &key, T &&data)
- {
- return accessor.insert(item_t(key, std::forward<T>(data)));
- }
+ using AccessorBase<item_t>::AccessorBase;
- std::pair<list_it, bool> insert(K &&key, T &&data)
- {
- return accessor.insert(
- item_t(std::forward<K>(key), std::forward<T>(data)));
- }
+ private:
+ using AccessorBase<item_t>::accessor;
- list_it_con find(const K &key) const { return accessor.find(key); }
+ public:
+ std::pair<list_it, bool> insert(const K &key, const T &data)
+ {
+ return accessor.insert(item_t(key, data));
+ }
- list_it find(const K &key) { return accessor.find(key); }
+ std::pair<list_it, bool> insert(const K &key, T &&data)
+ {
+ return accessor.insert(item_t(key, std::forward<T>(data)));
+ }
- bool contains(const K &key) const { return this->find(key) != this->end(); }
+ std::pair<list_it, bool> insert(K &&key, T &&data)
+ {
+ return accessor.insert(
+ item_t(std::forward<K>(key), std::forward<T>(data)));
+ }
- bool remove(const K &key) { return accessor.remove(key); }
- };
+ list_it_con find(const K &key) const { return accessor.find(key); }
- Accessor access() { return Accessor(&skiplist); }
+ list_it find(const K &key) { return accessor.find(key); }
- const Accessor access() const { return Accessor(&skiplist); }
+ list_it_con find_or_larger(const T &item) const
+ {
+ return accessor.find_or_larger(item);
+ }
- private:
- list skiplist;
+ list_it find_or_larger(const T &item)
+ {
+ return accessor.find_or_larger(item);
+ }
+
+ bool contains(const K &key) const
+ {
+ return this->find(key) != this->end();
+ }
+
+ bool remove(const K &key) { return accessor.remove(key); }
+ };
+
+ Accessor access() { return Accessor(&skiplist); }
+
+ const Accessor access() const { return Accessor(&skiplist); }
+
+private:
+ list skiplist;
};
diff --git a/include/data_structures/concurrent/concurrent_multimap.hpp b/include/data_structures/concurrent/concurrent_multimap.hpp
index cddce9914..1ae53ce75 100644
--- a/include/data_structures/concurrent/concurrent_multimap.hpp
+++ b/include/data_structures/concurrent/concurrent_multimap.hpp
@@ -53,6 +53,16 @@ public:
list_it find(const K &key) { return accessor.find(key); }
+ list_it_con find_or_larger(const T &item) const
+ {
+ return accessor.find_or_larger(item);
+ }
+
+ list_it find_or_larger(const T &item)
+ {
+ return accessor.find_or_larger(item);
+ }
+
bool contains(const K &key) const
{
return this->find(key) != this->end();
diff --git a/include/data_structures/concurrent/concurrent_multiset.hpp b/include/data_structures/concurrent/concurrent_multiset.hpp
index eae01c2d0..858620b1c 100644
--- a/include/data_structures/concurrent/concurrent_multiset.hpp
+++ b/include/data_structures/concurrent/concurrent_multiset.hpp
@@ -5,46 +5,59 @@
template <class T>
class ConcurrentMultiSet
{
- typedef SkipList<T> list;
- typedef typename SkipList<T>::Iterator list_it;
- typedef typename SkipList<T>::ConstIterator list_it_con;
-
- public:
- ConcurrentMultiSet() {}
-
- class Accessor : public AccessorBase<T>
- {
- friend class ConcurrentMultiSet;
-
- using AccessorBase<T>::AccessorBase;
-
-private:
- using AccessorBase<T>::accessor;
+ typedef SkipList<T> list;
+ typedef typename SkipList<T>::Iterator list_it;
+ typedef typename SkipList<T>::ConstIterator list_it_con;
public:
- list_it insert(const T &item) { return accessor.insert_non_unique(item); }
+ ConcurrentMultiSet() {}
- list_it insert(T &&item)
+ class Accessor : public AccessorBase<T>
{
- return accessor.insert_non_unique(std::forward<T>(item));
- }
+ friend class ConcurrentMultiSet;
- list_it_con find(const T &item) const { return accessor.find(item); }
+ using AccessorBase<T>::AccessorBase;
- list_it find(const T &item) { return accessor.find(item); }
+ private:
+ using AccessorBase<T>::accessor;
- bool contains(const T &item) const
- {
- return this->find(item) != this->end();
- }
+ public:
+ list_it insert(const T &item)
+ {
+ return accessor.insert_non_unique(item);
+ }
- bool remove(const T &item) { return accessor.remove(item); }
- };
+ list_it insert(T &&item)
+ {
+ return accessor.insert_non_unique(std::forward<T>(item));
+ }
- Accessor access() { return Accessor(&skiplist); }
+ list_it_con find(const T &item) const { return accessor.find(item); }
- const Accessor access() const { return Accessor(&skiplist); }
+ list_it find(const T &item) { return accessor.find(item); }
- private:
- list skiplist;
+ list_it_con find_or_larger(const T &item) const
+ {
+ return accessor.find_or_larger(item);
+ }
+
+ list_it find_or_larger(const T &item)
+ {
+ return accessor.find_or_larger(item);
+ }
+
+ bool contains(const T &item) const
+ {
+ return this->find(item) != this->end();
+ }
+
+ bool remove(const T &item) { return accessor.remove(item); }
+ };
+
+ Accessor access() { return Accessor(&skiplist); }
+
+ const Accessor access() const { return Accessor(&skiplist); }
+
+private:
+ list skiplist;
};
diff --git a/include/data_structures/concurrent/concurrent_set.hpp b/include/data_structures/concurrent/concurrent_set.hpp
index 036463ad2..e0d749bee 100644
--- a/include/data_structures/concurrent/concurrent_set.hpp
+++ b/include/data_structures/concurrent/concurrent_set.hpp
@@ -37,6 +37,24 @@ public:
list_it find(const T &item) { return accessor.find(item); }
+ template <class K>
+ list_it_con find_or_larger(const K &item) const
+ {
+ return accessor.find_or_larger(item);
+ }
+
+ template <class K>
+ list_it find_or_larger(const K &item)
+ {
+ return accessor.find_or_larger(item);
+ }
+
+ template <class K>
+ list_it_con cfind_or_larger(const K &item)
+ {
+ return accessor.template find_or_larger<list_it_con, K>(item);
+ }
+
bool contains(const T &item) const
{
return this->find(item) != this->end();
diff --git a/include/data_structures/concurrent/skiplist.hpp b/include/data_structures/concurrent/skiplist.hpp
index bb7834a60..227c6559e 100644
--- a/include/data_structures/concurrent/skiplist.hpp
+++ b/include/data_structures/concurrent/skiplist.hpp
@@ -556,6 +556,19 @@ public:
return skiplist->find(item);
}
+ template <class K>
+ ConstIterator find_or_larger(const K &item) const
+ {
+ return static_cast<const SkipList &>(*skiplist).find_or_larger(
+ item);
+ }
+
+ template <class It, class K>
+ It find_or_larger(const K &item)
+ {
+ return skiplist->find_or_larger<It, K>(item);
+ }
+
template <class K>
bool contains(const K &item) const
{
@@ -637,6 +650,18 @@ private:
template <class It, class K>
It find_node(const K &item)
+ {
+ auto it = find_or_larger<It, K>(item);
+ if (it.node == nullptr || item == *it) {
+ return std::move(it);
+ } else {
+ return It();
+ }
+ }
+
+ // Returns iterator on searched element or the first larger element.
+ template <class It, class K>
+ It find_or_larger(const K &item)
{
Node *node, *pred = header;
int h = static_cast<int>(pred->height) - 1;
@@ -647,7 +672,7 @@ private:
}
// if we overshoot at every layer, item doesn't exist
- if (h < 0) return It();
+ if (h < 0) return It(node);
// the item is farther to the right, continue going right as long
// as the key is greater than the current node's key
diff --git a/include/database/db.hpp b/include/database/db.hpp
index 028ed518e..f28a1189d 100644
--- a/include/database/db.hpp
+++ b/include/database/db.hpp
@@ -1,5 +1,9 @@
#pragma once
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+
+#include "storage/garbage/garbage.hpp"
#include "storage/graph.hpp"
#include "transactions/engine.hpp"
@@ -14,9 +18,24 @@ public:
Graph graph;
tx::Engine tx_engine;
+ Garbage garbage;
std::string &name();
+ // INDEXES
+
+ // TG - type group
+ // I - type of function I:const tx::Transaction& ->
+ // std::unique_ptr<IndexBase<TypeGroupVertex,std::nullptr_t>>
+ // G - type of collection (verrtex/edge)
+ template <class TG, class I, class G>
+ bool create_index_on_vertex_property_family(const char *name, G &coll,
+ I &create_index);
+
+ // Removes index IndexHolder. True if there was index to remove.
+ template <class TG, class K>
+ bool remove_index(IndexHolder<TG, K> &ih);
+
private:
std::string name_;
};
diff --git a/include/database/db_accessor.hpp b/include/database/db_accessor.hpp
index 6f6bb9fb6..3f9e8fa75 100644
--- a/include/database/db_accessor.hpp
+++ b/include/database/db_accessor.hpp
@@ -1,9 +1,8 @@
#pragma once
#include "database/db_transaction.hpp"
-#include "storage/vertex_accessor.hpp"
+#include "storage/model/properties/property_family.hpp"
#include "utils/border.hpp"
-// #include "utils/iterator/iterator.hpp"
#include "utils/option.hpp"
namespace tx
@@ -11,23 +10,29 @@ namespace tx
class Transaction;
}
+class Label;
+class EdgeType;
+
+using EdgePropertyFamily = PropertyFamily<TypeGroupEdge>;
+using VertexPropertyFamily = PropertyFamily<TypeGroupVertex>;
+
/*
* DbAccessor
* -Guarantees that access to Vertex and Edge is possible only through
-* Vertex::Accessor and Edge::Accessor.
+* VertexAccessor and EdgeAccessor.
* -Guarantees that changing Vertex and Edge is possible only using
-* Vertex::Accessor returned by vertex_insert() method and
-* Edge::Accessor returned by edge_insert() method.
+* VertexAccessor returned by vertex_insert() method and
+* EdgeAccessor returned by edge_insert() method.
* -Offers CRUD for Vertex and Edge except iterating over all edges.
*
-* Vertex::Accessor
+* VertexAccessor
* By default Vertex::accessor is empty. Caller has to call fill() method
* to fetch valid data and check it's return value. fill() method returns
* true if there is valid data for current transaction false otherwise.
* Only exception to this rule is vertex_insert() method in DbAccessor
-* which returns by default filled Vertex::Accessor.
+* which returns by default filled VertexAccessor.
*
-* Edge::Accessor
+* EdgeAccessor
* By default Edge::accessor is empty. Caller has to call fill() method
* to
* fetch valid data and check it's return value. fill() method returns
@@ -35,7 +40,7 @@ class Transaction;
* if there is valid data for current transaction false otherwise.
* Only exception to this rule is edge_insert() method in DbAccessor
* which
-* returns by default filled Edge::Accessor.
+* returns by default filled EdgeAccessor.
*/
class DbAccessor
{
@@ -43,22 +48,24 @@ class DbAccessor
public:
DbAccessor(Db &db);
+ DbAccessor(Db &db, tx::Transaction &t);
+
//*******************VERTEX METHODS
auto vertex_access();
- Option<const Vertex::Accessor> vertex_find(const Id &id);
+ Option<const VertexAccessor> vertex_find(const Id &id);
- // Creates new Vertex and returns filled Vertex::Accessor.
- Vertex::Accessor vertex_insert();
+ // Creates new Vertex and returns filled VertexAccessor.
+ VertexAccessor vertex_insert();
// ******************* EDGE METHODS
- Option<const Edge::Accessor> edge_find(const Id &id);
+ Option<const EdgeAccessor> edge_find(const Id &id);
- // Creates new Edge and returns filled Edge::Accessor.
- Edge::Accessor edge_insert(Vertex::Accessor const &from,
- Vertex::Accessor const &to);
+ // Creates new Edge and returns filled EdgeAccessor.
+ EdgeAccessor edge_insert(VertexAccessor const &from,
+ VertexAccessor const &to);
// ******************* LABEL METHODS
@@ -74,25 +81,37 @@ public:
// ******************** PROPERTY METHODS
- PropertyFamily &vertex_property_family_get(const std::string &name);
+ VertexPropertyFamily &vertex_property_family_get(const std::string &name);
- PropertyFamily &edge_property_family_get(const std::string &name);
+ EdgePropertyFamily &edge_property_family_get(const std::string &name);
// ******************** PROPERTY HELPER METHODS
- PropertyFamily::PropertyType::PropertyFamilyKey
+ VertexPropertyFamily::PropertyType::PropertyFamilyKey
vertex_property_key(const std::string &name, Type type);
- PropertyFamily::PropertyType::PropertyFamilyKey
+ EdgePropertyFamily::PropertyType::PropertyFamilyKey
edge_property_key(const std::string &name, Type type);
+ template <class T>
+ VertexPropertyFamily::PropertyType::PropertyTypeKey<T>
+ vertex_property_key(const std::string &name);
+
+ template <class T>
+ EdgePropertyFamily::PropertyType::PropertyTypeKey<T>
+ edge_property_key(const std::string &name);
+
// ******************** TRANSACTION METHODS
- void commit();
+ // True if commit was successful, or false if transaction was aborted.
+ bool commit();
void abort();
private:
+ // TODO: make this friend generic for all indexes.
template <class T, class K>
friend class NonUniqueUnorderedIndex;
+ template <class T, class K>
+ friend class UniqueOrderedIndex;
DbTransaction db_transaction;
};
diff --git a/include/database/db_transaction.hpp b/include/database/db_transaction.hpp
index a36dd1d18..07972557e 100644
--- a/include/database/db_transaction.hpp
+++ b/include/database/db_transaction.hpp
@@ -1,10 +1,13 @@
#pragma once
+#include "storage/indexes/index_update.hpp"
#include "transactions/transaction.hpp"
class Db;
class DbAccessor;
+using index_updates_t = std::vector<IndexUpdate>;
+
// Inner structures local to transaction can hold ref to this structure and use
// its methods.
// Also serves as a barrier for calling methods defined public but meant for
@@ -21,6 +24,21 @@ public:
// This should provide cleaner hierarchy of operations on database.
// For example cleaner.
+ // Updates indexes of Vertex/Edges in index_updates. True if indexes are
+ // updated successfully. False means that transaction failed.
+ bool update_indexes();
+
+ // Will update indexes for given element TG::record_t. Actual update happens
+ // with call update_indexes
+ template <class TG>
+ void to_update_index(typename TG::vlist_t *vlist,
+ typename TG::record_t *record)
+ {
+ index_updates.push_back(make_index_update(vlist, record));
+ }
+
+ index_updates_t index_updates;
+
tx::Transaction &trans;
Db &db;
diff --git a/include/mvcc/record.hpp b/include/mvcc/record.hpp
index 2731c2b56..bc2e0ece2 100644
--- a/include/mvcc/record.hpp
+++ b/include/mvcc/record.hpp
@@ -3,14 +3,14 @@
#include <atomic>
#include <iostream>
-#include "transactions/transaction.hpp"
#include "transactions/commit_log.hpp"
#include "transactions/engine.hpp"
+#include "transactions/transaction.hpp"
-#include "mvcc/id.hpp"
#include "mvcc/cre_exp.hpp"
-#include "mvcc/version.hpp"
#include "mvcc/hints.hpp"
+#include "mvcc/id.hpp"
+#include "mvcc/version.hpp"
#include "storage/locking/record_lock.hpp"
// the mvcc implementation used here is very much like postgresql's
@@ -41,7 +41,7 @@ public:
RecordLock lock;
// check if this record is visible to the transaction t
- bool visible(const tx::Transaction& t)
+ bool visible(const tx::Transaction &t)
{
// TODO check if the record was created by a transaction that has been
// aborted. one might implement this by checking the hints in mvcc
@@ -51,87 +51,95 @@ public:
// if you think they're not, you're wrong, and you should think about it
// again. i know, it happened to me.
- return ((tx.cre() == t.id && // inserted by the current transaction
- cmd.cre() <= t.cid && // before this command, and
- (tx.exp() == Id(0) || // the row has not been deleted, or
- (tx.exp() == t.id && // it was deleted by the current
- // transaction
- cmd.exp() >= t.cid))) // but not before this command,
- || // or
- (cre_committed(tx.cre(), t) && // the record was inserted by a
- // committed transaction, and
- (tx.exp() == Id(0) || // the record has not been deleted, or
- (tx.exp() == t.id && // the row is being deleted by this
- // transaction
- cmd.exp() >= t.cid) || // but it's not deleted "yet", or
- (tx.exp() != t.id && // the row was deleted by another
- // transaction
- !exp_committed(tx.exp(), t) // that has not been committed
- ))));
+ return ((tx.cre() == t.id && // inserted by the current transaction
+ cmd.cre() <= t.cid && // before this command, and
+ (tx.exp() == Id(0) || // the row has not been deleted, or
+ (tx.exp() == t.id && // it was deleted by the current
+ // transaction
+ cmd.exp() >= t.cid))) // but not before this command,
+ || // or
+ (cre_committed(tx.cre(), t) && // the record was inserted by a
+ // committed transaction, and
+ (tx.exp() == Id(0) || // the record has not been deleted, or
+ (tx.exp() == t.id && // the row is being deleted by this
+ // transaction
+ cmd.exp() >= t.cid) || // but it's not deleted "yet", or
+ (tx.exp() != t.id && // the row was deleted by another
+ // transaction
+ !exp_committed(tx.exp(), t) // that has not been committed
+ ))));
}
- void mark_created(const tx::Transaction& t)
+ void mark_created(const tx::Transaction &t)
{
tx.cre(t.id);
cmd.cre(t.cid);
}
- void mark_deleted(const tx::Transaction& t)
+ void mark_deleted(const tx::Transaction &t)
{
tx.exp(t.id);
cmd.exp(t.cid);
}
- bool exp_committed(const Id& id, const tx::Transaction& t)
+ bool exp_committed(const Id &id, const tx::Transaction &t)
{
return committed(hints.exp, id, t);
}
- bool exp_committed(const tx::Transaction& t)
+ bool exp_committed(const tx::Transaction &t)
{
return committed(hints.exp, tx.exp(), t);
}
- bool cre_committed(const Id& id, const tx::Transaction& t)
+ bool cre_committed(const Id &id, const tx::Transaction &t)
{
return committed(hints.cre, id, t);
}
- bool cre_committed(const tx::Transaction& t)
+ bool cre_committed(const tx::Transaction &t)
{
return committed(hints.cre, tx.cre(), t);
}
+ // TODO: Test this
+ // True if this record is visible for write.
+ bool is_visible_write(const tx::Transaction &t)
+ {
+ return (tx.cre() == t.id && // inserted by the current transaction
+ cmd.cre() <= t.cid && // before this command, and
+ (tx.exp() == Id(0) || // the row has not been deleted, or
+ (tx.exp() == t.id && // it was deleted by the current
+ // transaction
+ cmd.exp() >= t.cid))); // but not before this command,
+ }
+
protected:
template <class U>
- bool committed(U& hints, const Id& id, const tx::Transaction& t)
+ bool committed(U &hints, const Id &id, const tx::Transaction &t)
{
// you certainly can't see the transaction with id greater than yours
// as that means it started after this transaction and if it committed,
// it committed after this transaction had started.
- if(id > t.id)
- return false;
+ if (id > t.id) return false;
+
+ // The creating transaction is still in progress (examine snapshot)
+ if (t.is_active(id)) return false;
auto hint_bits = hints.load();
+ // TODO: Validate if this position is valid for next if.
// if hints are set, return if xid is committed
- if(!hint_bits.is_unknown())
- return hint_bits.is_committed();
+ if (!hint_bits.is_unknown()) return hint_bits.is_committed();
// if hints are not set:
- // - the creating transaction is still in progress (examine snapshot)
- if(t.snapshot.is_active(id))
- return false;
-
// - you are the first one to check since it ended, consult commit log
auto info = t.engine.clog.fetch_info(id);
- if(info.is_committed())
- return hints.set_committed(), true;
+ if (info.is_committed()) return hints.set_committed(), true;
assert(info.is_aborted());
return hints.set_aborted(), false;
}
};
-
}
diff --git a/include/mvcc/version_list.hpp b/include/mvcc/version_list.hpp
index e6126201f..29161fe27 100644
--- a/include/mvcc/version_list.hpp
+++ b/include/mvcc/version_list.hpp
@@ -103,13 +103,6 @@ public:
T *update(T *record, tx::Transaction &t)
{
assert(record != nullptr);
- // TODO: VALIDATE NEXT IF BLOCK
- if (record->tx.cre() == t.id) {
- // THEN ONLY THIS TRANSACTION CAN SEE THIS DATA WHICH MENS THAT IT
- // CAN CHANGE IT.
- return record;
- }
-
lock_and_validate(record, t);
auto updated = new T();
@@ -149,7 +142,6 @@ private:
void lock_and_validate(T *record, tx::Transaction &t)
{
assert(record != nullptr);
- assert(record == find(t));
// take a lock on this node
t.take_lock(lock);
@@ -167,9 +159,3 @@ private:
RecordLock lock;
};
}
-
-class Vertex;
-class Edge;
-
-using VertexRecord = mvcc::VersionList<Vertex>;
-// using EdgeRecord = mvcc::VersionList<Edge>;
diff --git a/include/query_engine/hardcode/queries.hpp b/include/query_engine/hardcode/queries.hpp
index 8513b82de..bab402ce0 100644
--- a/include/query_engine/hardcode/queries.hpp
+++ b/include/query_engine/hardcode/queries.hpp
@@ -6,10 +6,12 @@
#include "query_engine/query_stripper.hpp"
#include "query_engine/util.hpp"
#include "storage/indexes/impl/nonunique_unordered_index.cpp"
+// #include "storage/model/properties/properties.cpp"
#include "storage/model/properties/property.hpp"
#include "storage/model/properties/property_family.hpp"
#include "utils/command_line/arguments.hpp"
#include "utils/iterator/iterator.hpp"
+// #include "utils/utils.cpp"
auto load_queries(Db &db)
{
diff --git a/include/query_engine/query_result.hpp b/include/query_engine/query_result.hpp
index 992df23c0..6ed096daf 100644
--- a/include/query_engine/query_result.hpp
+++ b/include/query_engine/query_result.hpp
@@ -10,10 +10,11 @@
#include "storage/model/properties/properties.hpp"
+template <class TG>
struct ResultList
{
using sptr = std::shared_ptr<ResultList>;
- using data_t = std::vector<const Properties *>;
+ using data_t = std::vector<const Properties<TG> *>;
ResultList() = default;
ResultList(ResultList &other) = delete;
@@ -22,13 +23,15 @@ struct ResultList
explicit operator bool() const { return data.size() > 0; }
- std::vector<const Properties *> data;
+ std::vector<const Properties<TG> *> data;
};
+template <class TG>
struct QueryResult
{
using sptr = std::shared_ptr<QueryResult>;
- using data_t = std::unordered_map<std::string, ResultList::sptr>;
+ using data_t =
+ std::unordered_map<std::string, typename ResultList<TG>::sptr>;
QueryResult() = default;
QueryResult(QueryResult &other) = delete;
diff --git a/include/query_engine/util.hpp b/include/query_engine/util.hpp
index 40b5b5a57..0d853b258 100644
--- a/include/query_engine/util.hpp
+++ b/include/query_engine/util.hpp
@@ -11,7 +11,8 @@
using std::cout;
using std::endl;
-void print_props(const Properties &properties);
+template <class T>
+void print_props(const Properties<T> &properties);
#ifdef NDEBUG
#define PRINT_PROPS(_)
@@ -19,7 +20,8 @@ void print_props(const Properties &properties);
#define PRINT_PROPS(_PROPS_) print_props(_PROPS_);
#endif
-void cout_properties(const Properties &properties);
+template <class T>
+void cout_properties(const Properties<T> &properties);
void cout_property(const std::string &key, const Property &property);
diff --git a/include/storage/edge.hpp b/include/storage/edge.hpp
index 55a3ea182..4e87c4d7d 100644
--- a/include/storage/edge.hpp
+++ b/include/storage/edge.hpp
@@ -2,7 +2,7 @@
#include "mvcc/record.hpp"
#include "storage/model/edge_model.hpp"
-#include "storage/model/properties/traversers/jsonwriter.hpp"
+// #include "storage/model/properties/traversers/jsonwriter.hpp"
class Edge : public mvcc::Record<Edge>
{
@@ -10,14 +10,14 @@ public:
class Accessor;
Edge() = default;
- Edge(const EdgeModel& data) : data(data) {}
- Edge(EdgeModel&& data) : data(std::move(data)) {}
+ Edge(const EdgeModel &data) : data(data) {}
+ Edge(EdgeModel &&data) : data(std::move(data)) {}
- Edge(const Edge&) = delete;
- Edge(Edge&&) = delete;
+ Edge(const Edge &) = delete;
+ Edge(Edge &&) = delete;
- Edge& operator=(const Edge&) = delete;
- Edge& operator=(Edge&&) = delete;
+ Edge &operator=(const Edge &) = delete;
+ Edge &operator=(Edge &&) = delete;
EdgeModel data;
};
diff --git a/include/storage/edge_accessor.hpp b/include/storage/edge_accessor.hpp
index f62328eae..72a4323d0 100644
--- a/include/storage/edge_accessor.hpp
+++ b/include/storage/edge_accessor.hpp
@@ -7,18 +7,23 @@
#include "utils/assert.hpp"
#include "utils/reference_wrapper.hpp"
+class EdgeType;
+using edge_type_ref_t = ReferenceWrapper<const EdgeType>;
+
class Edges;
-class Edge::Accessor : public RecordAccessor<Edge, Edge::Accessor, EdgeRecord>
+class EdgeAccessor : public RecordAccessor<TypeGroupEdge, EdgeAccessor>
{
public:
using RecordAccessor::RecordAccessor;
+ typedef Edge record_t;
+ typedef EdgeRecord record_list_t;
void edge_type(edge_type_ref_t edge_type);
edge_type_ref_t edge_type() const;
- Vertex::Accessor from() const;
+ VertexAccessor from() const;
- Vertex::Accessor to() const;
+ VertexAccessor to() const;
};
diff --git a/include/storage/edge_record.hpp b/include/storage/edge_record.hpp
index aa1471abe..50ce0a42d 100644
--- a/include/storage/edge_record.hpp
+++ b/include/storage/edge_record.hpp
@@ -3,6 +3,8 @@
#include "mvcc/version_list.hpp"
#include "storage/edge.hpp"
+class VertexRecord;
+
class EdgeRecord : public mvcc::VersionList<Edge>
{
public:
diff --git a/include/storage/edge_type/edge_type.hpp b/include/storage/edge_type/edge_type.hpp
index 2dd64262c..94367aea1 100644
--- a/include/storage/edge_type/edge_type.hpp
+++ b/include/storage/edge_type/edge_type.hpp
@@ -3,18 +3,30 @@
#include <ostream>
#include <stdint.h>
+#include "storage/edge.hpp"
+#include "storage/edge_accessor.hpp"
+#include "storage/indexes/impl/nonunique_unordered_index.hpp"
+#include "storage/type_group_edge.hpp"
#include "utils/char_str.hpp"
#include "utils/reference_wrapper.hpp"
#include "utils/total_ordering.hpp"
+using EdgeTypeIndexRecord = IndexRecord<TypeGroupEdge, std::nullptr_t>;
+
class EdgeType : public TotalOrdering<EdgeType>
{
public:
- EdgeType();
+ using type_index_t = NonUniqueUnorderedIndex<TypeGroupEdge, std::nullptr_t>;
+
+ EdgeType() = delete;
+
EdgeType(const std::string &id);
EdgeType(const char *id);
EdgeType(std::string &&id);
+ EdgeType(const EdgeType &) = delete;
+ EdgeType(EdgeType &&other) = default;
+
friend bool operator<(const EdgeType &lhs, const EdgeType &rhs);
friend bool operator==(const EdgeType &lhs, const EdgeType &rhs);
@@ -25,6 +37,8 @@ public:
CharStr char_str() { return CharStr(&id[0]); }
+ std::unique_ptr<type_index_t> index;
+
private:
std::string id;
};
diff --git a/include/storage/edges.hpp b/include/storage/edges.hpp
index 080d39836..664f6d545 100644
--- a/include/storage/edges.hpp
+++ b/include/storage/edges.hpp
@@ -1,25 +1,30 @@
#pragma once
#include <string>
+
#include "data_structures/concurrent/concurrent_map.hpp"
-#include "mvcc/version_list.hpp"
-#include "storage/common.hpp"
-#include "storage/edge_accessor.hpp"
-#include "storage/model/properties/property_family.hpp"
+#include "utils/counters/atomic_counter.hpp"
#include "utils/option.hpp"
+#include "storage/edge_record.hpp"
+#include "storage/model/properties/property_family.hpp"
+
+class EdgeAccessor;
+class DbTransaction;
+
+using EdgePropertyFamily = PropertyFamily<TypeGroupEdge>;
+
class Edges
{
- using prop_familys_t = ConcurrentMap<std::string, PropertyFamily *>;
+ using prop_familys_t = ConcurrentMap<std::string, EdgePropertyFamily *>;
public:
- Option<const Edge::Accessor> find(DbTransaction &t, const Id &id);
+ Option<const EdgeAccessor> find(DbTransaction &t, const Id &id);
- // Creates new Edge and returns filled Edge::Accessor.
- Edge::Accessor insert(DbTransaction &t, VertexRecord *from,
- VertexRecord *to);
+ // Creates new Edge and returns filled EdgeAccessor.
+ EdgeAccessor insert(DbTransaction &t, VertexRecord *from, VertexRecord *to);
- PropertyFamily &property_family_find_or_create(const std::string &name);
+ EdgePropertyFamily &property_family_find_or_create(const std::string &name);
private:
ConcurrentMap<uint64_t, EdgeRecord> edges;
diff --git a/include/storage/garbage/delete_sensitive.hpp b/include/storage/garbage/delete_sensitive.hpp
new file mode 100644
index 000000000..973bde9d2
--- /dev/null
+++ b/include/storage/garbage/delete_sensitive.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+// Base class for all classes which need to be safely disposed. Main usage is
+// for garbage class operations.
+class DeleteSensitive
+{
+public:
+ virtual ~DeleteSensitive() {}
+};
diff --git a/include/storage/garbage/garbage.hpp b/include/storage/garbage/garbage.hpp
new file mode 100644
index 000000000..4712fe780
--- /dev/null
+++ b/include/storage/garbage/garbage.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "data_structures/concurrent/concurrent_list.hpp"
+#include "mvcc/id.hpp"
+#include "storage/garbage/delete_sensitive.hpp"
+#include "transactions/snapshot.hpp"
+
+namespace tx
+{
+class Engine;
+}
+
+// Collection of delete sensitive data which need to be safely deleted. That
+// meens that all transactions that may have pointer to it must finish before
+// the sensitive data can be safely destroyed.
+class Garbage
+{
+public:
+ void dispose(tx::Snapshot<Id> &&snapshot, DeleteSensitive *data);
+
+ // Cleaner thread shoul call this method every some time. Removes data which
+ // is
+ // safe to be deleted.
+ void clean(tx::Engine &engine);
+
+private:
+ List<std::pair<tx::Snapshot<Id>, DeleteSensitive *>> gar;
+};
diff --git a/include/storage/indexes/impl/nonunique_unordered_index.hpp b/include/storage/indexes/impl/nonunique_unordered_index.hpp
index 01bebb1c5..77c76fc75 100644
--- a/include/storage/indexes/impl/nonunique_unordered_index.hpp
+++ b/include/storage/indexes/impl/nonunique_unordered_index.hpp
@@ -1,26 +1,29 @@
#pragma once
#include "storage/indexes/index_base.hpp"
-#include "storage/indexes/index_record.hpp"
+// #include "storage/indexes/index_record.hpp"
#include "data_structures/concurrent/concurrent_list.hpp"
-template <class T, class K>
-class NonUniqueUnorderedIndex : public IndexBase<T, K>
+template <class TG, class K>
+class NonUniqueUnorderedIndex : public IndexBase<TG, K>
{
public:
- typedef T value_type;
- typedef K key_type;
+ // typedef T value_type;
+ // typedef K key_type;
+ // Created with the database
NonUniqueUnorderedIndex();
+ NonUniqueUnorderedIndex(tx::Transaction const &t);
+
// Insert's value.
// nonunique => always succeds.
- bool insert(IndexRecord<T, K> &&value) final;
+ bool insert(IndexRecord<TG, K> &&value) final;
// Returns iterator which returns valid records in range.
// ordered==None => doesn't guarantee any order of submitting records.
- std::unique_ptr<IteratorBase<const typename T::Accessor>>
+ std::unique_ptr<IteratorBase<const typename TG::accessor_t>>
for_range(DbAccessor &t, Border<K> from = Border<K>(),
Border<K> to = Border<K>()) final;
@@ -34,5 +37,5 @@ public:
void clean(DbTransaction &) final;
private:
- List<IndexRecord<T, K>> list;
+ List<IndexRecord<TG, K>> list;
};
diff --git a/include/storage/indexes/impl/unique_ordered_index.hpp b/include/storage/indexes/impl/unique_ordered_index.hpp
new file mode 100644
index 000000000..69daeecf7
--- /dev/null
+++ b/include/storage/indexes/impl/unique_ordered_index.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "storage/indexes/index_base.hpp"
+
+#include "data_structures/concurrent/concurrent_set.hpp"
+
+template <class T, class K>
+class UniqueOrderedIndex : public IndexBase<T, K>
+{
+public:
+ // typedef T value_type;
+ // typedef K key_type;
+
+ // Created with the database
+ UniqueOrderedIndex(Order order);
+
+ UniqueOrderedIndex(Order order, tx::Transaction const &t);
+
+ // Insert's value.
+ // nonunique => always succeds.
+ bool insert(IndexRecord<T, K> &&value) final;
+
+ // Returns iterator which returns valid records in range.
+ // ordered==None => doesn't guarantee any order of submitting records.
+ std::unique_ptr<IteratorBase<const typename T::accessor_t>>
+ for_range(DbAccessor &t, Border<K> from = Border<K>(),
+ Border<K> to = Border<K>()) final;
+
+ // Same as for_range just whith known returned iterator.
+ auto for_range_exact(DbAccessor &t, Border<K> from = Border<K>(),
+ Border<K> to = Border<K>());
+
+ // Removes for all transactions obsolete Records.
+ // Cleaner has to call this method when he decideds that it is time for
+ // cleaning.
+ void clean(DbTransaction &) final;
+
+private:
+ ConcurrentSet<IndexRecord<T, K>> set;
+};
diff --git a/include/storage/indexes/index_base.hpp b/include/storage/indexes/index_base.hpp
index dd5e01529..06c00046f 100644
--- a/include/storage/indexes/index_base.hpp
+++ b/include/storage/indexes/index_base.hpp
@@ -1,41 +1,45 @@
#pragma once
-// #include "storage/indexes/index_record.hpp"
+#include <atomic>
#include <functional>
#include <memory>
+#include "mvcc/id.hpp"
+
+// #include "storage/indexes/index_record.hpp"
+#include "storage/garbage/delete_sensitive.hpp"
#include "utils/border.hpp"
#include "utils/iterator/iterator_base.hpp"
+#include "utils/order.hpp"
+
+template <class TG, class K>
+class IndexRecord;
class DbTransaction;
class DbAccessor;
-
-template <class T, class K>
-class IndexRecord;
-
-// Defines ordering of data
-enum Order
+namespace tx
{
- None = 0,
- Ascending = 1,
- Descending = 2,
-};
+class Transaction;
+}
// Interface for all indexes.
-// T type of record.
+// TG type group
// K type of key on which records are ordered
-template <class T, class K>
-class IndexBase
+template <class TG, class K>
+class IndexBase : public DeleteSensitive
{
public:
- typedef T value_type;
- typedef K key_type;
+ // typedef T value_type;
+ // typedef K key_type;
- IndexBase(bool unique, Order order) : unique(unique), order(order) {}
+ // Created with the database
+ IndexBase(bool unique, Order order);
+
+ IndexBase(bool unique, Order order, const tx::Transaction &t);
// Insert's value.
// unique => returns false if there is already valid equal value.
// nonunique => always succeds.
- virtual bool insert(IndexRecord<T, K> &&value) = 0;
+ virtual bool insert(IndexRecord<TG, K> &&value) = 0;
// Returns iterator which returns valid filled records in range.
// order==noe => doesn't guarantee any order of returned records.
@@ -44,7 +48,7 @@ public:
// order==Descending => guarantees order of returned records will be from
// largest to smallest.
// Range must be from<=to
- virtual std::unique_ptr<IteratorBase<const typename T::Accessor>>
+ virtual std::unique_ptr<IteratorBase<const typename TG::accessor_t>>
for_range(DbAccessor &, Border<K> from = Border<K>(),
Border<K> to = Border<K>()) = 0;
@@ -53,8 +57,23 @@ public:
// cleaning.
virtual void clean(DbTransaction &) = 0;
+ // Activates index for readers.
+ void activate();
+
+ // True if index is ready for reading.
+ bool can_read();
+
+ // True if transaction is obliged to insert T into index.
+ bool is_obliged_to_insert(const tx::Transaction &t);
+
// Are the records unique
const bool unique;
// Ordering of the records.
const Order order;
+
+private:
+ // Id of transaction which created this index.
+ const Id created;
+ // Active state
+ std::atomic_bool active = {false};
};
diff --git a/include/storage/indexes/index_holder.hpp b/include/storage/indexes/index_holder.hpp
new file mode 100644
index 000000000..e8dac0386
--- /dev/null
+++ b/include/storage/indexes/index_holder.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <atomic>
+
+#include "storage/indexes/index_base.hpp"
+#include "utils/option.hpp"
+#include "utils/option_ptr.hpp"
+
+namespace tx
+{
+class Transaction;
+}
+
+// Holds onde index which can be changed.
+// TG - type group
+// K - key of index_records
+template <class TG, class K>
+class IndexHolder
+{
+
+public:
+ IndexHolder() = default;
+
+ IndexHolder(IndexHolder const &) = delete;
+
+ IndexHolder(IndexHolder &&) = default;
+
+ // Sets index for this property family. Treturns false if index is already
+ // present.
+ bool set_index(std::unique_ptr<IndexBase<TG, K>> inx);
+
+ // Returns index for read only if it is present and it's valid for read.
+ OptionPtr<IndexBase<TG, K>> get_read() const;
+
+ // Returns index for write only if it's present and transaction is
+ // responsibly for updating it.
+ OptionPtr<IndexBase<TG, K>> get_write(const tx::Transaction &t) const;
+
+ // Removes index if it is given index. Caller is now responsable of
+ // disposing index in a safe way.
+ Option<std::unique_ptr<IndexBase<TG, K>>>
+ remove_index(IndexBase<TG, K> *index);
+
+ // Caller is now responsable of disposing index in a safe way.
+ Option<std::unique_ptr<IndexBase<TG, K>>> remove_index();
+
+private:
+ std::atomic<IndexBase<TG, K> *> index = {nullptr};
+};
diff --git a/include/storage/indexes/index_record.hpp b/include/storage/indexes/index_record.hpp
index 70f05af71..8381f8292 100644
--- a/include/storage/indexes/index_record.hpp
+++ b/include/storage/indexes/index_record.hpp
@@ -1,37 +1,32 @@
#pragma once
-#include "database/db_transaction.hpp"
-#include "mvcc/version_list.hpp"
+#include "utils/border.hpp"
#include "utils/total_ordering.hpp"
-// class DbTransaction;
-// namespace tx
-// {
-// class Transaction;
-// }
+namespace tx
+{
+class Transaction;
+}
+class DbTransaction;
-// T type of record.
+// TG type group
// K key on which record is ordered.
-template <class T, class K>
-class IndexRecord : public TotalOrdering<IndexRecord<T, K>>
+template <class TG, class K>
+class IndexRecord : public TotalOrdering<IndexRecord<TG, K>>,
+ public TotalOrdering<Border<K>, IndexRecord<TG, K>>
{
public:
- using vlist_t = mvcc::VersionList<T>;
-
IndexRecord() = default;
- IndexRecord(K key, T *record, vlist_t *vlist)
- : key(std::move(key)), record(record), vlist(vlist)
- {
- assert(record != nullptr);
- assert(vlist != nullptr);
- }
+ IndexRecord(K key, typename TG::record_t *record,
+ typename TG::vlist_t *vlist);
friend bool operator<(const IndexRecord &lhs, const IndexRecord &rhs)
{
- return lhs.key < rhs.key ||
- (lhs.key == rhs.key && lhs.vlist == rhs.vlist &&
- lhs.record < rhs.record);
+ return (lhs.key < rhs.key ||
+ (lhs.key == rhs.key && lhs.vlist == rhs.vlist &&
+ lhs.record < rhs.record)) ^
+ lhs.descending;
}
friend bool operator==(const IndexRecord &lhs, const IndexRecord &rhs)
@@ -40,28 +35,29 @@ public:
(lhs.vlist != rhs.vlist || lhs.record == rhs.record);
}
- bool empty() const { return record == nullptr; }
-
- bool is_valid(tx::Transaction &t) const
+ friend bool operator<(const Border<K> &lhs, const IndexRecord &rhs)
{
- assert(!empty());
- return record == vlist->find(t);
+ return lhs < rhs.key;
}
- const auto access(DbTransaction &db) const
+ friend bool operator==(const Border<K> &lhs, const IndexRecord &rhs)
{
- return T::Accessor::create(record, vlist, db);
+ return lhs == rhs.key;
}
+ // Will change ordering of record to descending.
+ void set_descending();
+
+ bool empty() const;
+
+ bool is_valid(tx::Transaction &t) const;
+
+ const auto access(DbTransaction &db) const;
+
const K key;
private:
- T *const record{nullptr};
- vlist_t *const vlist{nullptr};
+ bool descending = false;
+ typename TG::record_t *const record{nullptr};
+ typename TG::vlist_t *const vlist{nullptr};
};
-
-template <class K>
-using VertexIndexRecord = IndexRecord<Vertex, K>;
-
-template <class K>
-using EdgeIndexRecord = IndexRecord<Edge, K>;
diff --git a/include/storage/indexes/index_update.hpp b/include/storage/indexes/index_update.hpp
new file mode 100644
index 000000000..e19650960
--- /dev/null
+++ b/include/storage/indexes/index_update.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "storage/indexes/index_record.hpp"
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+
+struct IndexUpdateEdge
+{
+ EdgeRecord *vlist;
+ Edge *record;
+};
+
+struct IndexUpdateVertex
+{
+ VertexRecord *vlist;
+ Vertex *record;
+};
+
+struct IndexUpdate
+{
+ enum
+ {
+ EDGE,
+ VERTEX
+ } tag;
+
+ union
+ {
+ IndexUpdateEdge e;
+ IndexUpdateVertex v;
+ };
+};
+
+template <class T, class V>
+IndexUpdate make_index_update(V *vlist, T *record);
+
+template <>
+IndexUpdate make_index_update(EdgeRecord *vlist, Edge *record);
+
+template <>
+IndexUpdate make_index_update(VertexRecord *vlist, Vertex *record);
diff --git a/include/storage/label/label.hpp b/include/storage/label/label.hpp
index 441ff5ab2..12dc59f1b 100644
--- a/include/storage/label/label.hpp
+++ b/include/storage/label/label.hpp
@@ -9,13 +9,16 @@
#include "utils/char_str.hpp"
#include "utils/reference_wrapper.hpp"
#include "utils/total_ordering.hpp"
+// #include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
-using LabelIndexRecord = VertexIndexRecord<std::nullptr_t>;
+using LabelIndexRecord = IndexRecord<TypeGroupVertex, std::nullptr_t>;
class Label : public TotalOrdering<Label>, TotalOrdering<CharStr, Label>
{
public:
- using label_index_t = NonUniqueUnorderedIndex<Vertex, std::nullptr_t>;
+ using label_index_t =
+ NonUniqueUnorderedIndex<TypeGroupVertex, std::nullptr_t>;
Label() = delete;
@@ -36,10 +39,10 @@ public:
operator const std::string &() const;
- std::unique_ptr<label_index_t> index;
-
CharStr char_str() const { return CharStr(name.c_str()); }
+ std::unique_ptr<label_index_t> index;
+
private:
std::string name;
};
diff --git a/include/storage/model/edge_map.hpp b/include/storage/model/edge_map.hpp
index e8d109cc5..5460e3e18 100644
--- a/include/storage/model/edge_map.hpp
+++ b/include/storage/model/edge_map.hpp
@@ -1,7 +1,8 @@
#pragma once
#include "data_structures/map/rh_hashmultimap.hpp"
-#include "mvcc/version_list.hpp"
+#include "storage/edge_record.hpp"
+// #include "storage/vertex_record.hpp"
class EdgeMap
{
diff --git a/include/storage/model/edge_model.hpp b/include/storage/model/edge_model.hpp
index a00754934..2d3be107e 100644
--- a/include/storage/model/edge_model.hpp
+++ b/include/storage/model/edge_model.hpp
@@ -1,10 +1,13 @@
#pragma once
-#include "mvcc/version_list.hpp"
+// #include "mvcc/version_list.hpp"
+// #include "storage/edge_type/edge_type.hpp"
#include "storage/model/property_model.hpp"
-#include "storage/edge_type/edge_type.hpp"
+#include "storage/type_group_edge.hpp"
-class EdgeModel : public PropertyModel
+class EdgeType;
+
+class EdgeModel : public PropertyModel<TypeGroupEdge>
{
public:
// TODO: here should be the reference
diff --git a/include/storage/model/properties/properties.hpp b/include/storage/model/properties/properties.hpp
index 0d2554417..2e55fcbf6 100644
--- a/include/storage/model/properties/properties.hpp
+++ b/include/storage/model/properties/properties.hpp
@@ -6,16 +6,26 @@
#include "storage/model/properties/property_family.hpp"
#include "utils/option.hpp"
-using prop_key_t = PropertyFamily::PropertyType::PropertyFamilyKey;
+template <class TG>
+using prop_key_t = typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey;
-template <class T>
-using type_key_t = PropertyFamily::PropertyType::PropertyTypeKey<T>;
+template <class TG, class T>
+using type_key_t =
+ typename PropertyFamily<TG>::PropertyType::template PropertyTypeKey<T>;
+template <class TG>
class Properties
{
public:
using sptr = std::shared_ptr<Properties>;
+ using prop_key_t =
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey;
+
+ template <class T>
+ using type_key_t =
+ typename PropertyFamily<TG>::PropertyType::template PropertyTypeKey<T>;
+
auto begin() const { return props.begin(); }
auto cbegin() const { return props.cbegin(); }
@@ -24,7 +34,7 @@ public:
size_t size() const { return props.size(); }
- const Property &at(PropertyFamily &key) const;
+ const Property &at(PropertyFamily<TG> &key) const;
const Property &at(prop_key_t &key) const;
@@ -38,7 +48,7 @@ public:
void clear(prop_key_t &key);
- void clear(PropertyFamily &key);
+ void clear(PropertyFamily<TG> &key);
template <class Handler>
void accept(Handler &handler) const
@@ -58,6 +68,6 @@ public:
private:
using props_t =
- std::unordered_map<prop_key_t, Property::sptr, PropertyHash>;
+ std::unordered_map<prop_key_t, Property::sptr, PropertyHash<TG>>;
props_t props;
};
diff --git a/include/storage/model/properties/property_family.hpp b/include/storage/model/properties/property_family.hpp
index 653c78582..b71db0c7d 100644
--- a/include/storage/model/properties/property_family.hpp
+++ b/include/storage/model/properties/property_family.hpp
@@ -1,15 +1,21 @@
#pragma once
#include <memory>
+
#include "data_structures/concurrent/concurrent_map.hpp"
+#include "storage/indexes/index_holder.hpp"
#include "storage/model/properties/flags.hpp"
#include "utils/option.hpp"
#include "utils/total_ordering.hpp"
#include "utils/underlying_cast.hpp"
+// #include "storage/indexes/index_base.hpp"
+
// Family of properties with the same name but different types.
// Ordered on name.
-class PropertyFamily : public TotalOrdering<PropertyFamily>
+// TG - group of types Edge/Vertex
+template <class TG>
+class PropertyFamily : public TotalOrdering<PropertyFamily<TG>>
{
friend class PropertyType;
friend class PropertyFamilyKey;
@@ -175,6 +181,8 @@ public:
friend bool operator==(const PropertyFamily &lhs,
const PropertyFamily &rhs);
+ IndexHolder<TG, std::nullptr_t> index;
+
private:
const std::string name_v;
// This is exclusivly for getNull method.
@@ -184,11 +192,13 @@ private:
ConcurrentMap<Type, std::unique_ptr<PropertyType>> types;
};
+template <class TG>
class PropertyHash
{
public:
- size_t
- operator()(PropertyFamily::PropertyType::PropertyFamilyKey const &key) const
+ size_t operator()(
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey const &key)
+ const
{
return (std::hash<const void *>()((const void *)(&(key.get_family()))) +
7) *
diff --git a/include/storage/model/properties/traversers/consolewriter.hpp b/include/storage/model/properties/traversers/consolewriter.hpp
index dedc5eb4d..e81b1c534 100644
--- a/include/storage/model/properties/traversers/consolewriter.hpp
+++ b/include/storage/model/properties/traversers/consolewriter.hpp
@@ -4,6 +4,8 @@
#include "storage/model/properties/handler.hpp"
#include "storage/model/properties/properties.hpp"
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
using std::cout;
using std::endl;
@@ -13,7 +15,24 @@ class ConsoleWriter
public:
ConsoleWriter() {}
- void handle(const prop_key_t &key, const Property &value)
+ void handle(const typename PropertyFamily<
+ TypeGroupEdge>::PropertyType::PropertyFamilyKey &key,
+ const Property &value)
+ {
+ handle<TypeGroupEdge>(key, value);
+ }
+
+ void handle(const typename PropertyFamily<
+ TypeGroupVertex>::PropertyType::PropertyFamilyKey &key,
+ const Property &value)
+ {
+ handle<TypeGroupVertex>(key, value);
+ }
+
+ template <class T>
+ void handle(
+ const typename PropertyFamily<T>::PropertyType::PropertyFamilyKey &key,
+ const Property &value)
{
cout << "KEY: " << key.family_name() << "; VALUE: ";
diff --git a/include/storage/model/properties/traversers/jsonwriter.hpp b/include/storage/model/properties/traversers/jsonwriter.hpp
index 3daabcbef..449026783 100644
--- a/include/storage/model/properties/traversers/jsonwriter.hpp
+++ b/include/storage/model/properties/traversers/jsonwriter.hpp
@@ -2,6 +2,8 @@
#include "storage/model/properties/handler.hpp"
#include "storage/model/properties/properties.hpp"
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
template <class Buffer>
struct JsonWriter
@@ -9,7 +11,24 @@ struct JsonWriter
public:
JsonWriter(Buffer &buffer) : buffer(buffer) { buffer << '{'; };
- void handle(const prop_key_t &key, const Property &value)
+ void handle(const typename PropertyFamily<
+ TypeGroupEdge>::PropertyType::PropertyFamilyKey &key,
+ const Property &value)
+ {
+ handle<TypeGroupEdge>(key, value);
+ }
+
+ void handle(const typename PropertyFamily<
+ TypeGroupVertex>::PropertyType::PropertyFamilyKey &key,
+ const Property &value)
+ {
+ handle<TypeGroupVertex>(key, value);
+ }
+
+ template <class T>
+ void handle(
+ const typename PropertyFamily<T>::PropertyType::PropertyFamilyKey &key,
+ const Property &value)
{
if (!first) buffer << ',';
diff --git a/include/storage/model/property_model.hpp b/include/storage/model/property_model.hpp
index d6c7bb193..466446723 100644
--- a/include/storage/model/property_model.hpp
+++ b/include/storage/model/property_model.hpp
@@ -2,8 +2,9 @@
#include "storage/model/properties/properties.hpp"
+template <class TG>
class PropertyModel
{
public:
- Properties props;
+ Properties<TG> props;
};
diff --git a/include/storage/model/vertex_model.hpp b/include/storage/model/vertex_model.hpp
index 9293d0c51..088fbd549 100644
--- a/include/storage/model/vertex_model.hpp
+++ b/include/storage/model/vertex_model.hpp
@@ -5,7 +5,7 @@
#include "storage/model/edge_map.hpp"
#include "storage/model/property_model.hpp"
-class VertexModel : public PropertyModel
+class VertexModel : public PropertyModel<TypeGroupVertex>
{
public:
EdgeList out;
diff --git a/include/storage/record_accessor.hpp b/include/storage/record_accessor.hpp
index c72137406..945a7d696 100644
--- a/include/storage/record_accessor.hpp
+++ b/include/storage/record_accessor.hpp
@@ -3,15 +3,18 @@
#include "database/db_transaction.hpp"
#include "mvcc/version_list.hpp"
#include "storage/indexes/index_record.hpp"
+#include "storage/indexes/index_update.hpp"
#include "storage/model/properties/properties.hpp"
#include "storage/model/properties/property.hpp"
#include "storage/model/properties/property_family.hpp"
#include "transactions/transaction.hpp"
-template <class T, class Derived, class vlist_t = mvcc::VersionList<T>>
+template <class TG, class Derived>
class RecordAccessor
{
friend DbAccessor;
+ using vlist_t = typename TG::vlist_t;
+ using T = typename TG::record_t;
public:
RecordAccessor(vlist_t *vlist, DbTransaction &db) : vlist(vlist), db(db)
@@ -47,11 +50,27 @@ public:
const Id &id() const { return vlist->id; }
+ // TODO: Test this
Derived update() const
{
assert(!empty());
- return Derived(vlist->update(db.trans), vlist, db);
+ if (record->is_visible_write(db.trans)) {
+ // TODO: VALIDATE THIS BRANCH. THEN ONLY THIS TRANSACTION CAN SEE
+ // THIS DATA WHICH MEENS THAT IT CAN CHANGE IT.
+ return Derived(record, vlist, db);
+
+ } else {
+ auto new_record = vlist->update(db.trans);
+
+ // TODO: Validate that update of record in this accessor is correct.
+ const_cast<RecordAccessor *>(this)->record = new_record;
+
+ // Add record to update index.
+ db.to_update_index<TG>(vlist, new_record);
+
+ return Derived(new_record, vlist, db);
+ }
}
bool remove() const
@@ -61,30 +80,36 @@ public:
return vlist->remove(record, db.trans);
}
- const Property &at(PropertyFamily &key) const
+ const Property &at(PropertyFamily<TG> &key) const
{
return properties().at(key);
}
- const Property &at(prop_key_t &key) const { return properties().at(key); }
+ const Property &at(prop_key_t<TG> &key) const
+ {
+ return properties().at(key);
+ }
template <class V>
- auto at(type_key_t<V> &key) const;
+ auto at(type_key_t<TG, V> &key) const
+ {
+ return properties().template at<V>(key);
+ }
template <class V, class... Args>
- void set(type_key_t<V> &key, Args &&... args)
+ void set(type_key_t<TG, V> &key, Args &&... args)
{
properties().template set<V>(key, std::forward<Args>(args)...);
}
- void set(prop_key_t &key, Property::sptr value)
+ void set(prop_key_t<TG> &key, Property::sptr value)
{
properties().set(key, std::move(value));
}
- void clear(prop_key_t &key) { properties().clear(key); }
+ void clear(prop_key_t<TG> &key) { properties().clear(key); }
- void clear(PropertyFamily &key) { properties().clear(key); }
+ void clear(PropertyFamily<TG> &key) { properties().clear(key); }
template <class Handler>
void accept(Handler &handler) const
@@ -92,7 +117,7 @@ public:
properties().template accept<Handler>(handler);
}
- Properties &properties() const { return record->data.props; }
+ Properties<TG> &properties() const { return record->data.props; }
explicit operator bool() const { return record != nullptr; }
@@ -127,18 +152,6 @@ public:
return !(a == b);
}
-protected:
- IndexRecord<T, std::nullptr_t> create_index_record()
- {
- return create_index_record(std::nullptr_t());
- }
-
- template <class K>
- IndexRecord<T, K> create_index_record(K &&key)
- {
- return IndexRecord<T, K>(std::move(key), record, vlist);
- }
-
T *record{nullptr};
vlist_t *const vlist;
DbTransaction &db;
diff --git a/include/storage/type_group_edge.hpp b/include/storage/type_group_edge.hpp
new file mode 100644
index 000000000..f0871f865
--- /dev/null
+++ b/include/storage/type_group_edge.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+class Edge;
+class EdgeRecord;
+class EdgeAccessor;
+
+// Types for Edge side of database. Firstly there exists need for knowing the
+// type of object to be able to efficently use it. Dependant classes can
+// templetaze over such type, but this is anoying and error prone if there are
+// multiple such types over which it is necessary to templetaze. The idea is to
+// unify groups of logicaly tyed types into one type. That way depending classes
+// can template over that one type.
+class TypeGroupEdge
+{
+public:
+ using record_t = Edge;
+ using vlist_t = EdgeRecord;
+ using accessor_t = EdgeAccessor;
+};
diff --git a/include/storage/type_group_vertex.hpp b/include/storage/type_group_vertex.hpp
new file mode 100644
index 000000000..2c103ee78
--- /dev/null
+++ b/include/storage/type_group_vertex.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+class Vertex;
+class VertexRecord;
+class VertexAccessor;
+
+// Types for Vertex side of database. Firstly there exists need for knowing the
+// type of object to be able to efficently use it. Dependant classes can
+// templetaze over such type, but this is anoying and error prone if there are
+// multiple such types over which it is necessary to templetaze. The idea is to
+// unify groups of logicaly tyed types into one type. That way depending classes
+// can template over that one type.
+class TypeGroupVertex
+{
+public:
+ using record_t = Vertex;
+ using vlist_t = VertexRecord;
+ using accessor_t = VertexAccessor;
+};
diff --git a/include/storage/vertex_accessor.hpp b/include/storage/vertex_accessor.hpp
index 71b65d0c1..4a90481e0 100644
--- a/include/storage/vertex_accessor.hpp
+++ b/include/storage/vertex_accessor.hpp
@@ -5,16 +5,12 @@
class Vertices;
-class Vertex::Accessor : public RecordAccessor<Vertex, Vertex::Accessor>
+class VertexAccessor : public RecordAccessor<TypeGroupVertex, VertexAccessor>
{
public:
using RecordAccessor::RecordAccessor;
-
- static Vertex::Accessor create(Vertex *t, mvcc::VersionList<Vertex> *vlist,
- DbTransaction &db)
- {
- return Vertex::Accessor(t, vlist, db);
- }
+ typedef Vertex record_t;
+ typedef VertexRecord record_list_t;
size_t out_degree() const;
@@ -37,5 +33,5 @@ public:
auto in() const;
// True if there exists edge other->this
- bool in_contains(Vertex::Accessor const &other) const;
+ bool in_contains(VertexAccessor const &other) const;
};
diff --git a/include/storage/vertex_record.hpp b/include/storage/vertex_record.hpp
new file mode 100644
index 000000000..72051795b
--- /dev/null
+++ b/include/storage/vertex_record.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "mvcc/version_list.hpp"
+#include "storage/vertex.hpp"
+
+class VertexRecord : public mvcc::VersionList<Vertex>
+{
+public:
+ VertexRecord(Id id) : VersionList(id) {}
+ VertexRecord(const VersionList &) = delete;
+ VertexRecord(VersionList &&other) : VersionList(std::move(other)) {}
+};
diff --git a/include/storage/vertices.hpp b/include/storage/vertices.hpp
index c90293c7a..a10f43b08 100644
--- a/include/storage/vertices.hpp
+++ b/include/storage/vertices.hpp
@@ -1,31 +1,35 @@
#pragma once
-#include <memory>
#include <string>
+
#include "data_structures/concurrent/concurrent_map.hpp"
-#include "database/db_transaction.hpp"
-#include "storage/common.hpp"
-#include "storage/model/properties/property_family.hpp"
-#include "storage/vertex_accessor.hpp"
+#include "utils/counters/atomic_counter.hpp"
#include "utils/option.hpp"
+#include "storage/model/properties/property_family.hpp"
+#include "storage/vertex_record.hpp"
+
class DbTransaction;
+class VertexAccessor;
+
+using VertexPropertyFamily = PropertyFamily<TypeGroupVertex>;
class Vertices
{
public:
using vertices_t = ConcurrentMap<uint64_t, VertexRecord>;
using prop_familys_t =
- ConcurrentMap<std::string, std::unique_ptr<PropertyFamily>>;
+ ConcurrentMap<std::string, std::unique_ptr<VertexPropertyFamily>>;
vertices_t::Accessor access();
- Option<const Vertex::Accessor> find(DbTransaction &t, const Id &id);
+ Option<const VertexAccessor> find(DbTransaction &t, const Id &id);
- // Creates new Vertex and returns filled Vertex::Accessor.
- Vertex::Accessor insert(DbTransaction &t);
+ // Creates new Vertex and returns filled VertexAccessor.
+ VertexAccessor insert(DbTransaction &t);
- PropertyFamily &property_family_find_or_create(const std::string &name);
+ VertexPropertyFamily &
+ property_family_find_or_create(const std::string &name);
private:
vertices_t vertices;
diff --git a/include/transactions/commit_log.hpp b/include/transactions/commit_log.hpp
index 9f0608668..cc043ac6a 100644
--- a/include/transactions/commit_log.hpp
+++ b/include/transactions/commit_log.hpp
@@ -48,6 +48,9 @@ public:
void set_aborted(const Id &id) { log.set(2 * id + 1); }
private:
+ // TODO: Searching the log will take more and more time the more and more
+ // transactoins are done. This could be awerted if DynamicBitset is changed
+ // to point to largest chunk instead of the smallest.
DynamicBitset<uint8_t, 32768> log;
};
}
diff --git a/include/transactions/engine.hpp b/include/transactions/engine.hpp
index 2fb9d95d7..0348f80de 100644
--- a/include/transactions/engine.hpp
+++ b/include/transactions/engine.hpp
@@ -26,7 +26,10 @@ public:
Engine() : counter(1) {}
- Transaction &begin()
+ // Begins transaction and runs given functions in same atomic step.
+ // Functions will be given Transaction&
+ template <class... F>
+ Transaction &begin(F... fun)
{
auto guard = this->acquire_unique();
@@ -36,6 +39,8 @@ public:
active.insert(id);
store.put(id, t);
+ call(*t, fun...);
+
return *t;
}
@@ -53,6 +58,14 @@ public:
return *t;
}
+ // Returns copy of current snapshot
+ Snapshot<Id> snapshot()
+ {
+ auto guard = this->acquire_unique();
+
+ return active;
+ }
+
void commit(const Transaction &t)
{
auto guard = this->acquire_unique();
@@ -92,6 +105,21 @@ public:
CommitLog clog;
private:
+ template <class T, class... F>
+ void call(Transaction &t, T fun, F... funs)
+ {
+ call(t, fun);
+ call(t, funs...);
+ }
+
+ template <class T>
+ void call(Transaction &t, T fun)
+ {
+ fun(t);
+ }
+
+ void call(Transaction &t) {}
+
void finalize(const Transaction &t)
{
active.remove(t.id);
diff --git a/include/transactions/snapshot.hpp b/include/transactions/snapshot.hpp
index 8c558b3e6..04168a959 100644
--- a/include/transactions/snapshot.hpp
+++ b/include/transactions/snapshot.hpp
@@ -1,7 +1,7 @@
#pragma once
-#include <vector>
#include <algorithm>
+#include <vector>
namespace tx
{
@@ -14,45 +14,31 @@ public:
Snapshot(std::vector<id_t> active) : active(std::move(active)) {}
- Snapshot(const Snapshot& other)
- {
- active = other.active;
- }
+ Snapshot(const Snapshot &other) { active = other.active; }
- Snapshot(Snapshot&& other)
- {
- active = std::move(other.active);
- }
+ Snapshot(Snapshot &&other) { active = std::move(other.active); }
bool is_active(id_t xid) const
{
return std::binary_search(active.begin(), active.end(), xid);
}
- void insert(const id_t& id)
- {
- active.push_back(id);
- }
+ void insert(const id_t &id) { active.push_back(id); }
- void remove(const id_t& id)
+ void remove(const id_t &id)
{
// remove transaction from the active transactions list
auto last = std::remove(active.begin(), active.end(), id);
active.erase(last, active.end());
}
- const id_t& front()
- {
- return active.front();
- }
+ const id_t &front() { return active.front(); }
- size_t size()
- {
- return active.size();
- }
+ const id_t &back() { return active.back(); }
+
+ size_t size() { return active.size(); }
private:
std::vector<id_t> active;
};
-
}
diff --git a/include/transactions/transaction.hpp b/include/transactions/transaction.hpp
index f287282df..7c618aadf 100644
--- a/include/transactions/transaction.hpp
+++ b/include/transactions/transaction.hpp
@@ -28,8 +28,13 @@ public:
// index of the current command in the current transaction;
uint8_t cid;
// a snapshot of currently active transactions
- const Snapshot<Id> snapshot;
+ // Blocks until all transactions from snapshot finish. After this method,
+ // snapshot will be empty.
+ void wait_for_active();
+
+ // True if id is in snapshot.
+ bool is_active(const Id &id) const;
void take_lock(RecordLock &lock);
void commit();
void abort();
@@ -37,6 +42,7 @@ public:
Engine &engine;
private:
+ Snapshot<Id> snapshot;
LockStore<RecordLock> locks;
};
}
diff --git a/include/utils/border.hpp b/include/utils/border.hpp
index 641ee1d29..16c9555bb 100644
--- a/include/utils/border.hpp
+++ b/include/utils/border.hpp
@@ -1,6 +1,7 @@
#pragma once
#include "utils/option.hpp"
+#include "utils/total_ordering.hpp"
// Defines Including as [ and Excluding < for ranges.
enum BorderType
@@ -9,6 +10,7 @@ enum BorderType
Excluding = 1,
};
+// If key is not present he is both the largest and the smallest of the keys.
template <class T>
class Border
{
@@ -26,22 +28,60 @@ public:
Border &operator=(Border &&other) = default;
Border &operator=(Border &other) = default;
- // true if no border or this > key or this >= key depends on border type.
- bool operator>(const T &other) const
+ friend bool operator<(const Border<T> &a, const T &other)
{
- return !key.is_present() || key.get() > other ||
- (type == Including && key.get() == other);
+ return !a.key.is_present() ||
+ (a.type == Excluding && a.key.get() <= other) ||
+ (a.type == Including && a.key.get() < other);
}
- // true if no border or this < key or this <= key depends on border type.
- bool operator<(const T &other) const
+ friend bool operator==(const Border<T> &a, const T &other)
{
- return !key.is_present() || key.get() < other ||
- (type == Including && key.get() == other);
+ return a.type == Including && a.key.is_present() &&
+ a.key.get() == other;
}
+ friend bool operator>(const Border<T> &a, const T &other)
+ {
+ return !a.key.is_present() ||
+ (a.type == Excluding && a.key.get() >= other) ||
+ (a.type == Including && a.key.get() > other);
+ }
+
+ friend bool operator!=(const Border<T> &a, const T &b) { return !(a == b); }
+
+ friend bool operator<=(const Border<T> &a, const T &b)
+ {
+ return a < b || a == b;
+ }
+
+ friend bool operator>=(const Border<T> &a, const T &b)
+ {
+ return a > b || a == b;
+ }
+
+ // // true if no border or this > key or this >= key depends on border type.
+ // bool operator>(const T &other) const
+ // {
+ // return !key.is_present() || key.get() > other ||
+ // (type == Including && key.get() == other);
+ // }
+ //
+ // // true if this border is inclusive and key is present and key == other.
+ // bool operator==(const T &other) const
+ // {
+ // return type == Including && key.is_present() && key.get() == other;
+ // }
+ //
+ // // true if no border or this < key or this <= key depends on border type.
+ // bool operator<(const T &other) const
+ // {
+ // return !key.is_present() || key.get() < other ||
+ // (type == Including && key.get() == other);
+ // }
+
Option<T> key;
- const BorderType type;
+ BorderType type;
};
template <class T>
diff --git a/include/utils/option_ptr.hpp b/include/utils/option_ptr.hpp
index b3fb0f550..a57502788 100644
--- a/include/utils/option_ptr.hpp
+++ b/include/utils/option_ptr.hpp
@@ -18,3 +18,9 @@ public:
private:
T *ptr = nullptr;
};
+
+template <class T>
+auto make_option_ptr(T *t)
+{
+ return OptionPtr<T>(t);
+}
diff --git a/include/utils/order.hpp b/include/utils/order.hpp
new file mode 100644
index 000000000..645609320
--- /dev/null
+++ b/include/utils/order.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+// Defines ordering of data
+enum Order
+{
+ None = 0,
+ Ascending = 1,
+ Descending = 2,
+};
diff --git a/poc/astar.cpp b/poc/astar.cpp
index c14084fa2..c4a6a09aa 100644
--- a/poc/astar.cpp
+++ b/poc/astar.cpp
@@ -28,7 +28,7 @@
const int max_score = 1000000;
using namespace std;
-typedef Vertex::Accessor VertexAccessor;
+typedef VertexAccessor VertexAccessor;
void add_scores(Db &db);
@@ -36,17 +36,18 @@ class Node
{
public:
Node *parent = {nullptr};
- type_key_t<Double> tkey;
+ type_key_t<TypeGroupVertex, Double> tkey;
double cost;
int depth = {0};
VertexAccessor vacc;
- Node(VertexAccessor vacc, double cost, type_key_t<Double> tkey)
+ Node(VertexAccessor vacc, double cost,
+ type_key_t<TypeGroupVertex, Double> tkey)
: cost(cost), vacc(vacc), tkey(tkey)
{
}
Node(VertexAccessor vacc, double cost, Node *parent,
- type_key_t<Double> tkey)
+ type_key_t<TypeGroupVertex, Double> tkey)
: cost(cost), vacc(vacc), parent(parent), depth(parent->depth + 1),
tkey(tkey)
{
@@ -84,27 +85,27 @@ void found_result(Node *res)
}
}
-double calc_heuristic_cost_dummy(type_key_t<Double> tkey, Edge::Accessor &edge,
- Vertex::Accessor &vertex)
+double calc_heuristic_cost_dummy(type_key_t<TypeGroupVertex, Double> tkey,
+ EdgeAccessor &edge, VertexAccessor &vertex)
{
assert(!vertex.empty());
return 1 - *vertex.at(tkey).get();
}
-typedef bool (*EdgeFilter)(DbAccessor &t, Edge::Accessor &, Node *before);
-typedef bool (*VertexFilter)(DbAccessor &t, Vertex::Accessor &, Node *before);
+typedef bool (*EdgeFilter)(DbAccessor &t, EdgeAccessor &, Node *before);
+typedef bool (*VertexFilter)(DbAccessor &t, VertexAccessor &, Node *before);
-bool edge_filter_dummy(DbAccessor &t, Edge::Accessor &e, Node *before)
+bool edge_filter_dummy(DbAccessor &t, EdgeAccessor &e, Node *before)
{
return true;
}
-bool vertex_filter_dummy(DbAccessor &t, Vertex::Accessor &va, Node *before)
+bool vertex_filter_dummy(DbAccessor &t, VertexAccessor &va, Node *before)
{
return va.fill();
}
-bool vertex_filter_contained_dummy(DbAccessor &t, Vertex::Accessor &v,
+bool vertex_filter_contained_dummy(DbAccessor &t, VertexAccessor &v,
Node *before)
{
if (v.fill()) {
@@ -128,7 +129,7 @@ bool vertex_filter_contained_dummy(DbAccessor &t, Vertex::Accessor &v,
return false;
}
-bool vertex_filter_contained(DbAccessor &t, Vertex::Accessor &v, Node *before)
+bool vertex_filter_contained(DbAccessor &t, VertexAccessor &v, Node *before)
{
if (v.fill()) {
bool found;
@@ -146,17 +147,18 @@ bool vertex_filter_contained(DbAccessor &t, Vertex::Accessor &v, Node *before)
// Vertex filter ima max_depth funkcija te edge filter ima max_depth funkcija.
// Jedan za svaku dubinu.
// Filtri vracaju true ako element zadovoljava uvjete.
-auto a_star(Db &db, int64_t sys_id_start, uint max_depth, EdgeFilter e_filter[],
- VertexFilter v_filter[],
- double (*calc_heuristic_cost)(type_key_t<Double> tkey,
- Edge::Accessor &edge,
- Vertex::Accessor &vertex),
- int limit)
+auto a_star(
+ Db &db, int64_t sys_id_start, uint max_depth, EdgeFilter e_filter[],
+ VertexFilter v_filter[],
+ double (*calc_heuristic_cost)(type_key_t<TypeGroupVertex, Double> tkey,
+ EdgeAccessor &edge, VertexAccessor &vertex),
+ int limit)
{
DbAccessor t(db);
- type_key_t<Double> tkey = t.vertex_property_family_get("score")
- .get(Flags::Double)
- .type_key<Double>();
+ type_key_t<TypeGroupVertex, Double> tkey =
+ t.vertex_property_family_get("score")
+ .get(Flags::Double)
+ .type_key<Double>();
auto best_found = new std::map<Id, Score>[max_depth];
diff --git a/poc/tool.cpp b/poc/tool.cpp
index 616db34f2..1f16f16c9 100644
--- a/poc/tool.cpp
+++ b/poc/tool.cpp
@@ -20,7 +20,7 @@ using namespace std;
// generation.
template <class C>
-void fill_to_fill(Edge::Accessor &e, const EdgeType &type, C &&consumer)
+void fill_to_fill(EdgeAccessor &e, const EdgeType &type, C &&consumer)
{
if (e.fill() && e.edge_type() == type) {
auto to = e.to();
@@ -31,7 +31,7 @@ void fill_to_fill(Edge::Accessor &e, const EdgeType &type, C &&consumer)
}
template <class C>
-void fill_from_fill(Edge::Accessor &e, const EdgeType &type, C &&consumer)
+void fill_from_fill(EdgeAccessor &e, const EdgeType &type, C &&consumer)
{
if (e.fill() && e.edge_type() == type) {
auto from = e.from();
@@ -42,7 +42,7 @@ void fill_from_fill(Edge::Accessor &e, const EdgeType &type, C &&consumer)
}
template <class C>
-void fill_to_fill(Edge::Accessor &e, C &&consumer)
+void fill_to_fill(EdgeAccessor &e, C &&consumer)
{
if (e.fill()) {
auto to = e.to();
@@ -53,7 +53,7 @@ void fill_to_fill(Edge::Accessor &e, C &&consumer)
}
template <class C>
-void to_fill(Edge::Accessor &e, C &&consumer)
+void to_fill(EdgeAccessor &e, C &&consumer)
{
auto to = e.to();
if (to.fill()) {
@@ -62,7 +62,7 @@ void to_fill(Edge::Accessor &e, C &&consumer)
}
template <class C>
-void to_fill(Edge::Accessor &e, const Label &label, C &&consumer)
+void to_fill(EdgeAccessor &e, const Label &label, C &&consumer)
{
auto to = e.to();
if (to.fill() && to.has_label(label)) {
@@ -71,7 +71,7 @@ void to_fill(Edge::Accessor &e, const Label &label, C &&consumer)
}
template <class C>
-void to_fill(Edge::Accessor &e, const EdgeType &type, const Label &label,
+void to_fill(EdgeAccessor &e, const EdgeType &type, const Label &label,
C &&consumer)
{
if (e.edge_type() == type) {
@@ -83,7 +83,7 @@ void to_fill(Edge::Accessor &e, const EdgeType &type, const Label &label,
}
template <class C>
-void from_fill(Edge::Accessor &e, const EdgeType &type, C &&consumer)
+void from_fill(EdgeAccessor &e, const EdgeType &type, C &&consumer)
{
if (e.edge_type() == type) {
auto from = e.from();
@@ -94,7 +94,7 @@ void from_fill(Edge::Accessor &e, const EdgeType &type, C &&consumer)
}
template <class C>
-void fill_from_fill(Edge::Accessor &e, C &&consumer)
+void fill_from_fill(EdgeAccessor &e, C &&consumer)
{
if (e.fill()) {
auto from = e.from();
@@ -144,10 +144,10 @@ void find_fill(I iter, C &&consumer)
}
}
-void fill_with_bt(unordered_map<string, double> &values, Vertex::Accessor &com,
- double weight,
- PropertyFamily::PropertyType::PropertyTypeKey<ArrayString>
- &prop_vertex_business_types)
+void fill_with_bt(
+ unordered_map<string, double> &values, VertexAccessor &com, double weight,
+ VertexPropertyFamily::PropertyType::PropertyTypeKey<ArrayString>
+ &prop_vertex_business_types)
{
auto bus_t = com.at(prop_vertex_business_types);
if (bus_t.is_present()) {
@@ -158,8 +158,8 @@ void fill_with_bt(unordered_map<string, double> &values, Vertex::Accessor &com,
}
void oportunity_employe_company(
- Vertex::Accessor &va, unordered_map<string, double> &values, double weight,
- PropertyFamily::PropertyType::PropertyTypeKey<ArrayString>
+ VertexAccessor &va, unordered_map<string, double> &values, double weight,
+ VertexPropertyFamily::PropertyType::PropertyTypeKey<ArrayString>
&prop_vertex_business_types,
const EdgeType &type_created, const EdgeType &type_works_in,
const Label &label_company)
@@ -192,16 +192,17 @@ auto query(DbAccessor &t, const Id &start_id)
const Label &label_company = t.label_find_or_create("Company");
const Label &label_opportunuty = t.label_find_or_create("Opportunity");
- auto type_works_in = t.type_find_or_create("Works_In");
- auto type_reached_to = t.type_find_or_create("Reached_To");
- auto type_partnered_with = t.type_find_or_create("Partnered_With");
- auto type_interested_in = t.type_find_or_create("Interested_In");
- auto type_viewed = t.type_find_or_create("Viewed");
- auto type_has_match = t.type_find_or_create("Has_Match");
- auto type_searched_and_clicked =
+ const EdgeType &type_works_in = t.type_find_or_create("Works_In");
+ const EdgeType &type_reached_to = t.type_find_or_create("Reached_To");
+ const EdgeType &type_partnered_with =
+ t.type_find_or_create("Partnered_With");
+ const EdgeType &type_interested_in = t.type_find_or_create("Interested_In");
+ const EdgeType &type_viewed = t.type_find_or_create("Viewed");
+ const EdgeType &type_has_match = t.type_find_or_create("Has_Match");
+ const EdgeType &type_searched_and_clicked =
t.type_find_or_create("Searched_And_Clicked");
- auto type_is_employee = t.type_find_or_create("Is_Employee");
- auto type_created = t.type_find_or_create("Created");
+ const EdgeType &type_is_employee = t.type_find_or_create("Is_Employee");
+ const EdgeType &type_created = t.type_find_or_create("Created");
auto prop_edge_status = t.edge_property_family_get("status")
.get(Flags::String)
@@ -362,18 +363,21 @@ int main(int argc, char **argv)
DbAccessor t(db);
int n = 300 * 1000;
- vector<pair<Vertex::Accessor, unordered_map<string, double>>> coll;
+ vector<pair<VertexAccessor, unordered_map<string, double>>> coll;
// QUERY BENCHMARK
auto begin = clock();
int i = 0;
- iter::for_all_fill(
+ iter::find_fill(
t.label_find_or_create("Company").index->for_range_exact(t),
[&](auto v) {
if (i < n) {
coll.push_back(make_pair(v, query(t, v.id())));
+ i++;
+ return false;
+ } else {
+ return true;
}
- i++;
});
n = i;
clock_t end = clock();
diff --git a/src/api/resources/node.hpp b/src/api/resources/node.hpp
index 4e643654c..14362f550 100644
--- a/src/api/resources/node.hpp
+++ b/src/api/resources/node.hpp
@@ -37,7 +37,7 @@ public:
return std::move(vertex_accessor);
},
- [&req, &res](Vertex::Accessor&& vertex_accessor) {
+ [&req, &res](VertexAccessor&& vertex_accessor) {
return res.send(
http::Status::Created,
vertex_create_response(vertex_accessor)
@@ -69,7 +69,7 @@ public:
return std::move(vertex_accessor);
},
- [&req, &res](Vertex::Accessor&& vertex_accessor) {
+ [&req, &res](VertexAccessor&& vertex_accessor) {
if (vertex_accessor.empty()) {
return res.send(
http::Status::NotFound,
@@ -111,7 +111,7 @@ public:
return std::move(vertex_accessor);
},
- [&req, &res](Vertex::Accessor&& vertex_accessor) {
+ [&req, &res](VertexAccessor&& vertex_accessor) {
if (vertex_accessor.empty()) {
return res.send(
http::Status::NotFound,
diff --git a/src/api/response_json.hpp b/src/api/response_json.hpp
index 5c659e271..e54034586 100644
--- a/src/api/response_json.hpp
+++ b/src/api/response_json.hpp
@@ -29,7 +29,7 @@ using RJStringBuffer = rapidjson::StringBuffer;
using RJStringWriter = rapidjson::Writer<RJStringBuffer>;
using ptr_RJStringWriter = std::shared_ptr<RJStringWriter>;
-std::string vertex_create_response(const Vertex::Accessor& vertex_accessor)
+std::string vertex_create_response(const VertexAccessor& vertex_accessor)
{
// make a string buffer
RJStringBuffer buffer;
diff --git a/src/database/db.cpp b/src/database/db.cpp
index df9abaa74..e00c772ca 100644
--- a/src/database/db.cpp
+++ b/src/database/db.cpp
@@ -5,3 +5,60 @@ Db::Db() = default;
Db::Db(const std::string &name) : name_(name) {}
std::string &Db::name() { return name_; }
+
+template <class TG, class I, class G>
+bool Db::create_index_on_vertex_property_family(const char *name, G &coll,
+ I &create_index)
+{
+ auto &family = coll.property_family_find_or_create(name);
+ bool added_index = false;
+ DbTransaction t(*this, tx_engine.begin([&](auto t) {
+ added_index = family.index.set_index(create_index(t));
+ }));
+
+ if (added_index) {
+ t.trans.wait_for_active();
+
+ auto oindex = family.index.get_write(t.trans);
+ if (oindex.is_present()) {
+ auto index = oindex.get();
+
+ for (auto &vr : coll.access()) {
+ auto v = vr.second.find(t.trans);
+ if (v != nullptr) {
+ if (!index->insert(IndexRecord<TG, std::nullptr_t>(
+ std::nullptr_t(), v, &vr.second))) {
+ // Index is probably unique.
+ auto owned_maybe = family.index.remove_index(index);
+ if (owned_maybe.is_present()) {
+ garbage.dispose(tx_engine.snapshot(),
+ owned_maybe.get().release());
+ }
+
+ t.trans.abort();
+ return false;
+ }
+ }
+ }
+
+ index->activate();
+ t.trans.commit();
+ return true;
+ }
+ }
+
+ t.trans.abort();
+ return false;
+}
+
+template <class TG, class K>
+bool Db::remove_index(IndexHolder<TG, K> &ih)
+{
+ auto owned_maybe = ih.remove_index();
+ if (owned_maybe.is_present()) {
+ garbage.dispose(tx_engine.snapshot(), owned_maybe.get().release());
+ return true;
+ }
+
+ return false;
+}
diff --git a/src/database/db_accessor.cpp b/src/database/db_accessor.cpp
index e418a75d5..29bb2bd10 100644
--- a/src/database/db_accessor.cpp
+++ b/src/database/db_accessor.cpp
@@ -7,35 +7,40 @@ DbAccessor::DbAccessor(Db &db)
{
}
+DbAccessor::DbAccessor(Db &db, tx::Transaction &t)
+ : db_transaction(DbTransaction(db, t))
+{
+}
+
// VERTEX METHODS
auto DbAccessor::vertex_access()
{
return iter::make_map(
iter::make_iter(this->db_transaction.db.graph.vertices.access()),
[&](auto e) -> auto {
- return Vertex::Accessor(&(e->second), db_transaction);
+ return VertexAccessor(&(e->second), db_transaction);
});
}
-Option<const Vertex::Accessor> DbAccessor::vertex_find(const Id &id)
+Option<const VertexAccessor> DbAccessor::vertex_find(const Id &id)
{
return this->db_transaction.db.graph.vertices.find(db_transaction, id);
}
-Vertex::Accessor DbAccessor::vertex_insert()
+VertexAccessor DbAccessor::vertex_insert()
{
return this->db_transaction.db.graph.vertices.insert(db_transaction);
}
// EDGE METHODS
-Option<const Edge::Accessor> DbAccessor::edge_find(const Id &id)
+Option<const EdgeAccessor> DbAccessor::edge_find(const Id &id)
{
return db_transaction.db.graph.edges.find(db_transaction, id);
}
-Edge::Accessor DbAccessor::edge_insert(Vertex::Accessor const &from,
- Vertex::Accessor const &to)
+EdgeAccessor DbAccessor::edge_insert(VertexAccessor const &from,
+ VertexAccessor const &to)
{
auto edge_accessor = db_transaction.db.graph.edges.insert(
db_transaction, from.vlist, to.vlist);
@@ -67,30 +72,55 @@ bool DbAccessor::type_contains(const char *name)
}
// PROPERTY METHODS
-PropertyFamily &DbAccessor::vertex_property_family_get(const std::string &name)
+VertexPropertyFamily &
+DbAccessor::vertex_property_family_get(const std::string &name)
{
return db_transaction.db.graph.vertices.property_family_find_or_create(
name);
}
-PropertyFamily &DbAccessor::edge_property_family_get(const std::string &name)
+EdgePropertyFamily &
+DbAccessor::edge_property_family_get(const std::string &name)
{
return db_transaction.db.graph.edges.property_family_find_or_create(name);
}
// PROPERTY HELPER METHODS
-PropertyFamily::PropertyType::PropertyFamilyKey
+VertexPropertyFamily::PropertyType::PropertyFamilyKey
DbAccessor::vertex_property_key(const std::string &name, Type type)
{
return vertex_property_family_get(name).get(type).family_key();
}
-PropertyFamily::PropertyType::PropertyFamilyKey
+EdgePropertyFamily::PropertyType::PropertyFamilyKey
DbAccessor::edge_property_key(const std::string &name, Type type)
{
return edge_property_family_get(name).get(type).family_key();
}
+template <class T>
+VertexPropertyFamily::PropertyType::PropertyTypeKey<T>
+DbAccessor::vertex_property_key(const std::string &name)
+{
+ return vertex_property_family_get(name).get(T::type).template type_key<T>();
+}
+
+template <class T>
+EdgePropertyFamily::PropertyType::PropertyTypeKey<T>
+DbAccessor::edge_property_key(const std::string &name)
+{
+ return edge_property_family_get(name).get(T::type).template type_key<T>();
+}
+
// TRANSACTION METHODS
-void DbAccessor::commit() { db_transaction.trans.commit(); }
+bool DbAccessor::commit()
+{
+ if (db_transaction.update_indexes()) {
+ db_transaction.trans.commit();
+ return true;
+ } else {
+ db_transaction.trans.abort();
+ return false;
+ }
+}
void DbAccessor::abort() { db_transaction.trans.abort(); }
diff --git a/src/database/db_transaction.cpp b/src/database/db_transaction.cpp
new file mode 100644
index 000000000..1b2d3fd7d
--- /dev/null
+++ b/src/database/db_transaction.cpp
@@ -0,0 +1,63 @@
+#include "database/db_transaction.hpp"
+
+#include "storage/edge.hpp"
+#include "storage/edge_type/edge_type.hpp"
+#include "storage/label/label.hpp"
+#include "storage/vertex.hpp"
+
+#define TRY(x) \
+ if (!x) { \
+ return false; \
+ }
+
+template <class TG, class IU>
+bool update_property_indexes(IU &iu, const tx::Transaction &t)
+{
+ for (auto kp : iu.record->data.props) {
+
+ // FamilyProperty index
+ auto opi = kp.first.get_family().index.get_write(t);
+ if (opi.is_present()) {
+ TRY(opi.get()->insert(IndexRecord<TG, std::nullptr_t>(
+ std::nullptr_t(), iu.record, iu.vlist)));
+ }
+
+ // TODO: other properti indexes
+ }
+
+ return true;
+}
+
+bool DbTransaction::update_indexes()
+{
+ while (!index_updates.empty()) {
+ auto iu = index_updates.back();
+
+ if (iu.tag == IndexUpdate::EDGE) {
+ auto e = iu.e;
+
+ // TODO: This could be done in batch
+ // NOTE: This assumes that type index is created with the database.
+ TRY(e.record->data.edge_type->index->insert(
+ EdgeTypeIndexRecord(std::nullptr_t(), e.record, e.vlist)));
+
+ TRY(update_property_indexes<TypeGroupEdge>(e, trans));
+
+ } else {
+ auto v = iu.v;
+
+ for (auto l : v.record->data.labels()) {
+ // TODO: This could be done in batch
+ // NOTE: This assumes that label index is created with the
+ // database.
+ TRY(l.get().index->insert(
+ LabelIndexRecord(std::nullptr_t(), v.record, v.vlist)));
+ }
+
+ TRY(update_property_indexes<TypeGroupVertex>(v, trans));
+ }
+
+ index_updates.pop_back();
+ }
+ return true;
+}
diff --git a/src/import/base_import.hpp b/src/import/base_import.hpp
index 8b577405e..20acb7904 100644
--- a/src/import/base_import.hpp
+++ b/src/import/base_import.hpp
@@ -20,7 +20,7 @@
using namespace std;
-static Option<Vertex::Accessor> empty_op_vacc;
+static Option<VertexAccessor> empty_op_vacc;
// Base importer with common facilities.
class BaseImporter
@@ -186,7 +186,7 @@ public:
// }
}
- Option<Vertex::Accessor> const &get_vertex(size_t id)
+ Option<VertexAccessor> const &get_vertex(size_t id)
{
if (vertices.size() > id) {
return vertices[id];
@@ -214,5 +214,5 @@ protected:
ostream &err_stream;
// All created vertices which have import local id
- vector<Option<Vertex::Accessor>> vertices;
+ vector<Option<VertexAccessor>> vertices;
};
diff --git a/src/import/csv_import.hpp b/src/import/csv_import.hpp
index 865c21b52..731d13163 100644
--- a/src/import/csv_import.hpp
+++ b/src/import/csv_import.hpp
@@ -50,18 +50,18 @@ public:
// Loads data from stream and returns number of loaded vertexes.
size_t import_vertices(std::fstream &file)
{
- return import(file, create_vertex, true);
+ return import<TypeGroupVertex>(file, create_vertex, true);
}
// Loads data from stream and returns number of loaded edges.
size_t import_edges(std::fstream &file)
{
- return import(file, create_edge, false);
+ return import<TypeGroupEdge>(file, create_edge, false);
}
private:
// Loads data from file and returns number of loaded name.
- template <class F>
+ template <class TG, class F>
size_t import(std::fstream &file, F f, bool vertex)
{
string line;
@@ -81,7 +81,7 @@ private:
}
for (auto p : sub_str) {
- auto o = get_filler(p, tmp, vertex);
+ auto o = get_filler<TG>(p, tmp, vertex);
if (o.is_present()) {
fillers.push_back(o.take());
} else {
@@ -132,8 +132,7 @@ private:
if (id.is_present()) {
if (im->vertices.size() <= id.get()) {
- Option<Vertex::Accessor> empty =
- make_option<Vertex::Accessor>();
+ Option<VertexAccessor> empty = make_option<VertexAccessor>();
im->vertices.insert(im->vertices.end(),
id.get() - im->vertices.size() + 1, empty);
}
@@ -166,7 +165,31 @@ private:
}
}
+ // template <typename F>
+ // Option<unique_ptr<Filler>> make_filler_property(bool vertex,
+ // const char name, Flags
+ // type)
+ // {
+ // if (vertex) {
+ // std::unique_ptr<Filler> f(
+ // F(db.vertex_property_key(name, Type(type))));
+ // return make_option(std::move(f));
+ // } else {
+ // std::unique_ptr<Filler> f(
+ // F(db.edge_property_key(name, Type(type))));
+ // return make_option(std::move(f));
+ // }
+ // }
+
+ template <class TG>
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey
+ prop_key(const char *name, Flags type)
+ {
+ assert(false);
+ }
+
// Returns filler for name:type in header_part. None if error occured.
+ template <class TG>
Option<unique_ptr<Filler>> get_filler(char *header_part,
vector<char *> &tmp_vec, bool vertex)
{
@@ -193,20 +216,20 @@ private:
// cout << name << " # " << type << endl;
- auto prop_key = [&](auto name, auto type) -> auto
- {
- if (vertex) {
- return db.vertex_property_key(name, Type(type));
- } else {
- return db.edge_property_key(name, Type(type));
- }
- };
+ // auto prop_key = [&](auto name, auto type) -> auto
+ // {
+ // if (vertex) {
+ // return db.vertex_property_key(name, Type(type));
+ // } else {
+ // return db.edge_property_key(name, Type(type));
+ // }
+ // };
if (equal_str(type, "id")) {
std::unique_ptr<Filler> f(
- name[0] == '\0'
- ? new IdFiller()
- : new IdFiller(make_option(prop_key(name, Flags::Int64))));
+ name[0] == '\0' ? new IdFiller<TG>()
+ : new IdFiller<TG>(make_option(
+ prop_key<TG>(name, Flags::Int64))));
return make_option(std::move(f));
} else if (equal_str(type, "start_id") || equal_str(type, "from_id") ||
@@ -234,63 +257,69 @@ private:
// *********************** PROPERTIES
} else if (equal_str(type, "bool")) {
+ // return make_filler_property<BoolFiller>(vertex, name,
+ // Flags::Bool);
std::unique_ptr<Filler> f(
- new BoolFiller(prop_key(name, Flags::Bool)));
+ new BoolFiller<TG>(prop_key<TG>(name, Flags::Bool)));
return make_option(std::move(f));
} else if (equal_str(type, "double")) {
std::unique_ptr<Filler> f(
- new DoubleFiller(prop_key(name, Flags::Double)));
+ new DoubleFiller<TG>(prop_key<TG>(name, Flags::Double)));
return make_option(std::move(f));
} else if (equal_str(type, "float")) {
std::unique_ptr<Filler> f(
- new FloatFiller(prop_key(name, Flags::Float)));
+ new FloatFiller<TG>(prop_key<TG>(name, Flags::Float)));
return make_option(std::move(f));
} else if (equal_str(type, "int")) {
std::unique_ptr<Filler> f(
- new Int32Filler(prop_key(name, Flags::Int32)));
+ new Int32Filler<TG>(prop_key<TG>(name, Flags::Int32)));
return make_option(std::move(f));
} else if (equal_str(type, "long")) {
std::unique_ptr<Filler> f(
- new Int64Filler(prop_key(name, Flags::Int64)));
+ new Int64Filler<TG>(prop_key<TG>(name, Flags::Int64)));
return make_option(std::move(f));
} else if (equal_str(type, "string")) {
std::unique_ptr<Filler> f(
- new StringFiller(prop_key(name, Flags::String)));
+ new StringFiller<TG>(prop_key<TG>(name, Flags::String)));
return make_option(std::move(f));
} else if (equal_str(type, "bool[]")) {
- std::unique_ptr<Filler> f(make_array_filler<bool, ArrayBool>(
- *this, prop_key(name, Flags::ArrayBool), to_bool));
+ std::unique_ptr<Filler> f(make_array_filler<TG, bool, ArrayBool>(
+ *this, prop_key<TG>(name, Flags::ArrayBool), to_bool));
return make_option(std::move(f));
} else if (equal_str(type, "float[]")) {
- std::unique_ptr<Filler> f(make_array_filler<float, ArrayFloat>(
- *this, prop_key(name, Flags::ArrayFloat), to_float));
+ std::unique_ptr<Filler> f(make_array_filler<TG, float, ArrayFloat>(
+ *this, prop_key<TG>(name, Flags::ArrayFloat), to_float));
return make_option(std::move(f));
} else if (equal_str(type, "double[]")) {
- std::unique_ptr<Filler> f(make_array_filler<double, ArrayDouble>(
- *this, prop_key(name, Flags::ArrayDouble), to_double));
+ std::unique_ptr<Filler> f(
+ make_array_filler<TG, double, ArrayDouble>(
+ *this, prop_key<TG>(name, Flags::ArrayDouble), to_double));
return make_option(std::move(f));
} else if (equal_str(type, "int[]")) {
- std::unique_ptr<Filler> f(make_array_filler<int32_t, ArrayInt32>(
- *this, prop_key(name, Flags::ArrayInt32), to_int32));
+ std::unique_ptr<Filler> f(
+ make_array_filler<TG, int32_t, ArrayInt32>(
+ *this, prop_key<TG>(name, Flags::ArrayInt32), to_int32));
return make_option(std::move(f));
} else if (equal_str(type, "long[]")) {
- std::unique_ptr<Filler> f(make_array_filler<int64_t, ArrayInt64>(
- *this, prop_key(name, Flags::ArrayInt64), to_int64));
+ std::unique_ptr<Filler> f(
+ make_array_filler<TG, int64_t, ArrayInt64>(
+ *this, prop_key<TG>(name, Flags::ArrayInt64), to_int64));
return make_option(std::move(f));
} else if (equal_str(type, "string[]")) {
- std::unique_ptr<Filler> f(make_array_filler<string, ArrayString>(
- *this, prop_key(name, Flags::ArrayString), to_string));
+ std::unique_ptr<Filler> f(
+ make_array_filler<TG, string, ArrayString>(
+ *this, prop_key<TG>(name, Flags::ArrayString), to_string));
return make_option(std::move(f));
} else {
@@ -315,6 +344,20 @@ private:
}
};
+template <>
+PropertyFamily<TypeGroupVertex>::PropertyType::PropertyFamilyKey
+CSVImporter::prop_key<TypeGroupVertex>(const char *name, Flags type)
+{
+ return db.vertex_property_key(name, Type(type));
+}
+
+template <>
+PropertyFamily<TypeGroupEdge>::PropertyType::PropertyFamilyKey
+CSVImporter::prop_key<TypeGroupEdge>(const char *name, Flags type)
+{
+ return db.edge_property_key(name, Type(type));
+}
+
// Imports all -v "vertex_file_path.csv" vertices and -e "edge_file_path.csv"
// edges from specified files. Also defines arguments -d, -ad, -w, -err, -info.
// -d delimiter => sets delimiter for parsing .csv files. Default is ,
diff --git a/src/import/element_skeleton.hpp b/src/import/element_skeleton.hpp
index 9e7b4f3b1..52c005a62 100644
--- a/src/import/element_skeleton.hpp
+++ b/src/import/element_skeleton.hpp
@@ -14,20 +14,36 @@ class ElementSkeleton
{
public:
- Prop(PropertyFamily::PropertyType::PropertyFamilyKey key,
+ Prop(VertexPropertyFamily::PropertyType::PropertyFamilyKey key,
Option<std::shared_ptr<Property>> &&prop)
- : key(key), prop(std::move(prop))
+ : key_v(key), prop(std::move(prop))
{
}
- PropertyFamily::PropertyType::PropertyFamilyKey key;
+ Prop(EdgePropertyFamily::PropertyType::PropertyFamilyKey key,
+ Option<std::shared_ptr<Property>> &&prop)
+ : key_e(key), prop(std::move(prop))
+ {
+ }
+
+ union
+ {
+ VertexPropertyFamily::PropertyType::PropertyFamilyKey key_v;
+ EdgePropertyFamily::PropertyType::PropertyFamilyKey key_e;
+ };
Option<std::shared_ptr<Property>> prop;
};
public:
ElementSkeleton(DbAccessor &db) : db(db){};
- void add_property(PropertyFamily::PropertyType::PropertyFamilyKey key,
+ void add_property(VertexPropertyFamily::PropertyType::PropertyFamilyKey key,
+ std::shared_ptr<Property> &&prop)
+ {
+ properties.push_back(Prop(key, make_option(std::move(prop))));
+ }
+
+ void add_property(EdgePropertyFamily::PropertyType::PropertyFamilyKey key,
std::shared_ptr<Property> &&prop)
{
properties.push_back(Prop(key, make_option(std::move(prop))));
@@ -42,17 +58,17 @@ public:
void set_type(EdgeType const &type) { this->type = make_option(&type); }
- void set_from(Vertex::Accessor &&va)
+ void set_from(VertexAccessor &&va)
{
- from_va = make_option<Vertex::Accessor>(std::move(va));
+ from_va = make_option<VertexAccessor>(std::move(va));
}
- void set_to(Vertex::Accessor &&va)
+ void set_to(VertexAccessor &&va)
{
- to_va = make_option<Vertex::Accessor>(std::move(va));
+ to_va = make_option<VertexAccessor>(std::move(va));
}
- Vertex::Accessor add_vertex()
+ VertexAccessor add_vertex()
{
auto va = db.vertex_insert();
@@ -60,7 +76,11 @@ public:
// std::cout << *l << std::endl;
va.add_label(*l);
}
- add_propreties(va);
+
+ for (auto prop : properties) {
+ assert(prop.prop.is_present());
+ va.set(prop.key_v, prop.prop.take());
+ }
return va;
}
@@ -79,7 +99,11 @@ public:
if (type.is_present()) {
ve.edge_type(*type.get());
}
- add_propreties(ve);
+
+ for (auto prop : properties) {
+ assert(prop.prop.is_present());
+ ve.set(prop.key_e, prop.prop.take());
+ }
return make_option<std::string>();
}
@@ -87,8 +111,8 @@ public:
void clear()
{
el_id = make_option<size_t>();
- to_va = make_option<Vertex::Accessor>();
- from_va = make_option<Vertex::Accessor>();
+ to_va = make_option<VertexAccessor>();
+ from_va = make_option<VertexAccessor>();
type = make_option<EdgeType const *>();
labels.clear();
properties.clear();
@@ -98,20 +122,20 @@ public:
Option<size_t> element_id() { return el_id; }
private:
- template <class A>
- void add_propreties(A &ra)
- {
- for (auto prop : properties) {
- assert(prop.prop.is_present());
- ra.set(prop.key, prop.prop.take());
- }
- }
+ // template <class A>
+ // void add_propreties(A &ra)
+ // {
+ // for (auto prop : properties) {
+ // assert(prop.prop.is_present());
+ // ra.set(prop.key, prop.prop.take());
+ // }
+ // }
DbAccessor &db;
Option<size_t> el_id;
- Option<Vertex::Accessor> to_va;
- Option<Vertex::Accessor> from_va;
+ Option<VertexAccessor> to_va;
+ Option<VertexAccessor> from_va;
Option<EdgeType const *> type;
std::vector<Label const *> labels;
std::vector<Prop> properties;
diff --git a/src/import/fillings/array.hpp b/src/import/fillings/array.hpp
index e8ebc2935..dc9327a2b 100644
--- a/src/import/fillings/array.hpp
+++ b/src/import/fillings/array.hpp
@@ -4,14 +4,15 @@
#include "import/fillings/common.hpp"
#include "import/fillings/filler.hpp"
-template <class T, class A>
+template <class TG, class T, class A>
class ArrayFiller : public Filler
{
public:
- ArrayFiller(BaseImporter &db,
- PropertyFamily::PropertyType::PropertyFamilyKey key,
- T (*f)(const char *))
+ ArrayFiller(
+ BaseImporter &db,
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key,
+ T (*f)(const char *))
: bim(db), key(key), f(f)
{
}
@@ -36,15 +37,16 @@ public:
private:
BaseImporter &bim;
- PropertyFamily::PropertyType::PropertyFamilyKey key;
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key;
vector<char *> sub_str;
T (*f)(const char *);
};
-template <class T, class A>
-auto make_array_filler(BaseImporter &db,
- PropertyFamily::PropertyType::PropertyFamilyKey key,
- T (*f)(const char *))
+template <class TG, class T, class A>
+auto make_array_filler(
+ BaseImporter &db,
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key,
+ T (*f)(const char *))
{
- return new ArrayFiller<T, A>(db, key, f);
+ return new ArrayFiller<TG, T, A>(db, key, f);
}
diff --git a/src/import/fillings/bool.hpp b/src/import/fillings/bool.hpp
index ef68ac63f..2fe9032e9 100644
--- a/src/import/fillings/bool.hpp
+++ b/src/import/fillings/bool.hpp
@@ -6,11 +6,13 @@
#include "storage/model/properties/flags.hpp"
#include "storage/model/properties/property_family.hpp"
+template <class TG>
class BoolFiller : public Filler
{
public:
- BoolFiller(PropertyFamily::PropertyType::PropertyFamilyKey key) : key(key)
+ BoolFiller(typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key)
+ : key(key)
{
}
@@ -26,5 +28,5 @@ public:
}
private:
- PropertyFamily::PropertyType::PropertyFamilyKey key;
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key;
};
diff --git a/src/import/fillings/double.hpp b/src/import/fillings/double.hpp
index 222cdc75f..3eaa1884a 100644
--- a/src/import/fillings/double.hpp
+++ b/src/import/fillings/double.hpp
@@ -6,11 +6,14 @@
#include "storage/model/properties/flags.hpp"
#include "storage/model/properties/property_family.hpp"
+template <class TG>
class DoubleFiller : public Filler
{
public:
- DoubleFiller(PropertyFamily::PropertyType::PropertyFamilyKey key) : key(key)
+ DoubleFiller(
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key)
+ : key(key)
{
}
// Fills skeleton with data from str. Returns error description if
@@ -25,5 +28,5 @@ public:
}
private:
- PropertyFamily::PropertyType::PropertyFamilyKey key;
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key;
};
diff --git a/src/import/fillings/float.hpp b/src/import/fillings/float.hpp
index b5f0c6ca8..e3d6f7511 100644
--- a/src/import/fillings/float.hpp
+++ b/src/import/fillings/float.hpp
@@ -6,11 +6,14 @@
#include "storage/model/properties/flags.hpp"
#include "storage/model/properties/property_family.hpp"
+template <class TG>
class FloatFiller : public Filler
{
public:
- FloatFiller(PropertyFamily::PropertyType::PropertyFamilyKey key) : key(key)
+ FloatFiller(
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key)
+ : key(key)
{
}
// Fills skeleton with data from str. Returns error description if
@@ -25,5 +28,5 @@ public:
}
private:
- PropertyFamily::PropertyType::PropertyFamilyKey key;
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key;
};
diff --git a/src/import/fillings/from.hpp b/src/import/fillings/from.hpp
index 92b9c6b4f..c5569338a 100644
--- a/src/import/fillings/from.hpp
+++ b/src/import/fillings/from.hpp
@@ -18,9 +18,9 @@ public:
{
if (str[0] != '\0') {
auto id = atol(str);
- Option<Vertex::Accessor> const &oav = bim.get_vertex(id);
+ Option<VertexAccessor> const &oav = bim.get_vertex(id);
if (oav.is_present()) {
- data.set_from(Vertex::Accessor(oav.get()));
+ data.set_from(VertexAccessor(oav.get()));
return make_option<std::string>();
} else {
return make_option(
diff --git a/src/import/fillings/id.hpp b/src/import/fillings/id.hpp
index 8b90489d4..11df0231a 100644
--- a/src/import/fillings/id.hpp
+++ b/src/import/fillings/id.hpp
@@ -2,16 +2,20 @@
#include "import/fillings/filler.hpp"
+template <class TG>
class IdFiller : public Filler
{
public:
IdFiller()
- : key(make_option<PropertyFamily::PropertyType::PropertyFamilyKey>())
+ : key(make_option<
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey>())
{
}
- IdFiller(Option<PropertyFamily::PropertyType::PropertyFamilyKey> key)
+ IdFiller(
+ Option<typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey>
+ key)
: key(key)
{
assert(!key.is_present() ||
@@ -34,5 +38,5 @@ public:
}
private:
- Option<PropertyFamily::PropertyType::PropertyFamilyKey> key;
+ Option<typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey> key;
};
diff --git a/src/import/fillings/int32.hpp b/src/import/fillings/int32.hpp
index f06cd2f8d..38d7fa46c 100644
--- a/src/import/fillings/int32.hpp
+++ b/src/import/fillings/int32.hpp
@@ -6,11 +6,14 @@
#include "storage/model/properties/flags.hpp"
#include "storage/model/properties/property_family.hpp"
+template <class TG>
class Int32Filler : public Filler
{
public:
- Int32Filler(PropertyFamily::PropertyType::PropertyFamilyKey key) : key(key)
+ Int32Filler(
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key)
+ : key(key)
{
}
@@ -26,5 +29,5 @@ public:
}
private:
- PropertyFamily::PropertyType::PropertyFamilyKey key;
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key;
};
diff --git a/src/import/fillings/int64.hpp b/src/import/fillings/int64.hpp
index 7859d84fa..897e32368 100644
--- a/src/import/fillings/int64.hpp
+++ b/src/import/fillings/int64.hpp
@@ -6,11 +6,14 @@
#include "storage/model/properties/flags.hpp"
#include "storage/model/properties/property_family.hpp"
+template <class TG>
class Int64Filler : public Filler
{
public:
- Int64Filler(PropertyFamily::PropertyType::PropertyFamilyKey key) : key(key)
+ Int64Filler(
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key)
+ : key(key)
{
}
// Fills skeleton with data from str. Returns error description if
@@ -25,5 +28,5 @@ public:
}
private:
- PropertyFamily::PropertyType::PropertyFamilyKey key;
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key;
};
diff --git a/src/import/fillings/string.hpp b/src/import/fillings/string.hpp
index a665b25b0..8e60da19f 100644
--- a/src/import/fillings/string.hpp
+++ b/src/import/fillings/string.hpp
@@ -6,11 +6,14 @@
#include "storage/model/properties/flags.hpp"
#include "storage/model/properties/property_family.hpp"
+template <class TG>
class StringFiller : public Filler
{
public:
- StringFiller(PropertyFamily::PropertyType::PropertyFamilyKey key) : key(key)
+ StringFiller(
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key)
+ : key(key)
{
}
// Fills skeleton with data from str. Returns error description if
@@ -25,5 +28,5 @@ public:
}
private:
- PropertyFamily::PropertyType::PropertyFamilyKey key;
+ typename PropertyFamily<TG>::PropertyType::PropertyFamilyKey key;
};
diff --git a/src/import/fillings/to.hpp b/src/import/fillings/to.hpp
index 45b8ff067..c07db3484 100644
--- a/src/import/fillings/to.hpp
+++ b/src/import/fillings/to.hpp
@@ -18,9 +18,9 @@ public:
{
if (str[0] != '\0') {
auto id = atol(str);
- Option<Vertex::Accessor> const &oav = bim.get_vertex(id);
+ Option<VertexAccessor> const &oav = bim.get_vertex(id);
if (oav.is_present()) {
- data.set_to(Vertex::Accessor(oav.get()));
+ data.set_to(VertexAccessor(oav.get()));
return make_option<std::string>();
} else {
return make_option(
diff --git a/src/query_engine/util.cpp b/src/query_engine/util.cpp
index 2efcaf5f3..e7f855fbf 100644
--- a/src/query_engine/util.cpp
+++ b/src/query_engine/util.cpp
@@ -1,6 +1,10 @@
#include "query_engine/util.hpp"
-void print_props(const Properties &properties)
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+
+template <class T>
+void print_props(const Properties<T> &properties)
{
StringBuffer buffer;
JsonWriter<StringBuffer> writer(buffer);
@@ -8,16 +12,42 @@ void print_props(const Properties &properties)
cout << buffer.str() << endl;
}
-void cout_properties(const Properties &properties)
+template <class T>
+void cout_properties(const Properties<T> &properties)
{
ConsoleWriter writer;
properties.accept(writer);
cout << "----" << endl;
}
-void cout_property(const prop_key_t &key, const Property &property)
+template <class T>
+void cout_property(
+ const typename PropertyFamily<T>::PropertyType::PropertyFamilyKey &key,
+ const Property &property)
{
ConsoleWriter writer;
- writer.handle(key, property);
+ writer.handle<T>(key, property);
cout << "----" << endl;
}
+
+template void
+print_props<TypeGroupEdge>(const Properties<TypeGroupEdge> &properties);
+
+template void
+print_props<TypeGroupVertex>(const Properties<TypeGroupVertex> &properties);
+
+template void
+cout_properties<TypeGroupEdge>(const Properties<TypeGroupEdge> &properties);
+
+template void
+cout_properties<TypeGroupVertex>(const Properties<TypeGroupVertex> &properties);
+
+template void cout_property<TypeGroupEdge>(
+ const typename PropertyFamily<
+ TypeGroupEdge>::PropertyType::PropertyFamilyKey &key,
+ const Property &property);
+
+template void cout_property<TypeGroupVertex>(
+ const typename PropertyFamily<
+ TypeGroupVertex>::PropertyType::PropertyFamilyKey &key,
+ const Property &property);
diff --git a/src/storage/edge_accessor.cpp b/src/storage/edge_accessor.cpp
index 72f7e0582..a095b79fe 100644
--- a/src/storage/edge_accessor.cpp
+++ b/src/storage/edge_accessor.cpp
@@ -1,22 +1,22 @@
#include "storage/edge_accessor.hpp"
-void Edge::Accessor::edge_type(edge_type_ref_t edge_type)
+void EdgeAccessor::edge_type(edge_type_ref_t edge_type)
{
this->record->data.edge_type = &edge_type.get();
}
-edge_type_ref_t Edge::Accessor::edge_type() const
+edge_type_ref_t EdgeAccessor::edge_type() const
{
runtime_assert(this->record->data.edge_type != nullptr, "EdgeType is null");
return edge_type_ref_t(*this->record->data.edge_type);
}
-Vertex::Accessor Edge::Accessor::from() const
+VertexAccessor EdgeAccessor::from() const
{
- return Vertex::Accessor(this->vlist->from(), this->db);
+ return VertexAccessor(this->vlist->from(), this->db);
}
-Vertex::Accessor Edge::Accessor::to() const
+VertexAccessor EdgeAccessor::to() const
{
- return Vertex::Accessor(this->vlist->to(), this->db);
+ return VertexAccessor(this->vlist->to(), this->db);
}
diff --git a/src/storage/edge_type/edge_type.cpp b/src/storage/edge_type/edge_type.cpp
index 6c0fd0996..bacffee3c 100644
--- a/src/storage/edge_type/edge_type.cpp
+++ b/src/storage/edge_type/edge_type.cpp
@@ -1,9 +1,19 @@
#include "storage/edge_type/edge_type.hpp"
-EdgeType::EdgeType() {}
-EdgeType::EdgeType(const std::string &id) : id(id) {}
-EdgeType::EdgeType(const char *id) : id(std::string(id)) {}
-EdgeType::EdgeType(std::string &&id) : id(std::move(id)) {}
+EdgeType::EdgeType(const std::string &id)
+ : id(id), index(std::unique_ptr<type_index_t>(new type_index_t()))
+{
+}
+EdgeType::EdgeType(const char *id)
+ : id(std::string(id)),
+ index(std::unique_ptr<type_index_t>(new type_index_t()))
+{
+}
+EdgeType::EdgeType(std::string &&id)
+ : id(std::move(id)),
+ index(std::unique_ptr<type_index_t>(new type_index_t()))
+{
+}
bool operator<(const EdgeType &lhs, const EdgeType &rhs)
{
diff --git a/src/storage/edges.cpp b/src/storage/edges.cpp
index b28f1d8b6..e860d8bea 100644
--- a/src/storage/edges.cpp
+++ b/src/storage/edges.cpp
@@ -1,20 +1,21 @@
#include "storage/edges.hpp"
-#include "storage/model/properties/property_family.hpp"
+
+#include "storage/edge_accessor.hpp"
#include "utils/iterator/iterator.hpp"
-Option<const Edge::Accessor> Edges::find(DbTransaction &t, const Id &id)
+Option<const EdgeAccessor> Edges::find(DbTransaction &t, const Id &id)
{
auto edges_accessor = edges.access();
auto edges_iterator = edges_accessor.find(id);
if (edges_iterator == edges_accessor.end())
- return make_option<const Edge::Accessor>();
+ return make_option<const EdgeAccessor>();
- return make_option_const(Edge::Accessor(&edges_iterator->second, t));
+ return make_option_const(EdgeAccessor(&edges_iterator->second, t));
}
-Edge::Accessor Edges::insert(DbTransaction &t, VertexRecord *from,
- VertexRecord *to)
+EdgeAccessor Edges::insert(DbTransaction &t, VertexRecord *from,
+ VertexRecord *to)
{
// get next vertex id
auto next = counter.next(std::memory_order_acquire);
@@ -29,16 +30,18 @@ Edge::Accessor Edges::insert(DbTransaction &t, VertexRecord *from,
// create new vertex
auto inserted_edge_record = result.first;
auto edge = inserted_edge_record->second.insert(t.trans);
+ t.to_update_index<TypeGroupEdge>(&inserted_edge_record->second, edge);
- return Edge::Accessor(edge, &inserted_edge_record->second, t);
+ return EdgeAccessor(edge, &inserted_edge_record->second, t);
}
-PropertyFamily &Edges::property_family_find_or_create(const std::string &name)
+EdgePropertyFamily &
+Edges::property_family_find_or_create(const std::string &name)
{
auto acc = prop_familys.access();
auto it = acc.find(name);
if (it == acc.end()) {
- PropertyFamily *family = new PropertyFamily(name);
+ EdgePropertyFamily *family = new EdgePropertyFamily(name);
auto res = acc.insert(name, family);
if (!res.second) {
delete family;
diff --git a/src/storage/garbage/garbage.cpp b/src/storage/garbage/garbage.cpp
new file mode 100644
index 000000000..4a57bc72c
--- /dev/null
+++ b/src/storage/garbage/garbage.cpp
@@ -0,0 +1,11 @@
+#include "storage/garbage/garbage.hpp"
+
+void Garbage::dispose(tx::Snapshot<Id> &&snapshot, DeleteSensitive *data)
+{
+ // TODO: add to list
+}
+
+void Garbage::clean(tx::Engine &engine)
+{
+ // TODO: iterator throug list and check snapshot
+}
diff --git a/src/storage/indexes/impl/nonunique_unordered_index.cpp b/src/storage/indexes/impl/nonunique_unordered_index.cpp
index 7278d3dc4..9bf7ef37c 100644
--- a/src/storage/indexes/impl/nonunique_unordered_index.cpp
+++ b/src/storage/indexes/impl/nonunique_unordered_index.cpp
@@ -2,14 +2,28 @@
#include "database/db_accessor.hpp"
#include "database/db_transaction.hpp"
+#include "storage/edge_accessor.hpp"
+#include "storage/edge_record.hpp"
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+#include "storage/vertex_accessor.hpp"
+#include "storage/vertex_record.hpp"
#include "utils/iterator/iterator.hpp"
+#include "storage/indexes/index_record.cpp"
+
template <class T, class K>
NonUniqueUnorderedIndex<T, K>::NonUniqueUnorderedIndex()
: IndexBase<T, K>(false, None)
{
}
+template <class T, class K>
+NonUniqueUnorderedIndex<T, K>::NonUniqueUnorderedIndex(tx::Transaction const &t)
+ : IndexBase<T, K>(false, None, t)
+{
+}
+
template <class T, class K>
bool NonUniqueUnorderedIndex<T, K>::insert(IndexRecord<T, K> &&value)
{
@@ -18,7 +32,7 @@ bool NonUniqueUnorderedIndex<T, K>::insert(IndexRecord<T, K> &&value)
}
template <class T, class K>
-std::unique_ptr<IteratorBase<const typename T::Accessor>>
+std::unique_ptr<IteratorBase<const typename T::accessor_t>>
NonUniqueUnorderedIndex<T, K>::for_range(DbAccessor &t, Border<K> from,
Border<K> to)
{
@@ -39,14 +53,14 @@ auto NonUniqueUnorderedIndex<T, K>::for_range_exact(DbAccessor &t_v,
const IndexRecord<T, K> &r = *it;
if (from < r.key && to > r.key &&
r.is_valid(t.db_transaction.trans)) {
- const typename T::Accessor acc = r.access(t.db_transaction);
+ const typename T::accessor_t acc = r.access(t.db_transaction);
it++;
return make_option(std::move(acc));
}
it++;
}
- return Option<const typename T::Accessor>();
+ return Option<const typename T::accessor_t>();
});
}
@@ -56,6 +70,5 @@ void NonUniqueUnorderedIndex<T, K>::clean(DbTransaction &)
// TODO: Actual cleaning
}
-#include "storage/vertex.hpp"
-// #include "utils/singleton.hpp"
-template class NonUniqueUnorderedIndex<Vertex, std::nullptr_t>;
+template class NonUniqueUnorderedIndex<TypeGroupEdge, std::nullptr_t>;
+template class NonUniqueUnorderedIndex<TypeGroupVertex, std::nullptr_t>;
diff --git a/src/storage/indexes/impl/unique_ordered_index.cpp b/src/storage/indexes/impl/unique_ordered_index.cpp
new file mode 100644
index 000000000..62ee11f59
--- /dev/null
+++ b/src/storage/indexes/impl/unique_ordered_index.cpp
@@ -0,0 +1,91 @@
+#include "storage/indexes/impl/unique_ordered_index.hpp"
+
+#include "database/db_accessor.hpp"
+#include "database/db_transaction.hpp"
+#include "storage/edge_accessor.hpp"
+#include "storage/edge_record.hpp"
+#include "storage/edge_type/edge_type.hpp"
+#include "storage/label/label.hpp"
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+#include "storage/vertex_accessor.hpp"
+#include "storage/vertex_record.hpp"
+#include "utils/iterator/iterator.hpp"
+
+#include "storage/indexes/index_record.cpp"
+
+template <class T, class K>
+UniqueOrderedIndex<T, K>::UniqueOrderedIndex(Order order)
+ : IndexBase<T, K>(true, order)
+{
+}
+
+template <class T, class K>
+UniqueOrderedIndex<T, K>::UniqueOrderedIndex(Order order,
+ tx::Transaction const &t)
+ : IndexBase<T, K>(true, order, t)
+{
+}
+
+template <class T, class K>
+bool UniqueOrderedIndex<T, K>::insert(IndexRecord<T, K> &&value)
+{
+ if (this->order == Descending) {
+ value.set_descending();
+ }
+ return set.access().insert(std::move(value)).second;
+}
+
+template <class T, class K>
+std::unique_ptr<IteratorBase<const typename T::accessor_t>>
+UniqueOrderedIndex<T, K>::for_range(DbAccessor &t, Border<K> from, Border<K> to)
+{
+ return std::make_unique<decltype(
+ for_range_exact(t, std::move(from), std::move(to)))>(
+ for_range_exact(t, std::move(from), std::move(to)));
+}
+
+template <class T, class K>
+auto UniqueOrderedIndex<T, K>::for_range_exact(DbAccessor &t_v,
+ Border<K> from_v, Border<K> to_v)
+{
+ auto acc = set.access();
+ auto begin = acc.cbegin();
+ auto end = to_v;
+
+ // Sorted order must be checked
+ if (this->order == Ascending && from_v.key.is_present()) {
+ begin = acc.cfind_or_larger(from_v);
+ } else if (this->order == Descending && to_v.key.is_present()) {
+ begin = acc.cfind_or_larger(to_v);
+ end = from_v;
+ } else {
+ assert(this->order != None);
+ }
+
+ return iter::make_iterator([
+ it = std::move(begin), b_end = std::move(end), t = t_v,
+ hold_acc = std::move(acc)
+ ]() mutable->auto {
+ while (b_end >= it->key) {
+ const IndexRecord<T, K> &r = *it;
+ if (r.is_valid(t.db_transaction.trans)) {
+ const typename T::accessor_t acc = r.access(t.db_transaction);
+ it++;
+ return make_option(std::move(acc));
+ }
+ it++;
+ }
+
+ return Option<const typename T::accessor_t>();
+ });
+}
+
+template <class T, class K>
+void UniqueOrderedIndex<T, K>::clean(DbTransaction &)
+{
+ // TODO: Actual cleaning
+}
+
+template class UniqueOrderedIndex<TypeGroupEdge, std::nullptr_t>;
+template class UniqueOrderedIndex<TypeGroupVertex, std::nullptr_t>;
diff --git a/src/storage/indexes/index_base.cpp b/src/storage/indexes/index_base.cpp
new file mode 100644
index 000000000..b2712a717
--- /dev/null
+++ b/src/storage/indexes/index_base.cpp
@@ -0,0 +1,39 @@
+#include "storage/indexes/index_base.hpp"
+
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+#include "transactions/transaction.hpp"
+
+template <class TG, class K>
+IndexBase<TG, K>::IndexBase(bool unique, Order order)
+ : unique(unique), order(order), created(Id(0)), active(true)
+{
+}
+
+template <class TG, class K>
+IndexBase<TG, K>::IndexBase(bool unique, Order order, const tx::Transaction &t)
+ : unique(unique), order(order), created(t.id)
+{
+}
+
+template <class TG, class K>
+void IndexBase<TG, K>::activate()
+{
+ assert(!can_read());
+ active.store(true);
+}
+
+template <class TG, class K>
+bool IndexBase<TG, K>::can_read()
+{
+ return active.load(std::memory_order_acquire);
+}
+
+template <class TG, class K>
+bool IndexBase<TG, K>::is_obliged_to_insert(const tx::Transaction &t)
+{
+ return t.id >= created;
+}
+
+template class IndexBase<TypeGroupEdge, std::nullptr_t>;
+template class IndexBase<TypeGroupVertex, std::nullptr_t>;
diff --git a/src/storage/indexes/index_holder.cpp b/src/storage/indexes/index_holder.cpp
new file mode 100644
index 000000000..de3e0510e
--- /dev/null
+++ b/src/storage/indexes/index_holder.cpp
@@ -0,0 +1,66 @@
+#include "storage/indexes/index_holder.hpp"
+
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+
+template <class TG, class K>
+IndexBase<TG, K> *npr = (IndexBase<TG, K> *)nullptr;
+
+template <class TG, class K>
+bool IndexHolder<TG, K>::set_index(std::unique_ptr<IndexBase<TG, K>> inx)
+{
+ if (index.compare_exchange_strong(npr<TG, K>, inx.get())) {
+ inx.release();
+ return true;
+ } else {
+ return false;
+ }
+}
+
+template <class TG, class K>
+OptionPtr<IndexBase<TG, K>> IndexHolder<TG, K>::get_read() const
+{
+ auto loaded = index.load(std::memory_order_acquire);
+ if (loaded == nullptr || !loaded->can_read()) {
+ return OptionPtr<IndexBase<TG, K>>();
+ } else {
+ return make_option_ptr(loaded);
+ }
+}
+
+template <class TG, class K>
+OptionPtr<IndexBase<TG, K>>
+IndexHolder<TG, K>::get_write(const tx::Transaction &t) const
+{
+ auto loaded = index.load(std::memory_order_acquire);
+ if (loaded == nullptr || !loaded->is_obliged_to_insert(t)) {
+ return OptionPtr<IndexBase<TG, K>>();
+ } else {
+ return make_option_ptr(loaded);
+ }
+}
+
+template <class TG, class K>
+Option<std::unique_ptr<IndexBase<TG, K>>>
+IndexHolder<TG, K>::remove_index(IndexBase<TG, K> *expected)
+{
+ if (index.compare_exchange_strong(expected, nullptr)) {
+ return make_option(std::unique_ptr<IndexBase<TG, K>>(expected));
+ } else {
+ return make_option(std::unique_ptr<IndexBase<TG, K>>());
+ }
+}
+
+template <class TG, class K>
+Option<std::unique_ptr<IndexBase<TG, K>>> IndexHolder<TG, K>::remove_index()
+{
+ auto removed = index.exchange(nullptr);
+ if (removed == nullptr) {
+ return make_option<std::unique_ptr<IndexBase<TG, K>>>();
+ } else {
+ return make_option(std::unique_ptr<IndexBase<TG, K>>(removed));
+ }
+}
+
+template class IndexHolder<TypeGroupEdge, std::nullptr_t>;
+template class IndexHolder<TypeGroupVertex, std::nullptr_t>;
diff --git a/src/storage/indexes/index_record.cpp b/src/storage/indexes/index_record.cpp
new file mode 100644
index 000000000..c3e42142c
--- /dev/null
+++ b/src/storage/indexes/index_record.cpp
@@ -0,0 +1,46 @@
+#include "storage/indexes/index_record.hpp"
+
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+
+template <class TG, class K>
+IndexRecord<TG, K>::IndexRecord(K key, typename TG::record_t *record,
+ typename TG::vlist_t *vlist)
+ : key(std::move(key)), record(record), vlist(vlist)
+{
+ assert(record != nullptr);
+ assert(vlist != nullptr);
+}
+
+template <class TG, class K>
+void IndexRecord<TG, K>::set_descending()
+{
+ descending = true;
+}
+
+template <class TG, class K>
+bool IndexRecord<TG, K>::empty() const
+{
+ return record == nullptr;
+}
+
+template <class TG, class K>
+bool IndexRecord<TG, K>::is_valid(tx::Transaction &t) const
+{
+ assert(!empty());
+ return record == vlist->find(t);
+}
+
+template <class TG, class K>
+const auto IndexRecord<TG, K>::access(DbTransaction &db) const
+{
+ return typename TG::accessor_t(record, vlist, db);
+}
+
+#include "storage/edge_accessor.hpp"
+#include "storage/edge_record.hpp"
+#include "storage/vertex_accessor.hpp"
+#include "storage/vertex_record.hpp"
+
+template class IndexRecord<TypeGroupVertex, std::nullptr_t>;
+template class IndexRecord<TypeGroupEdge, std::nullptr_t>;
diff --git a/src/storage/indexes/index_update.cpp b/src/storage/indexes/index_update.cpp
new file mode 100644
index 000000000..ca7fe1028
--- /dev/null
+++ b/src/storage/indexes/index_update.cpp
@@ -0,0 +1,14 @@
+#include "storage/indexes/index_update.hpp"
+
+template <>
+IndexUpdate make_index_update(EdgeRecord *vlist, Edge *record)
+{
+ return IndexUpdate{IndexUpdate::EDGE, .e = IndexUpdateEdge{vlist, record}};
+}
+
+template <>
+IndexUpdate make_index_update(VertexRecord *vlist, Vertex *record)
+{
+ return IndexUpdate{IndexUpdate::VERTEX,
+ .v = IndexUpdateVertex{vlist, record}};
+}
diff --git a/src/storage/model/properties/properties.cpp b/src/storage/model/properties/properties.cpp
index 76c1d2408..61b8a9ed5 100644
--- a/src/storage/model/properties/properties.cpp
+++ b/src/storage/model/properties/properties.cpp
@@ -4,7 +4,11 @@
#include "storage/model/properties/property_family.hpp"
#include "utils/option.hpp"
-const Property &Properties::at(PropertyFamily &fam) const
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+
+template <class TG>
+const Property &Properties<TG>::at(PropertyFamily<TG> &fam) const
{
// It doesn't matter whit which type
// find is called, thats why getNull
@@ -18,7 +22,8 @@ const Property &Properties::at(PropertyFamily &fam) const
return *it->second.get();
}
-const Property &Properties::at(prop_key_t &key) const
+template <class TG>
+const Property &Properties<TG>::at(prop_key_t &key) const
{
auto it = props.find(key);
@@ -28,8 +33,9 @@ const Property &Properties::at(prop_key_t &key) const
return *it->second.get();
}
+template <class TG>
template <class T>
-auto Properties::at(type_key_t<T> &key) const
+auto Properties<TG>::at(type_key_t<T> &key) const
{
auto f_key = key.family_key();
auto it = props.find(f_key);
@@ -41,8 +47,9 @@ auto Properties::at(type_key_t<T> &key) const
return make_option(&(it->second.get()->template as<T>().value_ref()));
}
+template <class TG>
template <class T, class... Args>
-void Properties::set(type_key_t<T> &key, Args &&... args)
+void Properties<TG>::set(type_key_t<T> &key, Args &&... args)
{
auto value = std::make_shared<T>(std::forward<Args>(args)...);
@@ -59,7 +66,8 @@ void Properties::set(type_key_t<T> &key, Args &&... args)
}
}
-void Properties::set(prop_key_t &key, Property::sptr value)
+template <class TG>
+void Properties<TG>::set(prop_key_t &key, Property::sptr value)
{
// TODO: There is uneccesary copying of value here.
auto result = props.insert(make_pair(key, value));
@@ -72,9 +80,14 @@ void Properties::set(prop_key_t &key, Property::sptr value)
}
}
-void Properties::clear(prop_key_t &key) { props.erase(key); }
+template <class TG>
+void Properties<TG>::clear(prop_key_t &key)
+{
+ props.erase(key);
+}
-void Properties::clear(PropertyFamily &fam)
+template <class TG>
+void Properties<TG>::clear(PropertyFamily<TG> &fam)
{
// It doesn't matter whit which type
// find is called, thats why getNull
@@ -84,9 +97,6 @@ void Properties::clear(PropertyFamily &fam)
props.erase(key);
}
-template <>
-inline void Properties::set<Null>(type_key_t<Null> &key)
-{
- auto fk = key.family_key();
- clear(fk);
-}
+template class Properties<TypeGroupEdge>;
+
+template class Properties<TypeGroupVertex>;
diff --git a/src/storage/model/properties/property_family.cpp b/src/storage/model/properties/property_family.cpp
index 58c9d8869..fe16a4a59 100644
--- a/src/storage/model/properties/property_family.cpp
+++ b/src/storage/model/properties/property_family.cpp
@@ -1,19 +1,31 @@
#include "storage/model/properties/property_family.hpp"
-PropertyFamily::PropertyFamily(std::string const &name_v)
+#include "storage/type_group_edge.hpp"
+#include "storage/type_group_vertex.hpp"
+
+template <class T>
+PropertyFamily<T>::PropertyFamily(std::string const &name_v)
: name_v(std::forward<const std::string>(name_v))
{
null_type = &get(Flags::Null);
}
-PropertyFamily::PropertyFamily(std::string &&name_v) : name_v(std::move(name_v))
+
+template <class T>
+PropertyFamily<T>::PropertyFamily(std::string &&name_v)
+ : name_v(std::move(name_v))
{
null_type = &get(Flags::Null);
}
-std::string const &PropertyFamily::name() const { return name_v; }
+template <class T>
+std::string const &PropertyFamily<T>::name() const
+{
+ return name_v;
+}
// Returns type if it exists otherwise creates it.
-PropertyFamily::PropertyType &PropertyFamily::get(Type type)
+template <class T>
+typename PropertyFamily<T>::PropertyType &PropertyFamily<T>::get(Type type)
{
auto acc = types.access();
auto it = acc.find(type);
@@ -26,16 +38,25 @@ PropertyFamily::PropertyType &PropertyFamily::get(Type type)
return *(it->second);
}
-PropertyFamily::PropertyType::PropertyType(PropertyFamily &family, Type type)
+template <class T>
+PropertyFamily<T>::PropertyType::PropertyType(PropertyFamily &family, Type type)
: family(family), type(std::move(type))
{
}
-bool PropertyFamily::PropertyType::is(Type &t) const { return type == t; }
+template <class T>
+bool PropertyFamily<T>::PropertyType::is(Type &t) const
+{
+ return type == t;
+}
// Returns key ordered on POINTERS to PropertyFamily
-PropertyFamily::PropertyType::PropertyFamilyKey
-PropertyFamily::PropertyType::family_key()
+template <class T>
+typename PropertyFamily<T>::PropertyType::PropertyFamilyKey
+PropertyFamily<T>::PropertyType::family_key()
{
return PropertyFamilyKey(*this);
}
+
+template class PropertyFamily<TypeGroupEdge>;
+template class PropertyFamily<TypeGroupVertex>;
diff --git a/src/storage/record_accessor.cpp b/src/storage/record_accessor.cpp
index 21198de4c..422b1b4db 100644
--- a/src/storage/record_accessor.cpp
+++ b/src/storage/record_accessor.cpp
@@ -1,8 +1,8 @@
#include "storage/record_accessor.hpp"
-template <class T, class Derived, class vlist_t>
-template <class V>
-auto RecordAccessor<T, Derived, vlist_t>::at(type_key_t<V> &key) const
-{
- return properties().template at<V>(key);
-}
+// template <class T, class Derived>
+// template <class V>
+// auto RecordAccessor<T, Derived>::at(type_key_t<T, V> &key) const
+// {
+// return properties().template at<V>(key);
+// }
diff --git a/src/storage/vertex_accessor.cpp b/src/storage/vertex_accessor.cpp
index e171aea10..0aae09eb7 100644
--- a/src/storage/vertex_accessor.cpp
+++ b/src/storage/vertex_accessor.cpp
@@ -1,64 +1,61 @@
-#include "database/db.hpp"
#include "storage/vertex_accessor.hpp"
+
+#include "database/db.hpp"
+#include "storage/vertex_record.hpp"
#include "storage/vertices.hpp"
#include "utils/iterator/iterator.hpp"
-size_t Vertex::Accessor::out_degree() const
+size_t VertexAccessor::out_degree() const
{
return this->record->data.out.degree();
}
-size_t Vertex::Accessor::in_degree() const
+size_t VertexAccessor::in_degree() const
{
return this->record->data.in.degree();
}
-size_t Vertex::Accessor::degree() const { return in_degree() + out_degree(); }
+size_t VertexAccessor::degree() const { return in_degree() + out_degree(); }
-bool Vertex::Accessor::add_label(const Label &label)
+bool VertexAccessor::add_label(const Label &label)
{
// update vertex
- if (this->record->data.labels.add(label)) {
- label.index->insert(create_index_record());
- return true;
- }
- return false;
+ return this->record->data.labels.add(label);
}
-bool Vertex::Accessor::remove_label(const Label &label)
+bool VertexAccessor::remove_label(const Label &label)
{
// update vertex
return this->record->data.labels.remove(label);
}
-bool Vertex::Accessor::has_label(const Label &label) const
+bool VertexAccessor::has_label(const Label &label) const
{
return this->record->data.labels.has(label);
}
-const std::set<label_ref_t> &Vertex::Accessor::labels() const
+const std::set<label_ref_t> &VertexAccessor::labels() const
{
return this->record->data.labels();
}
// Returns unfilled accessors
-auto Vertex::Accessor::out() const
+auto VertexAccessor::out() const
{
DbTransaction &t = this->db;
- return iter::make_map(
- iter::make_iter_ref(record->data.out),
- [&](auto e) -> auto { return Edge::Accessor(*e, t); });
+ return iter::make_map(iter::make_iter_ref(record->data.out),
+ [&](auto e) -> auto { return EdgeAccessor(*e, t); });
}
// Returns unfilled accessors
-auto Vertex::Accessor::in() const
+auto VertexAccessor::in() const
{
DbTransaction &t = this->db;
return iter::make_map(iter::make_iter_ref(record->data.in),
- [&](auto e) -> auto { return Edge::Accessor(e, t); });
+ [&](auto e) -> auto { return EdgeAccessor(e, t); });
}
-bool Vertex::Accessor::in_contains(Vertex::Accessor const &other) const
+bool VertexAccessor::in_contains(VertexAccessor const &other) const
{
return record->data.in.contains(other.vlist);
}
diff --git a/src/storage/vertices.cpp b/src/storage/vertices.cpp
index 5b6e46040..31be412cc 100644
--- a/src/storage/vertices.cpp
+++ b/src/storage/vertices.cpp
@@ -1,20 +1,22 @@
#include "storage/vertices.hpp"
+
+#include "storage/vertex_accessor.hpp"
#include "utils/iterator/iterator.hpp"
Vertices::vertices_t::Accessor Vertices::access() { return vertices.access(); }
-Option<const Vertex::Accessor> Vertices::find(DbTransaction &t, const Id &id)
+Option<const VertexAccessor> Vertices::find(DbTransaction &t, const Id &id)
{
auto vertices_accessor = vertices.access();
auto vertices_iterator = vertices_accessor.find(id);
if (vertices_iterator == vertices_accessor.end())
- return make_option<const Vertex::Accessor>();
+ return make_option<const VertexAccessor>();
- return make_option_const(Vertex::Accessor(&vertices_iterator->second, t));
+ return make_option_const(VertexAccessor(&vertices_iterator->second, t));
}
-Vertex::Accessor Vertices::insert(DbTransaction &t)
+VertexAccessor Vertices::insert(DbTransaction &t)
{
// get next vertex id
auto next = counter.next();
@@ -30,17 +32,19 @@ Vertex::Accessor Vertices::insert(DbTransaction &t)
// create new vertex
auto inserted_vertex_record = result.first;
auto vertex = inserted_vertex_record->second.insert(t.trans);
+ t.to_update_index<TypeGroupVertex>(&inserted_vertex_record->second, vertex);
- return Vertex::Accessor(vertex, &inserted_vertex_record->second, t);
+ return VertexAccessor(vertex, &inserted_vertex_record->second, t);
}
-PropertyFamily &
+VertexPropertyFamily &
Vertices::property_family_find_or_create(const std::string &name)
{
auto acc = prop_familys.access();
auto it = acc.find(name);
if (it == acc.end()) {
- auto family = std::unique_ptr<PropertyFamily>(new PropertyFamily(name));
+ auto family = std::unique_ptr<VertexPropertyFamily>(
+ new VertexPropertyFamily(name));
auto res = acc.insert(name, std::move(family));
it = res.first;
}
diff --git a/src/transactions/transaction.cpp b/src/transactions/transaction.cpp
index 402c0c519..aab629276 100644
--- a/src/transactions/transaction.cpp
+++ b/src/transactions/transaction.cpp
@@ -1,5 +1,9 @@
#include "transactions/transaction.hpp"
+#include <chrono> // std::chrono::seconds
+
+#include <thread> // std::this_thread::sleep_for
+
#include "transactions/engine.hpp"
namespace tx
@@ -11,10 +15,25 @@ Transaction::Transaction(const Id &id, const Snapshot<Id> &snapshot,
{
}
+void Transaction::wait_for_active()
+{
+ while (snapshot.size() > 0) {
+ auto id = snapshot.back();
+ while (engine.clog.fetch_info(id).is_active()) {
+ std::this_thread::sleep_for(std::chrono::microseconds(100));
+ }
+ snapshot.remove(id);
+ }
+}
+
+bool Transaction::is_active(const Id &id) const
+{
+ return snapshot.is_active(id);
+}
+
void Transaction::take_lock(RecordLock &lock) { locks.take(&lock, id); }
void Transaction::commit() { engine.commit(*this); }
void Transaction::abort() { engine.abort(*this); }
-
}