tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Allocate Cursor through utils::MemoryResource

Browse Source 
Reviewers: mtomic, llugovic, mferencevic

Reviewed By: llugovic

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D2026
This commit is contained in:
Teon Banek 2019-05-09 14:21:23 +02:00
parent 2909ef63d2
commit 7a586b3686
7 changed files with 228 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/distributed/produce_rpc_server.hpp
View File

@ -68,7 +68,7 @@ class ProduceRpcServer {
// execution_memory_ is unique_ptr because we are passing the address to
// cursor_, and we want to preserve the pointer in case we get moved.
std::unique_ptr<utils::MonotonicBufferResource> execution_memory_;
std::unique_ptr<query::plan::Cursor> cursor_;
query::plan::UniqueCursorPtr cursor_;
/// Pulls and returns a single result from the cursor.
std::pair<std::vector<query::TypedValue>, PullState> PullOneFromCursor();

48
src/query/distributed/plan/ops.cpp
View File

@ -488,7 +488,7 @@ class PullRemoteCursor : public Cursor {
private:
const PullRemote &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
tx::CommandId command_id_;
RemotePuller remote_puller_;
int last_pulled_worker_id_index_ = 0;
@ -566,8 +566,8 @@ class SynchronizeCursor : public Cursor {
distributed::PullRpcClients *pull_clients_{nullptr};
distributed::UpdatesRpcClients *updates_clients_{nullptr};
distributed::UpdatesRpcServer *updates_server_{nullptr};
const std::unique_ptr<Cursor> input_cursor_;
const std::unique_ptr<Cursor> pull_remote_cursor_;
const UniqueCursorPtr input_cursor_;
const UniqueCursorPtr pull_remote_cursor_;
bool initial_pull_done_{false};
std::vector<std::vector<TypedValue>> local_frames_;
tx::CommandId command_id_;
@ -810,7 +810,7 @@ class PullRemoteOrderByCursor : public Cursor {
};
const PullRemoteOrderBy &self_;
std::unique_ptr<Cursor> input_;
UniqueCursorPtr input_;
tx::CommandId command_id_;
RemotePuller remote_puller_;
std::vector<MergeResultItem> merge_;
@ -1041,7 +1041,7 @@ class DistributedExpandCursor : public query::plan::Cursor {
std::vector<TypedValue> frame_elems;
};
std::unique_ptr<query::plan::Cursor> input_cursor_;
UniqueCursorPtr input_cursor_;
const DistributedExpand *self_{nullptr};
// The iterable over edges and the current edge iterator are referenced via
// optional because they can not be initialized in the constructor of
@ -1223,7 +1223,7 @@ class DistributedExpandBfsCursor : public query::plan::Cursor {
const DistributedExpandBfs &self_;
database::GraphDbAccessor &db_;
distributed::BfsRpcClients *bfs_subcursor_clients_{nullptr};
std::unique_ptr<query::plan::Cursor> input_cursor_;
UniqueCursorPtr input_cursor_;
// Depth bounds. Calculated on each pull from the input, the initial value
// is irrelevant.
@ -1318,7 +1318,7 @@ class DistributedCreateNodeCursor : public query::plan::Cursor {
void Reset() override { input_cursor_->Reset(); }
private:
std::unique_ptr<query::plan::Cursor> input_cursor_;
UniqueCursorPtr input_cursor_;
database::GraphDb *db_{nullptr};
NodeCreationInfo node_info_;
bool on_random_worker_{false};
@ -1403,46 +1403,46 @@ class DistributedCreateExpandCursor : public query::plan::Cursor {
}
private:
std::unique_ptr<query::plan::Cursor> input_cursor_;
UniqueCursorPtr input_cursor_;
const DistributedCreateExpand *self_{nullptr};
database::GraphDb *db_{nullptr};
};
} // namespace
std::unique_ptr<Cursor> PullRemote::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<PullRemoteCursor>(*this, db, mem);
UniqueCursorPtr PullRemote::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<PullRemoteCursor>(mem, *this, db, mem);
}
std::unique_ptr<Cursor> Synchronize::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<SynchronizeCursor>(*this, db, mem);
UniqueCursorPtr Synchronize::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<SynchronizeCursor>(mem, *this, db, mem);
}
std::unique_ptr<Cursor> PullRemoteOrderBy::MakeCursor(
UniqueCursorPtr PullRemoteOrderBy::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<PullRemoteOrderByCursor>(*this, db, mem);
return MakeUniqueCursorPtr<PullRemoteOrderByCursor>(mem, *this, db, mem);
}
std::unique_ptr<Cursor> DistributedExpand::MakeCursor(
UniqueCursorPtr DistributedExpand::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<DistributedExpandCursor>(this, db, mem);
return MakeUniqueCursorPtr<DistributedExpandCursor>(mem, this, db, mem);
}
std::unique_ptr<Cursor> DistributedExpandBfs::MakeCursor(
UniqueCursorPtr DistributedExpandBfs::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<DistributedExpandBfsCursor>(*this, db, mem);
return MakeUniqueCursorPtr<DistributedExpandBfsCursor>(mem, *this, db, mem);
}
std::unique_ptr<Cursor> DistributedCreateNode::MakeCursor(
UniqueCursorPtr DistributedCreateNode::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<DistributedCreateNodeCursor>(this, db, mem);
return MakeUniqueCursorPtr<DistributedCreateNodeCursor>(mem, this, db, mem);
}
std::unique_ptr<Cursor> DistributedCreateExpand::MakeCursor(
UniqueCursorPtr DistributedCreateExpand::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<DistributedCreateExpandCursor>(this, db, mem);
return MakeUniqueCursorPtr<DistributedCreateExpandCursor>(mem, this, db, mem);
}
} // namespace query::plan

14
src/query/distributed/plan/ops.lcp
View File

@ -68,7 +68,7 @@ time on data transfer. It gives no guarantees on result order.")
const std::vector<Symbol> &symbols)
: input_(input), plan_id_(plan_id), symbols_(symbols) {}
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> OutputSymbols(const SymbolTable &) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -138,7 +138,7 @@ Logic of the synchronize operator is:
pull_remote_(pull_remote),
advance_command_(advance_command) {}
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -179,7 +179,7 @@ by having only one result from each worker.")
const std::shared_ptr<LogicalOperator> &input, int64_t plan_id,
const std::vector<SortItem> &order_by, const std::vector<Symbol> &symbols);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -216,7 +216,7 @@ by having only one result from each worker.")
Symbol input_symbol, const ExpandCommon &common);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -266,7 +266,7 @@ by having only one result from each worker.")
const ExpansionLambda &filter_lambda);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -301,7 +301,7 @@ by having only one result from each worker.")
const NodeCreationInfo &node_info, bool on_random_worker);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -347,7 +347,7 @@ by having only one result from each worker.")
const std::shared_ptr<LogicalOperator> &input,
Symbol input_symbol, bool existing_node);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;

2
src/query/interpreter.hpp
View File

@ -182,7 +182,7 @@ class Interpreter {
// execution_memory_ is unique_ptr because we are passing the address to
// cursor_, and we want to preserve the pointer in case we get moved.
std::unique_ptr<utils::MonotonicBufferResource> execution_memory_;
std::unique_ptr<query::plan::Cursor> cursor_;
query::plan::UniqueCursorPtr cursor_;
Frame frame_;
std::vector<Symbol> output_symbols_;

219
src/query/plan/operator.cpp
View File

@ -92,9 +92,9 @@ bool Once::OnceCursor::Pull(Frame &, ExecutionContext &context) {
return false;
}
std::unique_ptr<Cursor> Once::MakeCursor(database::GraphDbAccessor *,
utils::MemoryResource *) const {
return std::make_unique<OnceCursor>();
UniqueCursorPtr Once::MakeCursor(database::GraphDbAccessor *,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<OnceCursor>(mem);
}
WITHOUT_SINGLE_INPUT(Once);
@ -128,9 +128,9 @@ VertexAccessor &CreateLocalVertex(const NodeCreationInfo &node_info,
ACCEPT_WITH_INPUT(CreateNode)
std::unique_ptr<Cursor> CreateNode::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<CreateNodeCursor>(*this, db, mem);
UniqueCursorPtr CreateNode::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<CreateNodeCursor>(mem, *this, db, mem);
}
std::vector<Symbol> CreateNode::ModifiedSymbols(
@ -173,9 +173,9 @@ CreateExpand::CreateExpand(const NodeCreationInfo &node_info,
ACCEPT_WITH_INPUT(CreateExpand)
std::unique_ptr<Cursor> CreateExpand::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<CreateExpandCursor>(*this, db, mem);
UniqueCursorPtr CreateExpand::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<CreateExpandCursor>(mem, *this, db, mem);
}
std::vector<Symbol> CreateExpand::ModifiedSymbols(
@ -261,8 +261,7 @@ void CreateExpand::CreateExpandCursor::CreateEdge(
template <class TVerticesFun>
class ScanAllCursor : public Cursor {
public:
explicit ScanAllCursor(Symbol output_symbol,
std::unique_ptr<Cursor> &&input_cursor,
explicit ScanAllCursor(Symbol output_symbol, UniqueCursorPtr &&input_cursor,
TVerticesFun &&get_vertices,
database::GraphDbAccessor &db)
: output_symbol_(output_symbol),
@ -302,7 +301,7 @@ class ScanAllCursor : public Cursor {
private:
const Symbol output_symbol_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
TVerticesFun get_vertices_;
std::optional<typename std::result_of<TVerticesFun(
Frame &, ExecutionContext &)>::type::value_type>
@ -319,13 +318,14 @@ ScanAll::ScanAll(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(ScanAll)
std::unique_ptr<Cursor> ScanAll::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
UniqueCursorPtr ScanAll::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
auto vertices = [this, db](Frame &, ExecutionContext &) {
return std::make_optional(db->Vertices(graph_view_ == GraphView::NEW));
};
return std::make_unique<ScanAllCursor<decltype(vertices)>>(
output_symbol_, input_->MakeCursor(db, mem), std::move(vertices), *db);
return MakeUniqueCursorPtr<ScanAllCursor<decltype(vertices)>>(
mem, output_symbol_, input_->MakeCursor(db, mem), std::move(vertices),
*db);
}
std::vector<Symbol> ScanAll::ModifiedSymbols(const SymbolTable &table) const {
@ -341,14 +341,15 @@ ScanAllByLabel::ScanAllByLabel(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(ScanAllByLabel)
std::unique_ptr<Cursor> ScanAllByLabel::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
UniqueCursorPtr ScanAllByLabel::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
auto vertices = [this, db](Frame &, ExecutionContext &) {
return std::make_optional(
db->Vertices(label_, graph_view_ == GraphView::NEW));
};
return std::make_unique<ScanAllCursor<decltype(vertices)>>(
output_symbol_, input_->MakeCursor(db, mem), std::move(vertices), *db);
return MakeUniqueCursorPtr<ScanAllCursor<decltype(vertices)>>(
mem, output_symbol_, input_->MakeCursor(db, mem), std::move(vertices),
*db);
}
ScanAllByLabelPropertyRange::ScanAllByLabelPropertyRange(
@ -367,7 +368,7 @@ ScanAllByLabelPropertyRange::ScanAllByLabelPropertyRange(
ACCEPT_WITH_INPUT(ScanAllByLabelPropertyRange)
std::unique_ptr<Cursor> ScanAllByLabelPropertyRange::MakeCursor(
UniqueCursorPtr ScanAllByLabelPropertyRange::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
auto vertices = [this, db](Frame &frame, ExecutionContext &context)
-> std::optional<decltype(
@ -398,8 +399,9 @@ std::unique_ptr<Cursor> ScanAllByLabelPropertyRange::MakeCursor(
maybe_upper,
graph_view_ == GraphView::NEW));
};
return std::make_unique<ScanAllCursor<decltype(vertices)>>(
output_symbol_, input_->MakeCursor(db, mem), std::move(vertices), *db);
return MakeUniqueCursorPtr<ScanAllCursor<decltype(vertices)>>(
mem, output_symbol_, input_->MakeCursor(db, mem), std::move(vertices),
*db);
}
ScanAllByLabelPropertyValue::ScanAllByLabelPropertyValue(
@ -417,7 +419,7 @@ ScanAllByLabelPropertyValue::ScanAllByLabelPropertyValue(
ACCEPT_WITH_INPUT(ScanAllByLabelPropertyValue)
std::unique_ptr<Cursor> ScanAllByLabelPropertyValue::MakeCursor(
UniqueCursorPtr ScanAllByLabelPropertyValue::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
auto vertices = [this, db](Frame &frame, ExecutionContext &context)
-> std::optional<decltype(
@ -435,8 +437,9 @@ std::unique_ptr<Cursor> ScanAllByLabelPropertyValue::MakeCursor(
PropertyValue(value),
graph_view_ == GraphView::NEW));
};
return std::make_unique<ScanAllCursor<decltype(vertices)>>(
output_symbol_, input_->MakeCursor(db, mem), std::move(vertices), *db);
return MakeUniqueCursorPtr<ScanAllCursor<decltype(vertices)>>(
mem, output_symbol_, input_->MakeCursor(db, mem), std::move(vertices),
*db);
}
namespace {
@ -461,9 +464,9 @@ Expand::Expand(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Expand)
std::unique_ptr<Cursor> Expand::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<ExpandCursor>(*this, db, mem);
UniqueCursorPtr Expand::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<ExpandCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Expand::ModifiedSymbols(const SymbolTable &table) const {
@ -728,7 +731,7 @@ class ExpandVariableCursor : public Cursor {
private:
const ExpandVariable &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
// bounds. in the cursor they are not optional but set to
// default values if missing in the ExpandVariable operator
// initialize to arbitrary values, they should only be used
@ -975,7 +978,7 @@ class STShortestPathCursor : public query::plan::Cursor {
private:
const ExpandVariable &self_;
std::unique_ptr<query::plan::Cursor> input_cursor_;
UniqueCursorPtr input_cursor_;
using VertexEdgeMapT =
std::unordered_map<VertexAccessor, std::optional<EdgeAccessor>>;
@ -1296,7 +1299,7 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
private:
const ExpandVariable &self_;
const std::unique_ptr<query::plan::Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
// Depth bounds. Calculated on each pull from the input, the initial value
// is irrelevant.
@ -1506,7 +1509,7 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
private:
const ExpandVariable &self_;
const std::unique_ptr<query::plan::Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
// Upper bound on the path length.
int64_t upper_bound_{-1};
@ -1553,19 +1556,21 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
}
};
std::unique_ptr<Cursor> ExpandVariable::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
UniqueCursorPtr ExpandVariable::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
switch (type_) {
case EdgeAtom::Type::BREADTH_FIRST:
if (common_.existing_node) {
return std::make_unique<STShortestPathCursor>(*this, db, mem);
return MakeUniqueCursorPtr<STShortestPathCursor>(mem, *this, db, mem);
} else {
return std::make_unique<SingleSourceShortestPathCursor>(*this, db, mem);
return MakeUniqueCursorPtr<SingleSourceShortestPathCursor>(mem, *this,
db, mem);
}
case EdgeAtom::Type::DEPTH_FIRST:
return std::make_unique<ExpandVariableCursor>(*this, db, mem);
return MakeUniqueCursorPtr<ExpandVariableCursor>(mem, *this, db, mem);
case EdgeAtom::Type::WEIGHTED_SHORTEST_PATH:
return std::make_unique<ExpandWeightedShortestPathCursor>(*this, db, mem);
return MakeUniqueCursorPtr<ExpandWeightedShortestPathCursor>(mem, *this,
db, mem);
case EdgeAtom::Type::SINGLE:
LOG(FATAL)
<< "ExpandVariable should not be planned for a single expansion!";
@ -1653,14 +1658,14 @@ class ConstructNamedPathCursor : public Cursor {
private:
const ConstructNamedPath self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
ACCEPT_WITH_INPUT(ConstructNamedPath)
std::unique_ptr<Cursor> ConstructNamedPath::MakeCursor(
UniqueCursorPtr ConstructNamedPath::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<ConstructNamedPathCursor>(*this, db, mem);
return MakeUniqueCursorPtr<ConstructNamedPathCursor>(mem, *this, db, mem);
}
std::vector<Symbol> ConstructNamedPath::ModifiedSymbols(
@ -1677,9 +1682,9 @@ Filter::Filter(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Filter)
std::unique_ptr<Cursor> Filter::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<FilterCursor>(*this, db, mem);
UniqueCursorPtr Filter::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<FilterCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Filter::ModifiedSymbols(const SymbolTable &table) const {
@ -1716,9 +1721,9 @@ Produce::Produce(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Produce)
std::unique_ptr<Cursor> Produce::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<ProduceCursor>(*this, db, mem);
UniqueCursorPtr Produce::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<ProduceCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Produce::OutputSymbols(
@ -1765,9 +1770,9 @@ Delete::Delete(const std::shared_ptr<LogicalOperator> &input_,
ACCEPT_WITH_INPUT(Delete)
std::unique_ptr<Cursor> Delete::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<DeleteCursor>(*this, db, mem);
UniqueCursorPtr Delete::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<DeleteCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Delete::ModifiedSymbols(const SymbolTable &table) const {
@ -1846,9 +1851,9 @@ SetProperty::SetProperty(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(SetProperty)
std::unique_ptr<Cursor> SetProperty::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<SetPropertyCursor>(*this, db, mem);
UniqueCursorPtr SetProperty::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<SetPropertyCursor>(mem, *this, db, mem);
}
std::vector<Symbol> SetProperty::ModifiedSymbols(
@ -1907,9 +1912,9 @@ SetProperties::SetProperties(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(SetProperties)
std::unique_ptr<Cursor> SetProperties::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<SetPropertiesCursor>(*this, db, mem);
UniqueCursorPtr SetProperties::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<SetPropertiesCursor>(mem, *this, db, mem);
}
std::vector<Symbol> SetProperties::ModifiedSymbols(
@ -2014,9 +2019,9 @@ SetLabels::SetLabels(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(SetLabels)
std::unique_ptr<Cursor> SetLabels::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<SetLabelsCursor>(*this, db, mem);
UniqueCursorPtr SetLabels::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<SetLabelsCursor>(mem, *this, db, mem);
}
std::vector<Symbol> SetLabels::ModifiedSymbols(const SymbolTable &table) const {
@ -2058,9 +2063,9 @@ RemoveProperty::RemoveProperty(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(RemoveProperty)
std::unique_ptr<Cursor> RemoveProperty::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<RemovePropertyCursor>(*this, db, mem);
UniqueCursorPtr RemoveProperty::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<RemovePropertyCursor>(mem, *this, db, mem);
}
std::vector<Symbol> RemoveProperty::ModifiedSymbols(
@ -2125,9 +2130,9 @@ RemoveLabels::RemoveLabels(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(RemoveLabels)
std::unique_ptr<Cursor> RemoveLabels::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<RemoveLabelsCursor>(*this, db, mem);
UniqueCursorPtr RemoveLabels::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<RemoveLabelsCursor>(mem, *this, db, mem);
}
std::vector<Symbol> RemoveLabels::ModifiedSymbols(
@ -2174,9 +2179,9 @@ EdgeUniquenessFilter::EdgeUniquenessFilter(
ACCEPT_WITH_INPUT(EdgeUniquenessFilter)
std::unique_ptr<Cursor> EdgeUniquenessFilter::MakeCursor(
UniqueCursorPtr EdgeUniquenessFilter::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<EdgeUniquenessFilterCursor>(*this, db, mem);
return MakeUniqueCursorPtr<EdgeUniquenessFilterCursor>(mem, *this, db, mem);
}
std::vector<Symbol> EdgeUniquenessFilter::ModifiedSymbols(
@ -2244,9 +2249,9 @@ Accumulate::Accumulate(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Accumulate)
std::unique_ptr<Cursor> Accumulate::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<Accumulate::AccumulateCursor>(*this, db, mem);
UniqueCursorPtr Accumulate::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<Accumulate::AccumulateCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Accumulate::ModifiedSymbols(const SymbolTable &) const {
@ -2308,9 +2313,9 @@ Aggregate::Aggregate(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Aggregate)
std::unique_ptr<Cursor> Aggregate::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<AggregateCursor>(*this, db, mem);
UniqueCursorPtr Aggregate::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<AggregateCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Aggregate::ModifiedSymbols(const SymbolTable &) const {
@ -2595,9 +2600,9 @@ Skip::Skip(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Skip)
std::unique_ptr<Cursor> Skip::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<SkipCursor>(*this, db, mem);
UniqueCursorPtr Skip::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<SkipCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Skip::OutputSymbols(const SymbolTable &symbol_table) const {
@ -2655,9 +2660,9 @@ Limit::Limit(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Limit)
std::unique_ptr<Cursor> Limit::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<LimitCursor>(*this, db, mem);
UniqueCursorPtr Limit::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<LimitCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Limit::OutputSymbols(
@ -2730,9 +2735,9 @@ OrderBy::OrderBy(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(OrderBy)
std::unique_ptr<Cursor> OrderBy::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<OrderByCursor>(*this, db, mem);
UniqueCursorPtr OrderBy::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<OrderByCursor>(mem, *this, db, mem);
}
std::vector<Symbol> OrderBy::OutputSymbols(
@ -2823,9 +2828,9 @@ bool Merge::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
return visitor.PostVisit(*this);
}
std::unique_ptr<Cursor> Merge::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<MergeCursor>(*this, db, mem);
UniqueCursorPtr Merge::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<MergeCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Merge::ModifiedSymbols(const SymbolTable &table) const {
@ -2910,9 +2915,9 @@ bool Optional::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
return visitor.PostVisit(*this);
}
std::unique_ptr<Cursor> Optional::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<OptionalCursor>(*this, db, mem);
UniqueCursorPtr Optional::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<OptionalCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Optional::ModifiedSymbols(const SymbolTable &table) const {
@ -2987,9 +2992,9 @@ Unwind::Unwind(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Unwind)
std::unique_ptr<Cursor> Unwind::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<UnwindCursor>(*this, db, mem);
UniqueCursorPtr Unwind::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<UnwindCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Unwind::ModifiedSymbols(const SymbolTable &table) const {
@ -3084,7 +3089,7 @@ class DistinctCursor : public Cursor {
private:
const Distinct &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
// a set of already seen rows
std::unordered_set<
std::vector<TypedValue, utils::Allocator<TypedValue>>,
@ -3104,9 +3109,9 @@ Distinct::Distinct(const std::shared_ptr<LogicalOperator> &input,
ACCEPT_WITH_INPUT(Distinct)
std::unique_ptr<Cursor> Distinct::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<DistinctCursor>(*this, db, mem);
UniqueCursorPtr Distinct::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<DistinctCursor>(mem, *this, db, mem);
}
std::vector<Symbol> Distinct::OutputSymbols(
@ -3130,9 +3135,9 @@ Union::Union(const std::shared_ptr<LogicalOperator> &left_op,
left_symbols_(left_symbols),
right_symbols_(right_symbols) {}
std::unique_ptr<Cursor> Union::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return std::make_unique<Union::UnionCursor>(*this, db, mem);
UniqueCursorPtr Union::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<Union::UnionCursor>(mem, *this, db, mem);
}
bool Union::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
@ -3290,17 +3295,17 @@ class CartesianCursor : public Cursor {
const Cartesian &self_;
std::vector<std::vector<TypedValue>> left_op_frames_;
std::vector<TypedValue> right_op_frame_;
const std::unique_ptr<Cursor> left_op_cursor_;
const std::unique_ptr<Cursor> right_op_cursor_;
const UniqueCursorPtr left_op_cursor_;
const UniqueCursorPtr right_op_cursor_;
std::vector<std::vector<TypedValue>>::iterator left_op_frames_it_;
bool cartesian_pull_initialized_{false};
};
} // namespace
std::unique_ptr<Cursor> Cartesian::MakeCursor(
database::GraphDbAccessor *db, utils::MemoryResource *mem) const {
return std::make_unique<CartesianCursor>(*this, db, mem);
UniqueCursorPtr Cartesian::MakeCursor(database::GraphDbAccessor *db,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<CartesianCursor>(mem, *this, db, mem);
}
OutputTable::OutputTable(std::vector<Symbol> output_symbols,
@ -3355,9 +3360,9 @@ class OutputTableCursor : public Cursor {
bool pulled_{false};
};
std::unique_ptr<Cursor> OutputTable::MakeCursor(database::GraphDbAccessor *,
utils::MemoryResource *) const {
return std::make_unique<OutputTableCursor>(*this);
UniqueCursorPtr OutputTable::MakeCursor(database::GraphDbAccessor *,
utils::MemoryResource *mem) const {
return MakeUniqueCursorPtr<OutputTableCursor>(mem, *this);
}
} // namespace query::plan

134
src/query/plan/operator.lcp
View File

@ -66,6 +66,28 @@ class Cursor {
virtual ~Cursor() {}
};
/// unique_ptr to Cursor managed with a custom deleter.
/// This allows us to use utils::MemoryResource for allocation.
using UniqueCursorPtr = std::unique_ptr<Cursor, std::function<void(Cursor *)>>;
template <class TCursor, class... TArgs>
std::unique_ptr<Cursor, std::function<void(Cursor *)>> MakeUniqueCursorPtr(
utils::Allocator<TCursor> allocator, TArgs &&... args) {
auto *ptr = allocator.allocate(1);
try {
auto *cursor = new (ptr) TCursor(std::forward<TArgs>(args)...);
return std::unique_ptr<Cursor, std::function<void(Cursor *)>>(
cursor, [allocator](Cursor *base_ptr) mutable {
auto *p = static_cast<TCursor *>(base_ptr);
p->~TCursor();
allocator.deallocate(p, 1);
});
} catch (...) {
allocator.deallocate(ptr, 1);
throw;
}
}
class Once;
class CreateNode;
class CreateExpand;
@ -142,7 +164,7 @@ can serve as inputs to others and thus a sequence of operations is formed.")
* @param utils::MemoryResource Memory resource used for allocations during
* the lifetime of the returned Cursor.
*/
virtual std::unique_ptr<Cursor> MakeCursor(
virtual UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const = 0;
/** Return @c Symbol vector where the query results will be stored.
@ -278,7 +300,7 @@ and false on every following Pull.")
(:public
#>cpp
DEFVISITABLE(HierarchicalLogicalOperatorVisitor);
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override {
return {};
@ -373,7 +395,7 @@ a preceeding `MATCH`), or multiple nodes (`MATCH ... CREATE` or
CreateNode(const std::shared_ptr<LogicalOperator> &input,
const NodeCreationInfo &node_info);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -395,7 +417,7 @@ a preceeding `MATCH`), or multiple nodes (`MATCH ... CREATE` or
private:
const CreateNode &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -473,7 +495,7 @@ chained in cases when longer paths need creating.
const std::shared_ptr<LogicalOperator> &input,
Symbol input_symbol, bool existing_node);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -496,7 +518,7 @@ chained in cases when longer paths need creating.
private:
const CreateExpand &self_;
database::GraphDbAccessor &db_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
// Get the existing node (if existing_node_ == true), or create a new node
VertexAccessor &OtherVertex(Frame &frame, ExecutionContext &context);
@ -552,7 +574,7 @@ with a constructor argument.
ScanAll(const std::shared_ptr<LogicalOperator> &input, Symbol output_symbol,
GraphView graph_view = GraphView::OLD);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -581,7 +603,7 @@ given label.
Symbol output_symbol, storage::Label label,
GraphView graph_view = GraphView::OLD);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
cpp<#)
(:serialize (:slk))
@ -691,7 +713,7 @@ property value which is inside a range (inclusive or exlusive).
GraphView graph_view = GraphView::OLD);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
cpp<#)
(:serialize (:slk))
@ -732,7 +754,7 @@ property value.
GraphView graph_view = GraphView::OLD);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
cpp<#)
(:serialize (:slk))
@ -798,7 +820,7 @@ pulled.")
Expand() {}
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -824,7 +846,7 @@ pulled.")
decltype(std::declval<VertexAccessor>().out().begin());
const Expand &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
database::GraphDbAccessor &db_;
// The iterable over edges and the current edge iterator are referenced via
@ -949,7 +971,7 @@ pulled.")
std::optional<Symbol> total_weight);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -988,7 +1010,7 @@ pulled.")
path_symbol_(path_symbol),
path_elements_(path_elements) {}
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1021,7 +1043,7 @@ a boolean value.")
Filter(const std::shared_ptr<LogicalOperator> &input_,
Expression *expression_);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1043,7 +1065,7 @@ a boolean value.")
private:
const Filter &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -1073,7 +1095,7 @@ RETURN clause) the Produce's pull succeeds exactly once.")
Produce(const std::shared_ptr<LogicalOperator> &input,
const std::vector<NamedExpression *> &named_expressions);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> OutputSymbols(const SymbolTable &) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1096,7 +1118,7 @@ RETURN clause) the Produce's pull succeeds exactly once.")
private:
const Produce &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -1123,7 +1145,7 @@ Has a flag for using DETACH DELETE when deleting vertices.")
Delete(const std::shared_ptr<LogicalOperator> &input_,
const std::vector<Expression *> &expressions, bool detach_);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1146,7 +1168,7 @@ Has a flag for using DETACH DELETE when deleting vertices.")
private:
const Delete &self_;
database::GraphDbAccessor &db_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -1176,7 +1198,7 @@ can be stored (a TypedValue that can be converted to PropertyValue).")
storage::Property property, PropertyLookup *lhs,
Expression *rhs);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1198,7 +1220,7 @@ can be stored (a TypedValue that can be converted to PropertyValue).")
private:
const SetProperty &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -1237,7 +1259,7 @@ that the old properties are discarded and replaced with new ones.")
SetProperties(const std::shared_ptr<LogicalOperator> &input,
Symbol input_symbol, Expression *rhs, Op op);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1260,7 +1282,7 @@ that the old properties are discarded and replaced with new ones.")
private:
const SetProperties &self_;
database::GraphDbAccessor &db_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
/** Helper function that sets the given values on either
* a VertexRecord or an EdgeRecord.
@ -1291,7 +1313,7 @@ It does NOT remove labels that are already set on that Vertex.")
SetLabels(const std::shared_ptr<LogicalOperator> &input, Symbol input_symbol,
const std::vector<storage::Label> &labels);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1313,7 +1335,7 @@ It does NOT remove labels that are already set on that Vertex.")
private:
const SetLabels &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -1336,7 +1358,7 @@ It does NOT remove labels that are already set on that Vertex.")
RemoveProperty(const std::shared_ptr<LogicalOperator> &input,
storage::Property property, PropertyLookup *lhs);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1358,7 +1380,7 @@ It does NOT remove labels that are already set on that Vertex.")
private:
const RemoveProperty &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -1381,7 +1403,7 @@ If a label does not exist on a Vertex, nothing happens.")
RemoveLabels(const std::shared_ptr<LogicalOperator> &input,
Symbol input_symbol, const std::vector<storage::Label> &labels);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1403,7 +1425,7 @@ If a label does not exist on a Vertex, nothing happens.")
private:
const RemoveLabels &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -1437,7 +1459,7 @@ edge lists).")
Symbol expand_symbol,
const std::vector<Symbol> &previous_symbols);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1460,7 +1482,7 @@ edge lists).")
private:
const EdgeUniquenessFilter &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -1506,7 +1528,7 @@ has been cached will be reconstructed before Pull returns.
Accumulate(const std::shared_ptr<LogicalOperator> &input,
const std::vector<Symbol> &symbols, bool advance_command = false);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1529,7 +1551,7 @@ has been cached will be reconstructed before Pull returns.
private:
const Accumulate &self_;
database::GraphDbAccessor &db_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
std::vector<std::vector<TypedValue>> cache_;
decltype(cache_.begin()) cache_it_ = cache_.begin();
bool pulled_all_input_{false};
@ -1615,7 +1637,7 @@ elements are in an undefined state after aggregation.")
const std::vector<Expression *> &group_by,
const std::vector<Symbol> &remember);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1653,7 +1675,7 @@ elements are in an undefined state after aggregation.")
};
const Aggregate &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
// storage for aggregated data
// map key is the vector of group-by values
// map value is an AggregationValue struct
@ -1736,7 +1758,7 @@ operator's implementation does not expect this.")
Skip(const std::shared_ptr<LogicalOperator> &input, Expression *expression);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> OutputSymbols(const SymbolTable &) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1759,7 +1781,7 @@ operator's implementation does not expect this.")
private:
const Skip &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
// init to_skip_ to -1, indicating
// that it's still unknown (input has not been Pulled yet)
int to_skip_{-1};
@ -1797,7 +1819,7 @@ input should be performed).")
Limit(const std::shared_ptr<LogicalOperator> &input, Expression *expression);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> OutputSymbols(const SymbolTable &) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1820,7 +1842,7 @@ input should be performed).")
private:
const Limit &self_;
std::unique_ptr<Cursor> input_cursor_;
UniqueCursorPtr input_cursor_;
// init limit_ to -1, indicating
// that it's still unknown (Cursor has not been Pulled yet)
int limit_{-1};
@ -1858,7 +1880,7 @@ are valid for usage after the OrderBy operator.")
const std::vector<SortItem> &order_by,
const std::vector<Symbol> &output_symbols);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> OutputSymbols(const SymbolTable &) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1881,7 +1903,7 @@ are valid for usage after the OrderBy operator.")
private:
const OrderBy &self_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
bool did_pull_all_{false};
// a cache of elements pulled from the input
// first pair element is the order-by vector
@ -1926,7 +1948,7 @@ documentation.")
const std::shared_ptr<LogicalOperator> &merge_match,
const std::shared_ptr<LogicalOperator> &merge_create);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -1950,9 +1972,9 @@ documentation.")
void Reset() override;
private:
const std::unique_ptr<Cursor> input_cursor_;
const std::unique_ptr<Cursor> merge_match_cursor_;
const std::unique_ptr<Cursor> merge_create_cursor_;
const UniqueCursorPtr input_cursor_;
const UniqueCursorPtr merge_match_cursor_;
const UniqueCursorPtr merge_create_cursor_;
// indicates if the next Pull from this cursor
// should perform a pull from input_cursor_
@ -1988,7 +2010,7 @@ and returns true, once.")
const std::shared_ptr<LogicalOperator> &optional,
const std::vector<Symbol> &optional_symbols);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -2010,8 +2032,8 @@ and returns true, once.")
private:
const Optional &self_;
const std::unique_ptr<Cursor> input_cursor_;
const std::unique_ptr<Cursor> optional_cursor_;
const UniqueCursorPtr input_cursor_;
const UniqueCursorPtr optional_cursor_;
// indicates if the next Pull from this cursor should
// perform a Pull from the input_cursor_
// this is true when:
@ -2043,7 +2065,7 @@ Input is optional (unwind can be the first clause in a query).")
Unwind(const std::shared_ptr<LogicalOperator> &input,
Expression *input_expression_, Symbol output_symbol);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -2068,7 +2090,7 @@ Input is optional (unwind can be the first clause in a query).")
private:
const Unwind &self_;
database::GraphDbAccessor &db_;
const std::unique_ptr<Cursor> input_cursor_;
const UniqueCursorPtr input_cursor_;
// typed values we are unwinding and yielding
std::vector<TypedValue> input_value_;
// current position in input_value_
@ -2097,7 +2119,7 @@ This implementation maintains input ordering.")
Distinct(const std::shared_ptr<LogicalOperator> &input,
const std::vector<Symbol> &value_symbols);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> OutputSymbols(const SymbolTable &) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -2137,7 +2159,7 @@ of symbols used by each of the inputs.")
const std::vector<Symbol> &left_symbols,
const std::vector<Symbol> &right_symbols);
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> OutputSymbols(const SymbolTable &) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -2158,7 +2180,7 @@ of symbols used by each of the inputs.")
private:
const Union &self_;
const std::unique_ptr<Cursor> left_cursor_, right_cursor_;
const UniqueCursorPtr left_cursor_, right_cursor_;
};
cpp<#)
(:serialize (:slk))
@ -2191,7 +2213,7 @@ of symbols used by each of the inputs.")
right_symbols_(right_symbols) {}
bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
@ -2221,7 +2243,7 @@ of symbols used by each of the inputs.")
LOG(FATAL) << "OutputTable operator should not be visited!";
}
std::unique_ptr<Cursor> MakeCursor(
UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *, utils::MemoryResource *) const override;
std::vector<Symbol> OutputSymbols(const SymbolTable &) const override {
return output_symbols_;

10
tests/unit/bfs_common.hpp
View File

@ -109,10 +109,11 @@ class Yield : public query::plan::LogicalOperator {
modified_symbols_(modified_symbols),
values_(values) {}
std::unique_ptr<query::plan::Cursor> MakeCursor(
query::plan::UniqueCursorPtr MakeCursor(
database::GraphDbAccessor *dba,
utils::MemoryResource *mem) const override {
return std::make_unique<YieldCursor>(this, input_->MakeCursor(dba, mem));
return query::plan::MakeUniqueCursorPtr<YieldCursor>(
mem, this, input_->MakeCursor(dba, mem));
}
std::vector<query::Symbol> ModifiedSymbols(
const query::SymbolTable &) const override {
@ -140,8 +141,7 @@ class Yield : public query::plan::LogicalOperator {
class YieldCursor : public query::plan::Cursor {
public:
YieldCursor(const Yield *self,
std::unique_ptr<query::plan::Cursor> input_cursor)
YieldCursor(const Yield *self, query::plan::UniqueCursorPtr input_cursor)
: self_(self),
input_cursor_(std::move(input_cursor)),
pull_index_(self_->values_.size()) {}
@ -165,7 +165,7 @@ class Yield : public query::plan::LogicalOperator {
private:
const Yield *self_;
std::unique_ptr<query::plan::Cursor> input_cursor_;
query::plan::UniqueCursorPtr input_cursor_;
size_t pull_index_;
};
};