You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@quickstep.apache.org by hb...@apache.org on 2016/06/08 16:39:03 UTC
[1/3] incubator-quickstep git commit: Reordered query ID in
aggregation operator
Repository: incubator-quickstep
Updated Branches:
refs/heads/reorder-query-id-param [created] d67f61e16
Reordered query ID in aggregation operator
Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/15a2114a
Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/15a2114a
Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/15a2114a
Branch: refs/heads/reorder-query-id-param
Commit: 15a2114a2c64c05f8a1b23831496fcf606a38d5d
Parents: eb3e73f
Author: Harshad Deshmukh <hb...@apache.org>
Authored: Wed Jun 8 09:14:20 2016 -0500
Committer: Harshad Deshmukh <hb...@apache.org>
Committed: Wed Jun 8 09:14:20 2016 -0500
----------------------------------------------------------------------
query_optimizer/ExecutionGenerator.cpp | 5 +++--
relational_operators/AggregationOperator.cpp | 4 ++--
relational_operators/AggregationOperator.hpp | 14 +++++++-------
.../tests/AggregationOperator_unittest.cpp | 4 ++--
4 files changed, 14 insertions(+), 13 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/15a2114a/query_optimizer/ExecutionGenerator.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/ExecutionGenerator.cpp b/query_optimizer/ExecutionGenerator.cpp
index 30dfa8e..56625fd 100644
--- a/query_optimizer/ExecutionGenerator.cpp
+++ b/query_optimizer/ExecutionGenerator.cpp
@@ -1429,10 +1429,11 @@ void ExecutionGenerator::convertAggregate(
const QueryPlan::DAGNodeIndex aggregation_operator_index =
execution_plan_->addRelationalOperator(
new AggregationOperator(
+ query_handle_->query_id(),
*input_relation_info->relation,
input_relation_info->isStoredRelation(),
- aggr_state_index,
- query_handle_->query_id()));
+ aggr_state_index));
+
if (!input_relation_info->isStoredRelation()) {
execution_plan_->addDirectDependency(aggregation_operator_index,
input_relation_info->producer_operator_index,
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/15a2114a/relational_operators/AggregationOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/AggregationOperator.cpp b/relational_operators/AggregationOperator.cpp
index 94ba901..7252541 100644
--- a/relational_operators/AggregationOperator.cpp
+++ b/relational_operators/AggregationOperator.cpp
@@ -39,8 +39,8 @@ bool AggregationOperator::getAllWorkOrders(
for (const block_id input_block_id : input_relation_block_ids_) {
container->addNormalWorkOrder(
new AggregationWorkOrder(
- input_block_id,
query_id_,
+ input_block_id,
query_context->getAggregationState(aggr_state_index_)),
op_index_);
}
@@ -51,8 +51,8 @@ bool AggregationOperator::getAllWorkOrders(
while (num_workorders_generated_ < input_relation_block_ids_.size()) {
container->addNormalWorkOrder(
new AggregationWorkOrder(
- input_relation_block_ids_[num_workorders_generated_],
query_id_,
+ input_relation_block_ids_[num_workorders_generated_],
query_context->getAggregationState(aggr_state_index_)),
op_index_);
++num_workorders_generated_;
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/15a2114a/relational_operators/AggregationOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/AggregationOperator.hpp b/relational_operators/AggregationOperator.hpp
index 0fbc381..f340d4e 100644
--- a/relational_operators/AggregationOperator.hpp
+++ b/relational_operators/AggregationOperator.hpp
@@ -53,17 +53,17 @@ class AggregationOperator : public RelationalOperator {
* @brief Constructor for aggregating with arbitrary expressions in projection
* list.
*
+ * @param query_id The ID of this query.
* @param input_relation The relation to perform aggregation over.
* @param input_relation_is_stored If input_relation is a stored relation and
* is fully available to the operator before it can start generating
* workorders.
* @param aggr_state_index The index of the AggregationState in QueryContext.
- * @param query_id The ID of this query.
**/
- AggregationOperator(const CatalogRelation &input_relation,
+ AggregationOperator(const std::size_t query_id,
+ const CatalogRelation &input_relation,
bool input_relation_is_stored,
- const QueryContext::aggregation_state_id aggr_state_index,
- const std::size_t query_id)
+ const QueryContext::aggregation_state_id aggr_state_index)
: RelationalOperator(query_id),
input_relation_is_stored_(input_relation_is_stored),
input_relation_block_ids_(input_relation_is_stored ? input_relation.getBlocksSnapshot()
@@ -109,12 +109,12 @@ class AggregationWorkOrder : public WorkOrder {
/**
* @brief Constructor
*
- * @param input_block_id The block id.
* @param query_id The ID of this query.
+ * @param input_block_id The block id.
* @param state The AggregationState to use.
**/
- AggregationWorkOrder(const block_id input_block_id,
- const std::size_t query_id,
+ AggregationWorkOrder(const std::size_t query_id,
+ const block_id input_block_id,
AggregationOperationState *state)
: WorkOrder(query_id),
input_block_id_(input_block_id),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/15a2114a/relational_operators/tests/AggregationOperator_unittest.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/tests/AggregationOperator_unittest.cpp b/relational_operators/tests/AggregationOperator_unittest.cpp
index ace7951..5f3a434 100644
--- a/relational_operators/tests/AggregationOperator_unittest.cpp
+++ b/relational_operators/tests/AggregationOperator_unittest.cpp
@@ -270,7 +270,7 @@ class AggregationOperatorTest : public ::testing::Test {
aggr_state_proto->set_estimated_num_entries(estimated_entries);
// Create Operators.
- op_.reset(new AggregationOperator(*table_, true, aggr_state_index, 0));
+ op_.reset(new AggregationOperator(0, *table_, true, aggr_state_index));
// Setup the InsertDestination proto in the query context proto.
const QueryContext::insert_destination_id insert_destination_index =
@@ -354,7 +354,7 @@ class AggregationOperatorTest : public ::testing::Test {
serialization::HashTableImplType::LINEAR_OPEN_ADDRESSING);
// Create Operators.
- op_.reset(new AggregationOperator(*table_, true, aggr_state_index, 0));
+ op_.reset(new AggregationOperator(0, *table_, true, aggr_state_index));
// Setup the InsertDestination proto in the query context proto.
const QueryContext::insert_destination_id insert_destination_index =
[2/3] incubator-quickstep git commit: Reordered query ID in operators
and work orders.
Posted by hb...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SampleOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/SampleOperator.hpp b/relational_operators/SampleOperator.hpp
index f65f28a..3372da9 100644
--- a/relational_operators/SampleOperator.hpp
+++ b/relational_operators/SampleOperator.hpp
@@ -56,6 +56,7 @@ class SampleOperator : public RelationalOperator {
/**
* @brief Constructor for SampleOperator with the sampling percentage and type of sampling.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param input_relation The relation to perform sampling over.
* @param output_relation The output relation.
* @param output_destination_index The index of the InsertDestination in the
@@ -65,15 +66,15 @@ class SampleOperator : public RelationalOperator {
* workorders.
* @param is_block_sample Flag indicating whether the sample type is block or tuple.
* @param percentage The percentage of data to be sampled.
- * @param query_id The ID of the query to which this operator belongs.
**/
- SampleOperator(const CatalogRelation &input_relation,
- const CatalogRelationSchema &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const bool input_relation_is_stored,
- const bool is_block_sample,
- const int percentage,
- const std::size_t query_id)
+ SampleOperator(
+ const std::size_t query_id,
+ const CatalogRelation &input_relation,
+ const CatalogRelationSchema &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const bool input_relation_is_stored,
+ const bool is_block_sample,
+ const int percentage)
: RelationalOperator(query_id),
input_relation_(input_relation),
output_relation_(output_relation),
@@ -81,8 +82,9 @@ class SampleOperator : public RelationalOperator {
input_relation_is_stored_(input_relation_is_stored),
is_block_sample_(is_block_sample),
percentage_(percentage),
- input_relation_block_ids_(input_relation_is_stored ? input_relation.getBlocksSnapshot()
- : std::vector<block_id>()),
+ input_relation_block_ids_(input_relation_is_stored
+ ? input_relation.getBlocksSnapshot()
+ : std::vector<block_id>()),
num_workorders_generated_(0),
started_(false) {}
@@ -133,11 +135,11 @@ class SampleOperator : public RelationalOperator {
**/
class SampleWorkOrder : public WorkOrder {
public:
- SampleWorkOrder(const CatalogRelationSchema &input_relation,
+ SampleWorkOrder(const std::size_t query_id,
+ const CatalogRelationSchema &input_relation,
const block_id input_block_id,
const bool is_block_sample,
const int percentage,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager)
: WorkOrder(query_id),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SaveBlocksOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/SaveBlocksOperator.cpp b/relational_operators/SaveBlocksOperator.cpp
index 3581090..8127d88 100644
--- a/relational_operators/SaveBlocksOperator.cpp
+++ b/relational_operators/SaveBlocksOperator.cpp
@@ -36,9 +36,9 @@ bool SaveBlocksOperator::getAllWorkOrders(
while (num_workorders_generated_ < destination_block_ids_.size()) {
container->addNormalWorkOrder(
new SaveBlocksWorkOrder(
+ query_id_,
destination_block_ids_[num_workorders_generated_],
force_,
- query_id_,
storage_manager),
op_index_);
++num_workorders_generated_;
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SaveBlocksOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/SaveBlocksOperator.hpp b/relational_operators/SaveBlocksOperator.hpp
index f4650bb..21cce2e 100644
--- a/relational_operators/SaveBlocksOperator.hpp
+++ b/relational_operators/SaveBlocksOperator.hpp
@@ -96,15 +96,15 @@ class SaveBlocksWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param save_block_id The id of the block to save.
* @param force If true, force writing of all blocks to disk, otherwise only
* write dirty blocks.
- * @param query_id The ID of the query to which this operator belongs.
* @param storage_manager The StorageManager to use.
**/
- SaveBlocksWorkOrder(const block_id save_block_id,
+ SaveBlocksWorkOrder(const std::size_t query_id,
+ const block_id save_block_id,
const bool force,
- const std::size_t query_id,
StorageManager *storage_manager)
: WorkOrder(query_id),
save_block_id_(save_block_id),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SelectOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/SelectOperator.cpp b/relational_operators/SelectOperator.cpp
index 350890d..e9a96f3 100644
--- a/relational_operators/SelectOperator.cpp
+++ b/relational_operators/SelectOperator.cpp
@@ -42,29 +42,28 @@ void SelectOperator::addWorkOrders(WorkOrdersContainer *container,
InsertDestination *output_destination) {
if (input_relation_is_stored_) {
for (const block_id input_block_id : input_relation_block_ids_) {
- container->addNormalWorkOrder(
- new SelectWorkOrder(input_relation_,
- input_block_id,
- predicate,
- simple_projection_,
- simple_selection_,
- selection,
- query_id_,
- output_destination,
- storage_manager),
- op_index_);
+ container->addNormalWorkOrder(new SelectWorkOrder(query_id_,
+ input_relation_,
+ input_block_id,
+ predicate,
+ simple_projection_,
+ simple_selection_,
+ selection,
+ output_destination,
+ storage_manager),
+ op_index_);
}
} else {
while (num_workorders_generated_ < input_relation_block_ids_.size()) {
container->addNormalWorkOrder(
new SelectWorkOrder(
+ query_id_,
input_relation_,
input_relation_block_ids_[num_workorders_generated_],
predicate,
simple_projection_,
simple_selection_,
selection,
- query_id_,
output_destination,
storage_manager),
op_index_);
@@ -87,13 +86,13 @@ void SelectOperator::addPartitionAwareWorkOrders(WorkOrdersContainer *container,
input_relation_block_ids_in_partition_[part_id]) {
container->addNormalWorkOrder(
new SelectWorkOrder(
+ query_id_,
input_relation_,
input_block_id,
predicate,
simple_projection_,
simple_selection_,
selection,
- query_id_,
output_destination,
storage_manager,
placement_scheme_->getNUMANodeForBlock(input_block_id)),
@@ -108,13 +107,13 @@ void SelectOperator::addPartitionAwareWorkOrders(WorkOrdersContainer *container,
= input_relation_block_ids_in_partition_[part_id][num_workorders_generated_in_partition_[part_id]];
container->addNormalWorkOrder(
new SelectWorkOrder(
+ query_id_,
input_relation_,
block_in_partition,
predicate,
simple_projection_,
simple_selection_,
selection,
- query_id_,
output_destination,
storage_manager,
placement_scheme_->getNUMANodeForBlock(block_in_partition)),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SelectOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/SelectOperator.hpp b/relational_operators/SelectOperator.hpp
index 4f5b8ca..ac7b038 100644
--- a/relational_operators/SelectOperator.hpp
+++ b/relational_operators/SelectOperator.hpp
@@ -64,6 +64,7 @@ class SelectOperator : public RelationalOperator {
* @brief Constructor for selection with arbitrary expressions in projection
* list.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param input_relation The relation to perform selection over.
* @param output_relation The output relation.
* @param output_destination_index The index of the InsertDestination in the
@@ -76,23 +77,24 @@ class SelectOperator : public RelationalOperator {
* @param input_relation_is_stored If input_relation is a stored relation and
* is fully available to the operator before it can start generating
* workorders.
- * @param query_id The ID of the query to which this operator belongs.
**/
- SelectOperator(const CatalogRelation &input_relation,
- const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const QueryContext::predicate_id predicate_index,
- const QueryContext::scalar_group_id selection_index,
- const bool input_relation_is_stored,
- const std::size_t query_id)
+ SelectOperator(
+ const std::size_t query_id,
+ const CatalogRelation &input_relation,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const QueryContext::predicate_id predicate_index,
+ const QueryContext::scalar_group_id selection_index,
+ const bool input_relation_is_stored)
: RelationalOperator(query_id),
input_relation_(input_relation),
output_relation_(output_relation),
output_destination_index_(output_destination_index),
predicate_index_(predicate_index),
selection_index_(selection_index),
- input_relation_block_ids_(input_relation_is_stored ? input_relation.getBlocksSnapshot()
- : std::vector<block_id>()),
+ input_relation_block_ids_(input_relation_is_stored
+ ? input_relation.getBlocksSnapshot()
+ : std::vector<block_id>()),
num_workorders_generated_(0),
simple_projection_(false),
input_relation_is_stored_(input_relation_is_stored),
@@ -124,6 +126,7 @@ class SelectOperator : public RelationalOperator {
*
* @note selection_index_ is invalid, and will not be used for projection.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param input_relation The relation to perform selection over.
* @param output_relation The output relation.
* @param output_destination_index The index of the InsertDestination in the
@@ -136,15 +139,15 @@ class SelectOperator : public RelationalOperator {
* @param input_relation_is_stored If input_relation is a stored relation and
* is fully available to the operator before it can start generating
* workorders.
- * @param query_id The ID of the query to which this operator belongs.
**/
- SelectOperator(const CatalogRelation &input_relation,
- const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const QueryContext::predicate_id predicate_index,
- std::vector<attribute_id> &&selection,
- const bool input_relation_is_stored,
- const std::size_t query_id)
+ SelectOperator(
+ const std::size_t query_id,
+ const CatalogRelation &input_relation,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const QueryContext::predicate_id predicate_index,
+ std::vector<attribute_id> &&selection,
+ const bool input_relation_is_stored)
: RelationalOperator(query_id),
input_relation_(input_relation),
output_relation_(output_relation),
@@ -152,8 +155,9 @@ class SelectOperator : public RelationalOperator {
predicate_index_(predicate_index),
selection_index_(QueryContext::kInvalidScalarGroupId),
simple_selection_(std::move(selection)),
- input_relation_block_ids_(input_relation_is_stored ? input_relation.getBlocksSnapshot()
- : std::vector<block_id>()),
+ input_relation_block_ids_(input_relation_is_stored
+ ? input_relation.getBlocksSnapshot()
+ : std::vector<block_id>()),
num_workorders_generated_(0),
simple_projection_(true),
input_relation_is_stored_(input_relation_is_stored),
@@ -278,6 +282,7 @@ class SelectWorkOrder : public WorkOrder {
* @note Reference parameter selection is NOT owned by this class and must
* remain valid until after execute() is called.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param input_relation The relation to perform selection over.
* @param input_block_id The block id.
* @param predicate All tuples matching \c predicate will be selected (or NULL
@@ -287,18 +292,17 @@ class SelectWorkOrder : public WorkOrder {
* simple_projection is true.
* @param selection A list of Scalars which will be evaluated to project
* input tuples, used if \c simple_projection is false.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the selection
* results.
* @param storage_manager The StorageManager to use.
**/
- SelectWorkOrder(const CatalogRelationSchema &input_relation,
+ SelectWorkOrder(const std::size_t query_id,
+ const CatalogRelationSchema &input_relation,
const block_id input_block_id,
const Predicate *predicate,
const bool simple_projection,
const std::vector<attribute_id> &simple_selection,
const std::vector<std::unique_ptr<const Scalar>> *selection,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager,
const numa_node_id numa_node = 0)
@@ -320,6 +324,7 @@ class SelectWorkOrder : public WorkOrder {
* @note Reference parameter selection is NOT owned by this class and must
* remain valid until after execute() is called.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param input_relation The relation to perform selection over.
* @param input_block_id The block id.
* @param predicate All tuples matching \c predicate will be selected (or NULL
@@ -329,18 +334,17 @@ class SelectWorkOrder : public WorkOrder {
* simple_projection is true.
* @param selection A list of Scalars which will be evaluated to project
* input tuples, used if \c simple_projection is false.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the selection
* results.
* @param storage_manager The StorageManager to use.
**/
- SelectWorkOrder(const CatalogRelationSchema &input_relation,
+ SelectWorkOrder(const std::size_t query_id,
+ const CatalogRelationSchema &input_relation,
const block_id input_block_id,
const Predicate *predicate,
const bool simple_projection,
std::vector<attribute_id> &&simple_selection,
const std::vector<std::unique_ptr<const Scalar>> *selection,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager,
const numa_node_id numa_node = 0)
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SortMergeRunOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/SortMergeRunOperator.cpp b/relational_operators/SortMergeRunOperator.cpp
index 9db8de1..6bf5719 100644
--- a/relational_operators/SortMergeRunOperator.cpp
+++ b/relational_operators/SortMergeRunOperator.cpp
@@ -85,12 +85,12 @@ WorkOrder *SortMergeRunOperator::createWorkOrder(
// Create a work order from the merge job from merge tree.
return new SortMergeRunWorkOrder(
+ query_id_,
query_context->getSortConfig(sort_config_index_),
job->level > 0 ? run_relation_ : input_relation_,
std::move(job->runs),
top_k_,
job->level,
- query_id_,
output_destination,
storage_manager,
op_index_,
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SortMergeRunOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/SortMergeRunOperator.hpp b/relational_operators/SortMergeRunOperator.hpp
index f54e925..cfff8b9 100644
--- a/relational_operators/SortMergeRunOperator.hpp
+++ b/relational_operators/SortMergeRunOperator.hpp
@@ -72,6 +72,7 @@ class SortMergeRunOperator : public RelationalOperator {
/**
* @brief Constructor for merging sorted runs to generate a sorted relation.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param input_relation The relation to merge sorted blocks.
* @param output_relation The output relation.
* @param output_destination_index The index of the InsertDestination in the
@@ -88,18 +89,18 @@ class SortMergeRunOperator : public RelationalOperator {
* \c top_k is 0.
* @param input_relation_is_stored Boolean to indicate is input relation is
* stored or streamed.
- * @param query_id The ID of the query to which this operator belongs.
**/
- SortMergeRunOperator(const CatalogRelation &input_relation,
- const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const CatalogRelation &run_relation,
- const QueryContext::insert_destination_id run_block_destination_index,
- const QueryContext::sort_config_id sort_config_index,
- const std::size_t merge_factor,
- const std::size_t top_k,
- const bool input_relation_is_stored,
- const std::size_t query_id)
+ SortMergeRunOperator(
+ const std::size_t query_id,
+ const CatalogRelation &input_relation,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const CatalogRelation &run_relation,
+ const QueryContext::insert_destination_id run_block_destination_index,
+ const QueryContext::sort_config_id sort_config_index,
+ const std::size_t merge_factor,
+ const std::size_t top_k,
+ const bool input_relation_is_stored)
: RelationalOperator(query_id),
input_relation_(input_relation),
output_relation_(output_relation),
@@ -214,12 +215,12 @@ class SortMergeRunWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param sort_config The Sort configuration.
* @param run_relation The relation to which the run blocks belong to.
* @param input_runs Input runs to merge.
* @param top_k If non-zero will merge only \c top_k tuples.
* @param merge_level Merge level in the merge tree.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to create new blocks.
* @param storage_manager The StorageManager to use.
* @param operator_index Merge-run operator index to send feedback messages
@@ -228,12 +229,12 @@ class SortMergeRunWorkOrder : public WorkOrder {
* @param bus TMB to send the feedback message on.
**/
SortMergeRunWorkOrder(
+ const std::size_t query_id,
const SortConfiguration &sort_config,
const CatalogRelationSchema &run_relation,
std::vector<merge_run_operator::Run> &&input_runs,
const std::size_t top_k,
const std::size_t merge_level,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager,
const std::size_t operator_index,
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SortRunGenerationOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/SortRunGenerationOperator.cpp b/relational_operators/SortRunGenerationOperator.cpp
index e352f9e..37b8fb8 100644
--- a/relational_operators/SortRunGenerationOperator.cpp
+++ b/relational_operators/SortRunGenerationOperator.cpp
@@ -51,10 +51,10 @@ bool SortRunGenerationOperator::getAllWorkOrders(
if (!started_) {
for (const block_id input_block_id : input_relation_block_ids_) {
container->addNormalWorkOrder(
- new SortRunGenerationWorkOrder(input_relation_,
+ new SortRunGenerationWorkOrder(query_id_,
+ input_relation_,
input_block_id,
sort_config,
- query_id_,
output_destination,
storage_manager),
op_index_);
@@ -67,10 +67,10 @@ bool SortRunGenerationOperator::getAllWorkOrders(
while (num_workorders_generated_ < input_relation_block_ids_.size()) {
container->addNormalWorkOrder(
new SortRunGenerationWorkOrder(
+ query_id_,
input_relation_,
input_relation_block_ids_[num_workorders_generated_],
sort_config,
- query_id_,
output_destination,
storage_manager),
op_index_);
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SortRunGenerationOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/SortRunGenerationOperator.hpp b/relational_operators/SortRunGenerationOperator.hpp
index 3da9813..f96e6a6 100644
--- a/relational_operators/SortRunGenerationOperator.hpp
+++ b/relational_operators/SortRunGenerationOperator.hpp
@@ -73,6 +73,7 @@ class SortRunGenerationOperator : public RelationalOperator {
* @brief Constructor for sorting tuples in blocks based on the sort
* configuration and writing to output destination.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param input_relation The relation to generate sorted runs of.
* @param output_relation The output relation.
* @param output_destination_index The index of the InsertDestination in the
@@ -83,21 +84,22 @@ class SortRunGenerationOperator : public RelationalOperator {
* @param input_relation_is_stored Does the input relation contain the blocks
* to sort. If \c false, the blocks are
* streamed.
- * @param query_id The ID of the query to which this operator belongs.
**/
- SortRunGenerationOperator(const CatalogRelation &input_relation,
- const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const QueryContext::sort_config_id sort_config_index,
- bool input_relation_is_stored,
- const std::size_t query_id)
+ SortRunGenerationOperator(
+ const std::size_t query_id,
+ const CatalogRelation &input_relation,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const QueryContext::sort_config_id sort_config_index,
+ bool input_relation_is_stored)
: RelationalOperator(query_id),
input_relation_(input_relation),
output_relation_(output_relation),
output_destination_index_(output_destination_index),
sort_config_index_(sort_config_index),
- input_relation_block_ids_(input_relation_is_stored ? input_relation.getBlocksSnapshot()
- : std::vector<block_id>()),
+ input_relation_block_ids_(input_relation_is_stored
+ ? input_relation.getBlocksSnapshot()
+ : std::vector<block_id>()),
num_workorders_generated_(0),
started_(false),
input_relation_is_stored_(input_relation_is_stored) {}
@@ -151,19 +153,19 @@ class SortRunGenerationWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param input_relation The relation to generate sorted runs of.
* @param input_block_id The block id.
* @param sort_config The Sort configuration specifying ORDER BY, ordering,
* and null ordering.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to store the sorted blocks
* of runs.
* @param storage_manager The StorageManager to use.
**/
- SortRunGenerationWorkOrder(const CatalogRelationSchema &input_relation,
+ SortRunGenerationWorkOrder(const std::size_t query_id,
+ const CatalogRelationSchema &input_relation,
const block_id input_block_id,
const SortConfiguration &sort_config,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager)
: WorkOrder(query_id),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/TableGeneratorOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/TableGeneratorOperator.cpp b/relational_operators/TableGeneratorOperator.cpp
index fb1f743..a3f9340 100644
--- a/relational_operators/TableGeneratorOperator.cpp
+++ b/relational_operators/TableGeneratorOperator.cpp
@@ -43,9 +43,9 @@ bool TableGeneratorOperator::getAllWorkOrders(
// so just produce one work order.
container->addNormalWorkOrder(
new TableGeneratorWorkOrder(
+ query_id_,
query_context->getGeneratorFunctionHandle(
generator_function_index_),
- query_id_,
query_context->getInsertDestination(output_destination_index_)),
op_index_);
started_ = true;
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/TableGeneratorOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/TableGeneratorOperator.hpp b/relational_operators/TableGeneratorOperator.hpp
index bfc70c5..6a6af4b 100644
--- a/relational_operators/TableGeneratorOperator.hpp
+++ b/relational_operators/TableGeneratorOperator.hpp
@@ -55,23 +55,23 @@ class TableGeneratorOperator : public RelationalOperator {
/**
* @brief Constructor
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param output_relation The output relation.
* @param output_destination_index The index of the InsertDestination in the
* QueryContext to insert the generated output.
* @param generator_function_index The index of the GeneratorFunctionHandle in
* the QueryContext.
- * @param query_id The ID of the query to which this operator belongs.
**/
- TableGeneratorOperator(const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const QueryContext::generator_function_id generator_function_index,
- const std::size_t query_id)
+ TableGeneratorOperator(
+ const std::size_t query_id,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const QueryContext::generator_function_id generator_function_index)
: RelationalOperator(query_id),
output_relation_(output_relation),
output_destination_index_(output_destination_index),
generator_function_index_(generator_function_index),
- started_(false) {
- }
+ started_(false) {}
~TableGeneratorOperator() override {}
@@ -113,13 +113,13 @@ class TableGeneratorWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
- * @param generator_function The GeneratorFunctionHandle to use.
* @param query_id The ID of the query to which this WorkOrder belongs.
+ * @param generator_function The GeneratorFunctionHandle to use.
* @param output_destination The InsertDestination to insert the generated
* output.
**/
- TableGeneratorWorkOrder(const GeneratorFunctionHandle &function_handle,
- const std::size_t query_id,
+ TableGeneratorWorkOrder(const std::size_t query_id,
+ const GeneratorFunctionHandle &function_handle,
InsertDestination *output_destination)
: WorkOrder(query_id),
function_handle_(function_handle),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/TextScanOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/TextScanOperator.cpp b/relational_operators/TextScanOperator.cpp
index 8db5ef1..5acecbf 100644
--- a/relational_operators/TextScanOperator.cpp
+++ b/relational_operators/TextScanOperator.cpp
@@ -165,9 +165,9 @@ bool TextScanOperator::getAllWorkOrders(
// First, generate text-split work orders.
for (const auto &file : files) {
container->addNormalWorkOrder(
- new TextSplitWorkOrder(file,
+ new TextSplitWorkOrder(query_id_,
+ file,
process_escape_sequences_,
- query_id_,
storage_manager,
op_index_,
scheduler_client_id,
@@ -182,11 +182,11 @@ bool TextScanOperator::getAllWorkOrders(
while (!text_blob_queue_.empty()) {
const TextBlob blob_work = text_blob_queue_.popOne();
container->addNormalWorkOrder(
- new TextScanWorkOrder(blob_work.blob_id,
+ new TextScanWorkOrder(query_id_,
+ blob_work.blob_id,
blob_work.size,
field_terminator_,
process_escape_sequences_,
- query_id_,
output_destination,
storage_manager),
op_index_);
@@ -203,10 +203,10 @@ bool TextScanOperator::getAllWorkOrders(
if (blocking_dependencies_met_ && !work_generated_) {
for (const auto &file : files) {
container->addNormalWorkOrder(
- new TextScanWorkOrder(file,
+ new TextScanWorkOrder(query_id_,
+ file,
field_terminator_,
process_escape_sequences_,
- query_id_,
output_destination,
storage_manager),
op_index_);
@@ -234,11 +234,10 @@ void TextScanOperator::receiveFeedbackMessage(const WorkOrder::FeedbackMessage &
}
}
-
-TextScanWorkOrder::TextScanWorkOrder(const std::string &filename,
+TextScanWorkOrder::TextScanWorkOrder(const std::size_t query_id,
+ const std::string &filename,
const char field_terminator,
const bool process_escape_sequences,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager)
: WorkOrder(query_id),
@@ -254,11 +253,11 @@ TextScanWorkOrder::TextScanWorkOrder(const std::string &filename,
DCHECK(storage_manager_ != nullptr);
}
-TextScanWorkOrder::TextScanWorkOrder(const block_id text_blob,
+TextScanWorkOrder::TextScanWorkOrder(const std::size_t query_id,
+ const block_id text_blob,
const std::size_t text_size,
const char field_terminator,
const bool process_escape_sequences,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager)
: WorkOrder(query_id),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/TextScanOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/TextScanOperator.hpp b/relational_operators/TextScanOperator.hpp
index 1d0c04f..3cda65b 100644
--- a/relational_operators/TextScanOperator.hpp
+++ b/relational_operators/TextScanOperator.hpp
@@ -121,6 +121,7 @@ class TextScanOperator : public RelationalOperator {
/**
* @brief Constructor
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param file_pattern The glob-like file pattern of the sources to load. The
* pattern could include * (wildcard for multiple chars) and ?
* (wildcard for single char). It defaults to single file load, if a
@@ -134,15 +135,15 @@ class TextScanOperator : public RelationalOperator {
* @param output_relation The output relation.
* @param output_destination_index The index of the InsertDestination in the
* QueryContext to insert tuples.
- * @param query_id The ID of the query to which this operator belongs.
**/
- TextScanOperator(const std::string &file_pattern,
- const char field_terminator,
- const bool process_escape_sequences,
- const bool parallelize_load,
- const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const std::size_t query_id)
+ TextScanOperator(
+ const std::size_t query_id,
+ const std::string &file_pattern,
+ const char field_terminator,
+ const bool process_escape_sequences,
+ const bool parallelize_load,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index)
: RelationalOperator(query_id),
file_pattern_(file_pattern),
field_terminator_(field_terminator),
@@ -200,42 +201,42 @@ class TextScanWorkOrder : public WorkOrder {
/**
* @brief Constructor
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param filename The name of the text file to bulk insert.
* @param field_terminator The string which separates attribute values in
* the text file.
* @param process_escape_sequences Whether to decode escape sequences in the
* text file.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert tuples.
* @param storage_manager The StorageManager to use.
**/
TextScanWorkOrder(
+ const std::size_t query_id,
const std::string &filename,
const char field_terminator,
const bool process_escape_sequences,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager);
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param text_blob Blob ID containing the data to be scanned.
* @param text_size Size of the data in the blob.
* @param field_terminator The character which separates attribute values in
* the text file.
* @param process_escape_sequences Whether to decode escape sequences in the
* text file.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to write the read tuples.
* @param storage_manager The StorageManager to use.
*/
TextScanWorkOrder(
+ const std::size_t query_id,
const block_id text_blob,
const std::size_t text_size,
const char field_terminator,
const bool process_escape_sequences,
- const std::size_t query_id,
InsertDestination *output_destination,
StorageManager *storage_manager);
@@ -322,19 +323,20 @@ class TextSplitWorkOrder : public WorkOrder {
public:
/**
* @brief Constructor.
+ *
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param filename File to split into row-aligned blobs.
* @param process_escape_sequences Whether to decode escape sequences in the
* text file.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param storage_manager The StorageManager to use.
* @param operator_index Operator index of the current operator. This is used
* to send new-work available message to Foreman.
* @param scheduler_client_id The TMB client ID of the scheduler thread.
* @param bus A pointer to the TMB.
*/
- TextSplitWorkOrder(const std::string &filename,
+ TextSplitWorkOrder(const std::size_t query_id,
+ const std::string &filename,
const bool process_escape_sequences,
- const std::size_t query_id,
StorageManager *storage_manager,
const std::size_t operator_index,
const tmb::client_id scheduler_client_id,
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/UpdateOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/UpdateOperator.cpp b/relational_operators/UpdateOperator.cpp
index b331a9c..2130563 100644
--- a/relational_operators/UpdateOperator.cpp
+++ b/relational_operators/UpdateOperator.cpp
@@ -53,16 +53,18 @@ bool UpdateOperator::getAllWorkOrders(
for (const block_id input_block_id : input_blocks_) {
container->addNormalWorkOrder(
- new UpdateWorkOrder(relation_,
- input_block_id,
- query_context->getPredicate(predicate_index_),
- query_context->getUpdateGroup(update_group_index_),
- query_id_,
- query_context->getInsertDestination(relocation_destination_index_),
- storage_manager,
- op_index_,
- scheduler_client_id,
- bus),
+ new UpdateWorkOrder(
+ query_id_,
+ relation_,
+ input_block_id,
+ query_context->getPredicate(predicate_index_),
+ query_context->getUpdateGroup(update_group_index_),
+ query_context->getInsertDestination(
+ relocation_destination_index_),
+ storage_manager,
+ op_index_,
+ scheduler_client_id,
+ bus),
op_index_);
}
started_ = true;
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/UpdateOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/UpdateOperator.hpp b/relational_operators/UpdateOperator.hpp
index ba2d6cf..cebb9b5 100644
--- a/relational_operators/UpdateOperator.hpp
+++ b/relational_operators/UpdateOperator.hpp
@@ -62,6 +62,7 @@ class UpdateOperator : public RelationalOperator {
/**
* @brief Constructor
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param relation The relation to perform the UPDATE over.
* @param relocation_destination_index The index of the InsertDestination in
* the QueryContext to relocate tuples which can not be updated
@@ -72,16 +73,16 @@ class UpdateOperator : public RelationalOperator {
* @param update_group_index The index of a update group (the map of
* attribute_ids to Scalars) which should be evaluated to get the new
* value for the corresponding attribute.
- * @param query_id The ID of the query to which this operator belongs.
*
* @warning The constructed InsertDestination should belong to relation, but
* must NOT contain any pre-existing blocks.
**/
- UpdateOperator(const CatalogRelation &relation,
- const QueryContext::insert_destination_id relocation_destination_index,
- const QueryContext::predicate_id predicate_index,
- const QueryContext::update_group_id update_group_index,
- const std::size_t query_id)
+ UpdateOperator(
+ const std::size_t query_id,
+ const CatalogRelation &relation,
+ const QueryContext::insert_destination_id relocation_destination_index,
+ const QueryContext::predicate_id predicate_index,
+ const QueryContext::update_group_id update_group_index)
: RelationalOperator(query_id),
relation_(relation),
relocation_destination_index_(relocation_destination_index),
@@ -127,13 +128,13 @@ class UpdateWorkOrder : public WorkOrder {
/**
* @brief Constructor
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param relation The relation to perform the UPDATE over.
* @param predicate All tuples matching \c predicate will be updated (or NULL
* to update all tuples).
* @param assignments The assignments (the map of attribute_ids to Scalars)
* which should be evaluated to get the new value for the corresponding
* attribute.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param input_block_id The block id.
* @param relocation_destination The InsertDestination to relocate tuples
* which can not be updated in-place.
@@ -143,16 +144,18 @@ class UpdateWorkOrder : public WorkOrder {
* @param scheduler_client_id The TMB client ID of the scheduler thread.
* @param bus A pointer to the TMB.
**/
- UpdateWorkOrder(const CatalogRelationSchema &relation,
- const block_id input_block_id,
- const Predicate *predicate,
- const std::unordered_map<attribute_id, std::unique_ptr<const Scalar>> &assignments,
- const std::size_t query_id,
- InsertDestination *relocation_destination,
- StorageManager *storage_manager,
- const std::size_t update_operator_index,
- const tmb::client_id scheduler_client_id,
- MessageBus *bus)
+ UpdateWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &relation,
+ const block_id input_block_id,
+ const Predicate *predicate,
+ const std::unordered_map<attribute_id, std::unique_ptr<const Scalar>>
+ &assignments,
+ InsertDestination *relocation_destination,
+ StorageManager *storage_manager,
+ const std::size_t update_operator_index,
+ const tmb::client_id scheduler_client_id,
+ MessageBus *bus)
: WorkOrder(query_id),
relation_(relation),
input_block_id_(input_block_id),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/WorkOrderFactory.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/WorkOrderFactory.cpp b/relational_operators/WorkOrderFactory.cpp
index fdd694f..489b666 100644
--- a/relational_operators/WorkOrderFactory.cpp
+++ b/relational_operators/WorkOrderFactory.cpp
@@ -75,8 +75,8 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::AGGREGATION: {
LOG(INFO) << "Creating AggregationWorkOrder";
return new AggregationWorkOrder(
- proto.GetExtension(serialization::AggregationWorkOrder::block_id),
proto.query_id(),
+ proto.GetExtension(serialization::AggregationWorkOrder::block_id),
query_context->getAggregationState(
proto.GetExtension(serialization::AggregationWorkOrder::aggr_state_index)));
}
@@ -89,12 +89,12 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
}
return new BuildHashWorkOrder(
+ proto.query_id(),
catalog_database->getRelationSchemaById(
proto.GetExtension(serialization::BuildHashWorkOrder::relation_id)),
move(join_key_attributes),
proto.GetExtension(serialization::BuildHashWorkOrder::any_join_key_attributes_nullable),
proto.GetExtension(serialization::BuildHashWorkOrder::block_id),
- proto.query_id(),
query_context->getJoinHashTable(
proto.GetExtension(serialization::BuildHashWorkOrder::join_hash_table_index)),
storage_manager);
@@ -102,6 +102,7 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::DELETE: {
LOG(INFO) << "Creating DeleteWorkOrder";
return new DeleteWorkOrder(
+ proto.query_id(),
catalog_database->getRelationSchemaById(
proto.GetExtension(serialization::DeleteWorkOrder::relation_id)),
proto.GetExtension(serialization::DeleteWorkOrder::block_id),
@@ -110,15 +111,14 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
storage_manager,
proto.GetExtension(serialization::DeleteWorkOrder::operator_index),
shiftboss_client_id,
- proto.query_id(),
bus);
}
case serialization::DESTROY_HASH: {
LOG(INFO) << "Creating DestroyHashWorkOrder";
return new DestroyHashWorkOrder(
+ proto.query_id(),
proto.GetExtension(
serialization::DestroyHashWorkOrder::join_hash_table_index),
- proto.query_id(),
query_context);
}
case serialization::DROP_TABLE: {
@@ -193,6 +193,7 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::HashJoinWorkOrder::HASH_ANTI_JOIN: {
LOG(INFO) << "Creating HashAntiJoinWorkOrder";
return new HashAntiJoinWorkOrder(
+ proto.query_id(),
build_relation,
probe_relation,
move(join_key_attributes),
@@ -201,13 +202,13 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
residual_predicate,
selection,
hash_table,
- proto.query_id(),
output_destination,
storage_manager);
}
case serialization::HashJoinWorkOrder::HASH_INNER_JOIN: {
LOG(INFO) << "Creating HashInnerJoinWorkOrder";
return new HashInnerJoinWorkOrder(
+ proto.query_id(),
build_relation,
probe_relation,
move(join_key_attributes),
@@ -216,7 +217,6 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
residual_predicate,
selection,
hash_table,
- proto.query_id(),
output_destination,
storage_manager);
}
@@ -231,6 +231,7 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
LOG(INFO) << "Creating HashOuterJoinWorkOrder";
return new HashOuterJoinWorkOrder(
+ proto.query_id(),
build_relation,
probe_relation,
move(join_key_attributes),
@@ -239,13 +240,13 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
selection,
move(is_selection_on_build),
hash_table,
- proto.query_id(),
output_destination,
storage_manager);
}
case serialization::HashJoinWorkOrder::HASH_SEMI_JOIN: {
LOG(INFO) << "Creating HashSemiJoinWorkOrder";
return new HashSemiJoinWorkOrder(
+ proto.query_id(),
build_relation,
probe_relation,
move(join_key_attributes),
@@ -254,7 +255,6 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
residual_predicate,
selection,
hash_table,
- proto.query_id(),
output_destination,
storage_manager);
}
@@ -274,6 +274,7 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::NESTED_LOOP_JOIN: {
LOG(INFO) << "Creating NestedLoopsJoinWorkOrder";
return new NestedLoopsJoinWorkOrder(
+ proto.query_id(),
catalog_database->getRelationSchemaById(
proto.GetExtension(serialization::NestedLoopsJoinWorkOrder::left_relation_id)),
catalog_database->getRelationSchemaById(
@@ -284,7 +285,6 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
proto.GetExtension(serialization::NestedLoopsJoinWorkOrder::join_predicate_index)),
query_context->getScalarGroup(
proto.GetExtension(serialization::NestedLoopsJoinWorkOrder::selection_index)),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::NestedLoopsJoinWorkOrder::insert_destination_index)),
storage_manager);
@@ -292,12 +292,12 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::SAMPLE: {
LOG(INFO) << "Creating SampleWorkOrder";
return new SampleWorkOrder(
+ proto.query_id(),
catalog_database->getRelationSchemaById(
proto.GetExtension(serialization::SampleWorkOrder::relation_id)),
proto.GetExtension(serialization::SampleWorkOrder::block_id),
proto.GetExtension(serialization::SampleWorkOrder::is_block_sample),
proto.GetExtension(serialization::SampleWorkOrder::percentage),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::SampleWorkOrder::insert_destination_index)),
storage_manager);
@@ -305,9 +305,9 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::SAVE_BLOCKS: {
LOG(INFO) << "Creating SaveBlocksWorkOrder";
return new SaveBlocksWorkOrder(
+ proto.query_id(),
proto.GetExtension(serialization::SaveBlocksWorkOrder::block_id),
proto.GetExtension(serialization::SaveBlocksWorkOrder::force),
- proto.query_id(),
storage_manager);
}
case serialization::SELECT: {
@@ -321,6 +321,7 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
}
return new SelectWorkOrder(
+ proto.query_id(),
catalog_database->getRelationSchemaById(
proto.GetExtension(serialization::SelectWorkOrder::relation_id)),
proto.GetExtension(serialization::SelectWorkOrder::block_id),
@@ -331,7 +332,6 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
simple_projection ? nullptr
: &query_context->getScalarGroup(
proto.GetExtension(serialization::SelectWorkOrder::selection_index)),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::SelectWorkOrder::insert_destination_index)),
storage_manager);
@@ -350,6 +350,7 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
}
return new SortMergeRunWorkOrder(
+ proto.query_id(),
query_context->getSortConfig(
proto.GetExtension(serialization::SortMergeRunWorkOrder::sort_config_index)),
catalog_database->getRelationSchemaById(
@@ -357,7 +358,6 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
move(runs),
proto.GetExtension(serialization::SortMergeRunWorkOrder::top_k),
proto.GetExtension(serialization::SortMergeRunWorkOrder::merge_level),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::SortMergeRunWorkOrder::insert_destination_index)),
storage_manager,
@@ -368,12 +368,12 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::SORT_RUN_GENERATION: {
LOG(INFO) << "Creating SortRunGenerationWorkOrder";
return new SortRunGenerationWorkOrder(
+ proto.query_id(),
catalog_database->getRelationSchemaById(
proto.GetExtension(serialization::SortRunGenerationWorkOrder::relation_id)),
proto.GetExtension(serialization::SortRunGenerationWorkOrder::block_id),
query_context->getSortConfig(
proto.GetExtension(serialization::SortRunGenerationWorkOrder::sort_config_index)),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::SortRunGenerationWorkOrder::insert_destination_index)),
storage_manager);
@@ -381,9 +381,9 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::TABLE_GENERATOR: {
LOG(INFO) << "Creating SortRunGenerationWorkOrder";
return new TableGeneratorWorkOrder(
+ proto.query_id(),
query_context->getGeneratorFunctionHandle(
proto.GetExtension(serialization::TableGeneratorWorkOrder::generator_function_index)),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::TableGeneratorWorkOrder::insert_destination_index)));
}
@@ -391,10 +391,10 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
LOG(INFO) << "Creating TextScanWorkOrder";
if (proto.HasExtension(serialization::TextScanWorkOrder::filename)) {
return new TextScanWorkOrder(
+ proto.query_id(),
proto.GetExtension(serialization::TextScanWorkOrder::filename),
proto.GetExtension(serialization::TextScanWorkOrder::field_terminator),
proto.GetExtension(serialization::TextScanWorkOrder::process_escape_sequences),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::TextScanWorkOrder::insert_destination_index)),
storage_manager);
@@ -403,11 +403,11 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
proto.GetExtension(serialization::TextScanWorkOrder::text_blob);
return new TextScanWorkOrder(
+ proto.query_id(),
text_blob_proto.blob_id(),
text_blob_proto.size(),
proto.GetExtension(serialization::TextScanWorkOrder::field_terminator),
proto.GetExtension(serialization::TextScanWorkOrder::process_escape_sequences),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::TextScanWorkOrder::insert_destination_index)),
storage_manager);
@@ -416,9 +416,9 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::TEXT_SPLIT: {
LOG(INFO) << "Creating TextSplitWorkOrder";
return new TextSplitWorkOrder(
+ proto.query_id(),
proto.GetExtension(serialization::TextSplitWorkOrder::filename),
proto.GetExtension(serialization::TextSplitWorkOrder::process_escape_sequences),
- proto.query_id(),
storage_manager,
proto.GetExtension(serialization::TextSplitWorkOrder::operator_index),
shiftboss_client_id,
@@ -427,6 +427,7 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
case serialization::UPDATE: {
LOG(INFO) << "Creating UpdateWorkOrder";
return new UpdateWorkOrder(
+ proto.query_id(),
catalog_database->getRelationSchemaById(
proto.GetExtension(serialization::UpdateWorkOrder::relation_id)),
proto.GetExtension(serialization::UpdateWorkOrder::block_id),
@@ -434,7 +435,6 @@ WorkOrder* WorkOrderFactory::ReconstructFromProto(const serialization::WorkOrder
proto.GetExtension(serialization::UpdateWorkOrder::predicate_index)),
query_context->getUpdateGroup(
proto.GetExtension(serialization::UpdateWorkOrder::update_group_index)),
- proto.query_id(),
query_context->getInsertDestination(
proto.GetExtension(serialization::UpdateWorkOrder::insert_destination_index)),
storage_manager,
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/tests/AggregationOperator_unittest.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/tests/AggregationOperator_unittest.cpp b/relational_operators/tests/AggregationOperator_unittest.cpp
index 5f3a434..dc15c56 100644
--- a/relational_operators/tests/AggregationOperator_unittest.cpp
+++ b/relational_operators/tests/AggregationOperator_unittest.cpp
@@ -281,10 +281,11 @@ class AggregationOperatorTest : public ::testing::Test {
insert_destination_proto->set_relation_id(result_table_->getID());
insert_destination_proto->set_relational_op_index(kOpIndex);
- finalize_op_.reset(new FinalizeAggregationOperator(aggr_state_index,
- *result_table_,
- insert_destination_index,
- 0 /* dummy query ID */));
+ finalize_op_.reset(
+ new FinalizeAggregationOperator(0 /* dummy query ID */,
+ aggr_state_index,
+ *result_table_,
+ insert_destination_index));
// Set up the QueryContext.
query_context_.reset(new QueryContext(query_context_proto,
@@ -365,10 +366,11 @@ class AggregationOperatorTest : public ::testing::Test {
insert_destination_proto->set_relation_id(result_table_->getID());
insert_destination_proto->set_relational_op_index(kOpIndex);
- finalize_op_.reset(new FinalizeAggregationOperator(aggr_state_index,
- *result_table_,
- insert_destination_index,
- 0 /* dummy query ID */));
+ finalize_op_.reset(
+ new FinalizeAggregationOperator(0 /* dummy query ID */,
+ aggr_state_index,
+ *result_table_,
+ insert_destination_index));
// Set up the QueryContext.
query_context_.reset(new QueryContext(query_context_proto,
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/tests/HashJoinOperator_unittest.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/tests/HashJoinOperator_unittest.cpp b/relational_operators/tests/HashJoinOperator_unittest.cpp
index 4ef5a5c..75445fb 100644
--- a/relational_operators/tests/HashJoinOperator_unittest.cpp
+++ b/relational_operators/tests/HashJoinOperator_unittest.cpp
@@ -332,12 +332,12 @@ TEST_P(HashJoinOperatorTest, LongKeyHashJoinTest) {
// Create the builder operator.
unique_ptr<BuildHashOperator> builder(
- new BuildHashOperator(*dim_table_,
+ new BuildHashOperator(0, /* dummy query ID */
+ *dim_table_,
true /* is_stored */,
std::vector<attribute_id>(1, dim_col_long.getID()),
dim_col_long.getType().isNullable(),
- join_hash_table_index,
- 0)); // dummy query ID
+ join_hash_table_index));
// Create the prober operator with one selection attribute.
const QueryContext::scalar_group_id selection_index = query_context_proto.scalar_groups_size();
@@ -359,18 +359,18 @@ TEST_P(HashJoinOperatorTest, LongKeyHashJoinTest) {
insert_destination_proto->set_relation_id(output_relation_id);
insert_destination_proto->set_relational_op_index(kOpIndex);
- unique_ptr<HashJoinOperator> prober(
- new HashJoinOperator(*dim_table_,
- *fact_table_,
- true /* is_stored */,
- std::vector<attribute_id>(1, fact_col_long.getID()),
- fact_col_long.getType().isNullable(),
- *result_table,
- output_destination_index,
- join_hash_table_index,
- QueryContext::kInvalidPredicateId /* residual_predicate_index */,
- selection_index,
- 0 /* dummy query ID */));
+ unique_ptr<HashJoinOperator> prober(new HashJoinOperator(
+ 0 /* dummy query ID */,
+ *dim_table_,
+ *fact_table_,
+ true /* is_stored */,
+ std::vector<attribute_id>(1, fact_col_long.getID()),
+ fact_col_long.getType().isNullable(),
+ *result_table,
+ output_destination_index,
+ join_hash_table_index,
+ QueryContext::kInvalidPredicateId /* residual_predicate_index */,
+ selection_index));
// Set up the QueryContext.
query_context_.reset(new QueryContext(query_context_proto,
@@ -423,7 +423,7 @@ TEST_P(HashJoinOperatorTest, LongKeyHashJoinTest) {
}
// Create cleaner operator.
- unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(join_hash_table_index, 0 /* dummy query ID */));
+ unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(0 /* dummy query ID */, join_hash_table_index));
cleaner->informAllBlockingDependenciesMet();
fetchAndExecuteWorkOrders(cleaner.get());
@@ -475,12 +475,12 @@ TEST_P(HashJoinOperatorTest, IntDuplicateKeyHashJoinTest) {
// Create the builder operator.
unique_ptr<BuildHashOperator> builder(
- new BuildHashOperator(*dim_table_,
+ new BuildHashOperator(0, /* dummy query ID */
+ *dim_table_,
true /* is_stored */,
std::vector<attribute_id>(1, dim_col_int.getID()),
dim_col_int.getType().isNullable(),
- join_hash_table_index,
- 0)); // dummy query ID
+ join_hash_table_index));
// Create the prober operator with two selection attributes.
const QueryContext::scalar_group_id selection_index = query_context_proto.scalar_groups_size();
@@ -507,18 +507,19 @@ TEST_P(HashJoinOperatorTest, IntDuplicateKeyHashJoinTest) {
insert_destination_proto->set_relation_id(output_relation_id);
insert_destination_proto->set_relational_op_index(kOpIndex);
- unique_ptr<HashJoinOperator> prober(
- new HashJoinOperator(*dim_table_,
- *fact_table_,
- true /* is_stored */,
- std::vector<attribute_id>(1, fact_col_int.getID()),
- fact_col_int.getType().isNullable(),
- *result_table,
- output_destination_index,
- join_hash_table_index,
- QueryContext::kInvalidPredicateId /* residual_predicate_index */,
- selection_index,
- 0 /* dummy query ID */));
+ unique_ptr<HashJoinOperator> prober(new HashJoinOperator(
+ 0 /* dummy query ID */,
+ *dim_table_,
+ *fact_table_,
+ true /* is_stored */,
+ std::vector<attribute_id>(1, fact_col_int.getID()),
+ fact_col_int.getType().isNullable(),
+ *result_table,
+ output_destination_index,
+ join_hash_table_index,
+ QueryContext::kInvalidPredicateId /* residual_predicate_index */,
+ selection_index));
+
// Set up the QueryContext.
query_context_.reset(new QueryContext(query_context_proto,
@@ -592,7 +593,7 @@ TEST_P(HashJoinOperatorTest, IntDuplicateKeyHashJoinTest) {
}
// Create cleaner operator.
- unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(join_hash_table_index, 0 /* dummy query ID */));
+ unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(0 /* dummy query ID */, join_hash_table_index));
cleaner->informAllBlockingDependenciesMet();
fetchAndExecuteWorkOrders(cleaner.get());
@@ -636,12 +637,12 @@ TEST_P(HashJoinOperatorTest, CharKeyCartesianProductHashJoinTest) {
// Create builder operator.
unique_ptr<BuildHashOperator> builder(
- new BuildHashOperator(*dim_table_,
+ new BuildHashOperator(0, /* dummy query ID */
+ *dim_table_,
true /* is_stored */,
std::vector<attribute_id>(1, dim_col_char.getID()),
dim_col_char.getType().isNullable(),
- join_hash_table_index,
- 0)); // dummy query ID.
+ join_hash_table_index));
// Create prober operator with one selection attribute.
const QueryContext::scalar_group_id selection_index = query_context_proto.scalar_groups_size();
@@ -663,18 +664,18 @@ TEST_P(HashJoinOperatorTest, CharKeyCartesianProductHashJoinTest) {
insert_destination_proto->set_relation_id(output_relation_id);
insert_destination_proto->set_relational_op_index(kOpIndex);
- unique_ptr<HashJoinOperator> prober(
- new HashJoinOperator(*dim_table_,
- *fact_table_,
- true /* is_stored */,
- std::vector<attribute_id>(1, fact_col_char.getID()),
- fact_col_char.getType().isNullable(),
- *result_table,
- output_destination_index,
- join_hash_table_index,
- QueryContext::kInvalidPredicateId /* residual_predicate_index */,
- selection_index,
- 0 /* dummy query ID */));
+ unique_ptr<HashJoinOperator> prober(new HashJoinOperator(
+ 0 /* dummy query ID */,
+ *dim_table_,
+ *fact_table_,
+ true /* is_stored */,
+ std::vector<attribute_id>(1, fact_col_char.getID()),
+ fact_col_char.getType().isNullable(),
+ *result_table,
+ output_destination_index,
+ join_hash_table_index,
+ QueryContext::kInvalidPredicateId /* residual_predicate_index */,
+ selection_index));
// Set up the QueryContext.
query_context_.reset(new QueryContext(query_context_proto,
@@ -727,7 +728,7 @@ TEST_P(HashJoinOperatorTest, CharKeyCartesianProductHashJoinTest) {
}
// Create cleaner operator.
- unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(join_hash_table_index, 0 /* dummy query ID */));
+ unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(0 /* dummy query ID */, join_hash_table_index));
cleaner->informAllBlockingDependenciesMet();
fetchAndExecuteWorkOrders(cleaner.get());
@@ -772,12 +773,12 @@ TEST_P(HashJoinOperatorTest, VarCharDuplicateKeyHashJoinTest) {
// Create builder operator.
unique_ptr<BuildHashOperator> builder(
- new BuildHashOperator(*dim_table_,
+ new BuildHashOperator(0, /* dummy query ID */
+ *dim_table_,
true /* is_stored */,
std::vector<attribute_id>(1, dim_col_varchar.getID()),
dim_col_varchar.getType().isNullable(),
- join_hash_table_index,
- 0)); // dummy query ID.
+ join_hash_table_index));
// Create prober operator with two selection attributes.
const QueryContext::scalar_group_id selection_index = query_context_proto.scalar_groups_size();
@@ -804,18 +805,19 @@ TEST_P(HashJoinOperatorTest, VarCharDuplicateKeyHashJoinTest) {
insert_destination_proto->set_relation_id(output_relation_id);
insert_destination_proto->set_relational_op_index(kOpIndex);
- unique_ptr<HashJoinOperator> prober(
- new HashJoinOperator(*dim_table_,
- *fact_table_,
- true /* is_stored */,
- std::vector<attribute_id>(1, fact_col_varchar.getID()),
- fact_col_varchar.getType().isNullable(),
- *result_table,
- output_destination_index,
- join_hash_table_index,
- QueryContext::kInvalidPredicateId /* residual_predicate_index */,
- selection_index,
- 0 /* dummy query ID */));
+ unique_ptr<HashJoinOperator> prober(new HashJoinOperator(
+ 0 /* dummy query ID */,
+ *dim_table_,
+ *fact_table_,
+ true /* is_stored */,
+ std::vector<attribute_id>(1, fact_col_varchar.getID()),
+ fact_col_varchar.getType().isNullable(),
+ *result_table,
+ output_destination_index,
+ join_hash_table_index,
+ QueryContext::kInvalidPredicateId /* residual_predicate_index */,
+ selection_index));
+
// Set up the QueryContext.
query_context_.reset(new QueryContext(query_context_proto,
@@ -893,7 +895,7 @@ TEST_P(HashJoinOperatorTest, VarCharDuplicateKeyHashJoinTest) {
}
// Create the cleaner operator.
- unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(join_hash_table_index, 0 /* dummy query ID */));
+ unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(0 /* dummy query ID */, join_hash_table_index));
cleaner->informAllBlockingDependenciesMet();
fetchAndExecuteWorkOrders(cleaner.get());
@@ -943,12 +945,12 @@ TEST_P(HashJoinOperatorTest, CompositeKeyHashJoinTest) {
dim_key_attrs.push_back(dim_col_varchar.getID());
unique_ptr<BuildHashOperator> builder(
- new BuildHashOperator(*dim_table_,
+ new BuildHashOperator(0, /* dummy query ID */
+ *dim_table_,
true /* is_stored */,
dim_key_attrs,
dim_col_long.getType().isNullable() || dim_col_varchar.getType().isNullable(),
- join_hash_table_index,
- 0)); // dummy query ID.
+ join_hash_table_index));
// Create the prober operator with two selection attributes.
const QueryContext::scalar_group_id selection_index = query_context_proto.scalar_groups_size();
@@ -979,18 +981,19 @@ TEST_P(HashJoinOperatorTest, CompositeKeyHashJoinTest) {
fact_key_attrs.push_back(fact_col_long.getID());
fact_key_attrs.push_back(fact_col_varchar.getID());
- unique_ptr<HashJoinOperator> prober(
- new HashJoinOperator(*dim_table_,
- *fact_table_,
- true /* is_stored */,
- fact_key_attrs,
- fact_col_long.getType().isNullable() || fact_col_varchar.getType().isNullable(),
- *result_table,
- output_destination_index,
- join_hash_table_index,
- QueryContext::kInvalidPredicateId /* residual_predicate_index */,
- selection_index,
- 0 /* dummy query ID */));
+ unique_ptr<HashJoinOperator> prober(new HashJoinOperator(
+ 0 /* dummy query ID */,
+ *dim_table_,
+ *fact_table_,
+ true /* is_stored */,
+ fact_key_attrs,
+ fact_col_long.getType().isNullable() ||
+ fact_col_varchar.getType().isNullable(),
+ *result_table,
+ output_destination_index,
+ join_hash_table_index,
+ QueryContext::kInvalidPredicateId /* residual_predicate_index */,
+ selection_index));
// Set up the QueryContext.
query_context_.reset(new QueryContext(query_context_proto,
@@ -1068,7 +1071,7 @@ TEST_P(HashJoinOperatorTest, CompositeKeyHashJoinTest) {
}
// Create cleaner operator.
- unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(join_hash_table_index, 0 /* dummy query ID */));
+ unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(0 /* dummy query ID */, join_hash_table_index));
cleaner->informAllBlockingDependenciesMet();
fetchAndExecuteWorkOrders(cleaner.get());
@@ -1119,12 +1122,12 @@ TEST_P(HashJoinOperatorTest, CompositeKeyHashJoinWithResidualPredicateTest) {
dim_key_attrs.push_back(dim_col_varchar.getID());
unique_ptr<BuildHashOperator> builder(
- new BuildHashOperator(*dim_table_,
+ new BuildHashOperator(0, /* dummy query ID */
+ *dim_table_,
true /* is_stored */,
dim_key_attrs,
dim_col_long.getType().isNullable() || dim_col_varchar.getType().isNullable(),
- join_hash_table_index,
- 0)); // dummy query ID.
+ join_hash_table_index));
// Create prober operator with two selection attributes.
const QueryContext::scalar_group_id selection_index = query_context_proto.scalar_groups_size();
@@ -1166,17 +1169,18 @@ TEST_P(HashJoinOperatorTest, CompositeKeyHashJoinWithResidualPredicateTest) {
query_context_proto.add_predicates()->CopyFrom(residual_pred->getProto());
unique_ptr<HashJoinOperator> prober(
- new HashJoinOperator(*dim_table_,
+ new HashJoinOperator(0 /* dummy query ID */,
+ *dim_table_,
*fact_table_,
true /* is_stored */,
fact_key_attrs,
- fact_col_long.getType().isNullable() || fact_col_varchar.getType().isNullable(),
+ fact_col_long.getType().isNullable() ||
+ fact_col_varchar.getType().isNullable(),
*result_table,
output_destination_index,
join_hash_table_index,
residual_pred_index,
- selection_index,
- 0 /* dummy query ID */));
+ selection_index));
// Set up the QueryContext.
query_context_.reset(new QueryContext(query_context_proto,
@@ -1254,7 +1258,7 @@ TEST_P(HashJoinOperatorTest, CompositeKeyHashJoinWithResidualPredicateTest) {
}
// Create cleaner operator.
- unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(join_hash_table_index, 0 /* dummy query ID */));
+ unique_ptr<DestroyHashOperator> cleaner(new DestroyHashOperator(0 /* dummy query ID */, join_hash_table_index));
cleaner->informAllBlockingDependenciesMet();
fetchAndExecuteWorkOrders(cleaner.get());
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/tests/SortMergeRunOperator_unittest.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/tests/SortMergeRunOperator_unittest.cpp b/relational_operators/tests/SortMergeRunOperator_unittest.cpp
index 244091f..37f155c 100644
--- a/relational_operators/tests/SortMergeRunOperator_unittest.cpp
+++ b/relational_operators/tests/SortMergeRunOperator_unittest.cpp
@@ -1565,7 +1565,8 @@ class SortMergeRunOperatorTest : public ::testing::Test {
const std::size_t top_k = 0) {
const QueryContext::sort_config_id sort_config_index = createSortConfigProto(attrs, ordering, null_ordering);
- merge_op_.reset(new SortMergeRunOperator(*input_table_,
+ merge_op_.reset(new SortMergeRunOperator(0 /* dummy query ID */,
+ *input_table_,
*result_table_,
insert_destination_index_,
*run_table_,
@@ -1573,8 +1574,8 @@ class SortMergeRunOperatorTest : public ::testing::Test {
sort_config_index,
merge_factor,
top_k,
- true,
- 0 /* dummy query ID */));
+ true));
+
merge_op_->setOperatorIndex(kOpIndex);
// Set up the QueryContext.
@@ -1609,7 +1610,8 @@ class SortMergeRunOperatorTest : public ::testing::Test {
const std::size_t top_k = 0) {
const QueryContext::sort_config_id sort_config_index = createSortConfigProto(attrs, ordering, null_ordering);
- merge_op_.reset(new SortMergeRunOperator(*input_table_,
+ merge_op_.reset(new SortMergeRunOperator(0 /* dummy query ID */,
+ *input_table_,
*result_table_,
insert_destination_index_,
*run_table_,
@@ -1617,8 +1619,7 @@ class SortMergeRunOperatorTest : public ::testing::Test {
sort_config_index,
merge_factor,
top_k,
- false,
- 0 /* dummy query ID */));
+ false));
merge_op_->setOperatorIndex(kOpIndex);
// Set up the QueryContext.
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/tests/SortRunGenerationOperator_unittest.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/tests/SortRunGenerationOperator_unittest.cpp b/relational_operators/tests/SortRunGenerationOperator_unittest.cpp
index 6f24b92..846c472 100644
--- a/relational_operators/tests/SortRunGenerationOperator_unittest.cpp
+++ b/relational_operators/tests/SortRunGenerationOperator_unittest.cpp
@@ -353,13 +353,14 @@ class SortRunGenerationOperatorTest : public ::testing::Test {
order_by_proto->set_null_first(null_ordering[i]);
}
- std::unique_ptr<RelationalOperator> run_gen(
- new SortRunGenerationOperator(*input_table_,
- *result_table_,
- insert_destination_index,
- sort_config_index,
- true /* is_stored */,
- 0 /* dummy query ID */));
+ std::unique_ptr<RelationalOperator> run_gen(new SortRunGenerationOperator(
+ 0 /* dummy query ID */,
+ *input_table_,
+ *result_table_,
+ insert_destination_index,
+ sort_config_index,
+ true /* is_stored */));
+
run_gen->setOperatorIndex(kOpIndex);
// Set up the QueryContext.
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/tests/TextScanOperator_unittest.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/tests/TextScanOperator_unittest.cpp b/relational_operators/tests/TextScanOperator_unittest.cpp
index 7626686..15697f8 100644
--- a/relational_operators/tests/TextScanOperator_unittest.cpp
+++ b/relational_operators/tests/TextScanOperator_unittest.cpp
@@ -188,13 +188,13 @@ TEST_F(TextScanOperatorTest, ScanTest) {
output_destination_proto->set_relational_op_index(kOpIndex);
std::unique_ptr<TextScanOperator> text_scan_op(
- new TextScanOperator(input_filename,
+ new TextScanOperator(0 /* dummy query ID */,
+ input_filename,
'\t',
true,
false,
*relation_,
- output_destination_index,
- 0 /* dummy query ID */));
+ output_destination_index));
// Setup query_context_.
query_context_.reset(new QueryContext(query_context_proto,
[3/3] incubator-quickstep git commit: Reordered query ID in operators
and work orders.
Posted by hb...@apache.org.
Reordered query ID in operators and work orders.
Reordered query ID in CreateIndex.
Reordered query ID in delete.
Reordered query ID in destroy hash.
Reordered query ID in Drop table.
Reordered query ID in Finalize aggregate
Reordered query ID in hash join
Reordered query ID in insert op
Reordered query ID in nested loops
Reordered query ID in rebuild
Reordered query ID in sample
Reordered query ID in save blocks
Reordered query ID in select
Reordered query ID in sort merge
Reordered query ID in sort run
Reordered query ID in table gen
Reorder query ID in text scan
Reordered query ID in update
Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/d67f61e1
Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/d67f61e1
Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/d67f61e1
Branch: refs/heads/reorder-query-id-param
Commit: d67f61e1651cb68243d78728cc1ce6c68bb08fb1
Parents: 15a2114
Author: Harshad Deshmukh <hb...@apache.org>
Authored: Wed Jun 8 09:36:18 2016 -0500
Committer: Harshad Deshmukh <hb...@apache.org>
Committed: Wed Jun 8 11:38:06 2016 -0500
----------------------------------------------------------------------
query_execution/Foreman.cpp | 12 +-
query_execution/QueryManager.cpp | 12 +-
query_optimizer/ExecutionGenerator.cpp | 189 +++++++--------
.../tests/ExecutionHeuristics_unittest.cpp | 29 +--
relational_operators/BuildHashOperator.cpp | 6 +-
relational_operators/BuildHashOperator.hpp | 20 +-
relational_operators/CreateIndexOperator.hpp | 6 +-
relational_operators/DeleteOperator.cpp | 8 +-
relational_operators/DeleteOperator.hpp | 14 +-
relational_operators/DestroyHashOperator.cpp | 2 +-
relational_operators/DestroyHashOperator.hpp | 12 +-
relational_operators/DropTableOperator.hpp | 6 +-
.../FinalizeAggregationOperator.hpp | 11 +-
relational_operators/HashJoinOperator.cpp | 31 +--
relational_operators/HashJoinOperator.hpp | 227 ++++++++++---------
relational_operators/InsertOperator.hpp | 11 +-
.../NestedLoopsJoinOperator.cpp | 45 ++--
.../NestedLoopsJoinOperator.hpp | 52 +++--
relational_operators/RebuildWorkOrder.hpp | 15 +-
relational_operators/SampleOperator.cpp | 51 +++--
relational_operators/SampleOperator.hpp | 26 ++-
relational_operators/SaveBlocksOperator.cpp | 2 +-
relational_operators/SaveBlocksOperator.hpp | 6 +-
relational_operators/SelectOperator.cpp | 27 ++-
relational_operators/SelectOperator.hpp | 56 ++---
relational_operators/SortMergeRunOperator.cpp | 2 +-
relational_operators/SortMergeRunOperator.hpp | 27 +--
.../SortRunGenerationOperator.cpp | 6 +-
.../SortRunGenerationOperator.hpp | 26 ++-
relational_operators/TableGeneratorOperator.cpp | 2 +-
relational_operators/TableGeneratorOperator.hpp | 20 +-
relational_operators/TextScanOperator.cpp | 21 +-
relational_operators/TextScanOperator.hpp | 32 +--
relational_operators/UpdateOperator.cpp | 22 +-
relational_operators/UpdateOperator.hpp | 37 +--
relational_operators/WorkOrderFactory.cpp | 38 ++--
.../tests/AggregationOperator_unittest.cpp | 18 +-
.../tests/HashJoinOperator_unittest.cpp | 180 ++++++++-------
.../tests/SortMergeRunOperator_unittest.cpp | 13 +-
.../SortRunGenerationOperator_unittest.cpp | 15 +-
.../tests/TextScanOperator_unittest.cpp | 6 +-
41 files changed, 695 insertions(+), 646 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/query_execution/Foreman.cpp
----------------------------------------------------------------------
diff --git a/query_execution/Foreman.cpp b/query_execution/Foreman.cpp
index b358f70..7705819 100644
--- a/query_execution/Foreman.cpp
+++ b/query_execution/Foreman.cpp
@@ -521,12 +521,12 @@ void Foreman::getRebuildWorkOrders(const dag_node_index index, WorkOrdersContain
// Note: The query ID used below is dummy for now, it will be replaced with
// the true query ID when QueryManager gets used in Foreman.
container->addRebuildWorkOrder(
- new RebuildWorkOrder(move(partially_filled_block_refs[i]),
- index,
- op.getOutputRelationID(),
- foreman_client_id_,
- 0,
- bus_),
+ new RebuildWorkOrder(0,
+ move(partially_filled_block_refs[i]),
+ index,
+ op.getOutputRelationID(),
+ foreman_client_id_,
+ bus_),
index);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/query_execution/QueryManager.cpp
----------------------------------------------------------------------
diff --git a/query_execution/QueryManager.cpp b/query_execution/QueryManager.cpp
index 21f5820..e4e4c9d 100644
--- a/query_execution/QueryManager.cpp
+++ b/query_execution/QueryManager.cpp
@@ -457,12 +457,12 @@ void QueryManager::getRebuildWorkOrders(const dag_node_index index,
i < partially_filled_block_refs.size();
++i) {
container->addRebuildWorkOrder(
- new RebuildWorkOrder(std::move(partially_filled_block_refs[i]),
- index,
- op.getOutputRelationID(),
- foreman_client_id_,
- query_id_,
- bus_),
+ new RebuildWorkOrder(query_id_,
+ std::move(partially_filled_block_refs[i]),
+ index,
+ op.getOutputRelationID(),
+ foreman_client_id_,
+ bus_),
index);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/query_optimizer/ExecutionGenerator.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/ExecutionGenerator.cpp b/query_optimizer/ExecutionGenerator.cpp
index 56625fd..99c2a21 100644
--- a/query_optimizer/ExecutionGenerator.cpp
+++ b/query_optimizer/ExecutionGenerator.cpp
@@ -193,8 +193,8 @@ void ExecutionGenerator::generatePlan(const P::PhysicalPtr &physical_plan) {
}
const QueryPlan::DAGNodeIndex drop_table_index =
execution_plan_->addRelationalOperator(
- new DropTableOperator(*temporary_relation,
- query_handle_->query_id(),
+ new DropTableOperator(query_handle_->query_id(),
+ *temporary_relation,
optimizer_context_->catalog_database(),
false /* only_drop_blocks */));
DCHECK(!temporary_relation_info.isStoredRelation());
@@ -411,13 +411,14 @@ void ExecutionGenerator::convertSample(const P::SamplePtr &physical_sample) {
findRelationInfoOutputByPhysical(physical_sample->input());
DCHECK(input_relation_info != nullptr);
- SampleOperator *sample_op = new SampleOperator(*input_relation_info->relation,
- *output_relation,
- insert_destination_index,
- input_relation_info->isStoredRelation(),
- physical_sample->is_block_sample(),
- physical_sample->percentage(),
- query_handle_->query_id());
+ SampleOperator *sample_op =
+ new SampleOperator(query_handle_->query_id(),
+ *input_relation_info->relation,
+ *output_relation,
+ insert_destination_index,
+ input_relation_info->isStoredRelation(),
+ physical_sample->is_block_sample(),
+ physical_sample->percentage());
const QueryPlan::DAGNodeIndex sample_index =
execution_plan_->addRelationalOperator(sample_op);
insert_destination_proto->set_relational_op_index(sample_index);
@@ -526,22 +527,22 @@ void ExecutionGenerator::convertSelection(
// doesn't require any expression evaluation or intermediate copies) if
// possible.
std::vector<attribute_id> attributes;
- SelectOperator *op
- = convertSimpleProjection(project_expressions_group_index, &attributes)
- ? new SelectOperator(*input_relation_info->relation,
- *output_relation,
- insert_destination_index,
- execution_predicate_index,
- move(attributes),
- input_relation_info->isStoredRelation(),
- query_handle_->query_id())
- : new SelectOperator(*input_relation_info->relation,
- *output_relation,
- insert_destination_index,
- execution_predicate_index,
- project_expressions_group_index,
- input_relation_info->isStoredRelation(),
- query_handle_->query_id());
+ SelectOperator *op =
+ convertSimpleProjection(project_expressions_group_index, &attributes)
+ ? new SelectOperator(query_handle_->query_id(),
+ *input_relation_info->relation,
+ *output_relation,
+ insert_destination_index,
+ execution_predicate_index,
+ move(attributes),
+ input_relation_info->isStoredRelation())
+ : new SelectOperator(query_handle_->query_id(),
+ *input_relation_info->relation,
+ *output_relation,
+ insert_destination_index,
+ execution_predicate_index,
+ project_expressions_group_index,
+ input_relation_info->isStoredRelation());
const QueryPlan::DAGNodeIndex select_index =
execution_plan_->addRelationalOperator(op);
@@ -741,12 +742,12 @@ void ExecutionGenerator::convertHashJoin(const P::HashJoinPtr &physical_plan) {
const QueryPlan::DAGNodeIndex build_operator_index =
execution_plan_->addRelationalOperator(
new BuildHashOperator(
+ query_handle_->query_id(),
*build_relation_info->relation,
build_relation_info->isStoredRelation(),
build_attribute_ids,
any_build_attributes_nullable,
- join_hash_table_index,
- query_handle_->query_id()));
+ join_hash_table_index));
// Create InsertDestination proto.
const CatalogRelation *output_relation = nullptr;
@@ -782,6 +783,7 @@ void ExecutionGenerator::convertHashJoin(const P::HashJoinPtr &physical_plan) {
const QueryPlan::DAGNodeIndex join_operator_index =
execution_plan_->addRelationalOperator(
new HashJoinOperator(
+ query_handle_->query_id(),
*build_relation_info->relation,
*probe_operator_info->relation,
probe_operator_info->isStoredRelation(),
@@ -792,14 +794,13 @@ void ExecutionGenerator::convertHashJoin(const P::HashJoinPtr &physical_plan) {
join_hash_table_index,
residual_predicate_index,
project_expressions_group_index,
- query_handle_->query_id(),
is_selection_on_build.get(),
join_type));
insert_destination_proto->set_relational_op_index(join_operator_index);
const QueryPlan::DAGNodeIndex destroy_operator_index =
execution_plan_->addRelationalOperator(new DestroyHashOperator(
- join_hash_table_index, query_handle_->query_id()));
+ query_handle_->query_id(), join_hash_table_index));
if (!build_relation_info->isStoredRelation()) {
execution_plan_->addDirectDependency(build_operator_index,
@@ -885,16 +886,16 @@ void ExecutionGenerator::convertNestedLoopsJoin(
// Create and add a NestedLoopsJoin operator.
const QueryPlan::DAGNodeIndex join_operator_index =
- execution_plan_->addRelationalOperator(new NestedLoopsJoinOperator(
- *left_relation_info->relation,
- *right_relation_info->relation,
- *output_relation,
- insert_destination_index,
- execution_join_predicate_index,
- project_expressions_group_index,
- left_relation_info->isStoredRelation(),
- right_relation_info->isStoredRelation(),
- query_handle_->query_id()));
+ execution_plan_->addRelationalOperator(
+ new NestedLoopsJoinOperator(query_handle_->query_id(),
+ *left_relation_info->relation,
+ *right_relation_info->relation,
+ *output_relation,
+ insert_destination_index,
+ execution_join_predicate_index,
+ project_expressions_group_index,
+ left_relation_info->isStoredRelation(),
+ right_relation_info->isStoredRelation()));
insert_destination_proto->set_relational_op_index(join_operator_index);
if (!left_relation_info->isStoredRelation()) {
@@ -940,13 +941,13 @@ void ExecutionGenerator::convertCopyFrom(
const QueryPlan::DAGNodeIndex scan_operator_index =
execution_plan_->addRelationalOperator(
new TextScanOperator(
+ query_handle_->query_id(),
physical_plan->file_name(),
physical_plan->column_delimiter(),
physical_plan->escape_strings(),
FLAGS_parallelize_load,
*output_relation,
- insert_destination_index,
- query_handle_->query_id()));
+ insert_destination_index));
insert_destination_proto->set_relational_op_index(scan_operator_index);
const QueryPlan::DAGNodeIndex save_blocks_operator_index =
@@ -997,10 +998,11 @@ void ExecutionGenerator::convertCreateIndex(
// Check if the given index description is valid.
THROW_SQL_ERROR() << "The index with given properties cannot be created.";
}
- execution_plan_->addRelationalOperator(new CreateIndexOperator(input_relation,
- physical_plan->index_name(),
- query_handle_->query_id(),
- std::move(index_description)));
+ execution_plan_->addRelationalOperator(
+ new CreateIndexOperator(query_handle_->query_id(),
+ input_relation,
+ physical_plan->index_name(),
+ std::move(index_description)));
}
void ExecutionGenerator::convertCreateTable(
@@ -1067,8 +1069,8 @@ void ExecutionGenerator::convertDeleteTuples(
execution_predicate->getStaticResult())) {
const QueryPlan::DAGNodeIndex drop_table_index =
execution_plan_->addRelationalOperator(
- new DropTableOperator(*input_relation_info->relation,
- query_handle_->query_id(),
+ new DropTableOperator(query_handle_->query_id(),
+ *input_relation_info->relation,
optimizer_context_->catalog_database(),
true /* only_drop_blocks */));
if (!input_relation_info->isStoredRelation()) {
@@ -1081,11 +1083,12 @@ void ExecutionGenerator::convertDeleteTuples(
query_context_proto_->add_predicates()->CopyFrom(execution_predicate->getProto());
const QueryPlan::DAGNodeIndex delete_tuples_index =
- execution_plan_->addRelationalOperator(new DeleteOperator(
- *input_relation_info->relation,
- execution_predicate_index,
- input_relation_info->isStoredRelation(),
- query_handle_->query_id()));
+ execution_plan_->addRelationalOperator(
+ new DeleteOperator(query_handle_->query_id(),
+ *input_relation_info->relation,
+ execution_predicate_index,
+ input_relation_info->isStoredRelation()));
+
if (!input_relation_info->isStoredRelation()) {
execution_plan_->addDirectDependency(delete_tuples_index,
input_relation_info->producer_operator_index,
@@ -1111,8 +1114,8 @@ void ExecutionGenerator::convertDropTable(
#endif
execution_plan_->addRelationalOperator(
- new DropTableOperator(catalog_relation,
- query_handle_->query_id(),
+ new DropTableOperator(query_handle_->query_id(),
+ catalog_relation,
optimizer_context_->catalog_database()));
}
@@ -1164,10 +1167,10 @@ void ExecutionGenerator::convertInsertTuple(
const QueryPlan::DAGNodeIndex insert_operator_index =
execution_plan_->addRelationalOperator(
- new InsertOperator(input_relation,
+ new InsertOperator(query_handle_->query_id(),
+ input_relation,
insert_destination_index,
- tuple_index,
- query_handle_->query_id()));
+ tuple_index));
insert_destination_proto->set_relational_op_index(insert_operator_index);
const QueryPlan::DAGNodeIndex save_blocks_index =
@@ -1240,13 +1243,13 @@ void ExecutionGenerator::convertInsertSelection(
// optimization is to enable specifying a specific output relation for each
// physical plan by modifying class Physical.
SelectOperator *insert_selection_op =
- new SelectOperator(*selection_relation_info->relation,
+ new SelectOperator(query_handle_->query_id(),
+ *selection_relation_info->relation,
destination_relation,
insert_destination_index,
QueryContext::kInvalidPredicateId,
move(attributes),
- selection_relation_info->isStoredRelation(),
- query_handle_->query_id());
+ selection_relation_info->isStoredRelation());
const QueryPlan::DAGNodeIndex insert_selection_index =
execution_plan_->addRelationalOperator(insert_selection_op);
@@ -1321,13 +1324,13 @@ void ExecutionGenerator::convertUpdateTable(
}
const QueryPlan::DAGNodeIndex update_operator_index =
- execution_plan_->addRelationalOperator(
- new UpdateOperator(
- *optimizer_context_->catalog_database()->getRelationById(input_rel_id),
- relocation_destination_index,
- execution_predicate_index,
- update_group_index,
- query_handle_->query_id()));
+ execution_plan_->addRelationalOperator(new UpdateOperator(
+ query_handle_->query_id(),
+ *optimizer_context_->catalog_database()->getRelationById(
+ input_rel_id),
+ relocation_destination_index,
+ execution_predicate_index,
+ update_group_index));
relocation_destination_proto->set_relational_op_index(update_operator_index);
const QueryPlan::DAGNodeIndex save_blocks_index =
@@ -1451,10 +1454,11 @@ void ExecutionGenerator::convertAggregate(
const QueryPlan::DAGNodeIndex finalize_aggregation_operator_index =
execution_plan_->addRelationalOperator(
- new FinalizeAggregationOperator(aggr_state_index,
+ new FinalizeAggregationOperator(query_handle_->query_id(),
+ aggr_state_index,
*output_relation,
- insert_destination_index,
- query_handle_->query_id()));
+ insert_destination_index));
+
insert_destination_proto->set_relational_op_index(finalize_aggregation_operator_index);
execution_plan_->addDirectDependency(finalize_aggregation_operator_index,
@@ -1500,13 +1504,13 @@ void ExecutionGenerator::convertSort(const P::SortPtr &physical_sort) {
const CatalogRelationInfo *input_relation_info =
findRelationInfoOutputByPhysical(physical_sort->input());
const QueryPlan::DAGNodeIndex run_generator_index =
- execution_plan_->addRelationalOperator(
- new SortRunGenerationOperator(*input_relation_info->relation,
- *initial_runs_relation,
- initial_runs_destination_id,
- sort_run_gen_config_id,
- input_relation_info->isStoredRelation(),
- query_handle_->query_id()));
+ execution_plan_->addRelationalOperator(new SortRunGenerationOperator(
+ query_handle_->query_id(),
+ *input_relation_info->relation,
+ *initial_runs_relation,
+ initial_runs_destination_id,
+ sort_run_gen_config_id,
+ input_relation_info->isStoredRelation()));
if (!input_relation_info->isStoredRelation()) {
execution_plan_->addDirectDependency(run_generator_index,
input_relation_info->producer_operator_index,
@@ -1554,17 +1558,18 @@ void ExecutionGenerator::convertSort(const P::SortPtr &physical_sort) {
// TODO(qzeng): Make the merge factor configurable.
const QueryPlan::DAGNodeIndex merge_run_operator_index =
- execution_plan_->addRelationalOperator(
- new SortMergeRunOperator(*initial_runs_relation,
- *sorted_relation,
- sorted_output_destination_id,
- *merged_runs_relation,
- merged_runs_destination_id,
- sort_merge_run_config_id,
- 64 /* merge_factor */,
- physical_sort->limit(),
- false /* input_relation_is_stored */,
- query_handle_->query_id()));
+ execution_plan_->addRelationalOperator(new SortMergeRunOperator(
+ query_handle_->query_id(),
+ *initial_runs_relation,
+ *sorted_relation,
+ sorted_output_destination_id,
+ *merged_runs_relation,
+ merged_runs_destination_id,
+ sort_merge_run_config_id,
+ 64 /* merge_factor */,
+ physical_sort->limit(),
+ false /* input_relation_is_stored */));
+
execution_plan_->addDirectDependency(merge_run_operator_index,
run_generator_index,
false /* is_pipeline_breaker */);
@@ -1577,8 +1582,8 @@ void ExecutionGenerator::convertSort(const P::SortPtr &physical_sort) {
const QueryPlan::DAGNodeIndex drop_merged_runs_index =
execution_plan_->addRelationalOperator(
new DropTableOperator(
- *merged_runs_relation,
query_handle_->query_id(),
+ *merged_runs_relation,
optimizer_context_->catalog_database(),
false /* only_drop_blocks */));
execution_plan_->addDirectDependency(
@@ -1614,10 +1619,10 @@ void ExecutionGenerator::convertTableGenerator(
physical_tablegen->generator_function_handle()->getProto());
TableGeneratorOperator *op =
- new TableGeneratorOperator(*output_relation,
+ new TableGeneratorOperator(query_handle_->query_id(),
+ *output_relation,
insert_destination_index,
- generator_function_index,
- query_handle_->query_id());
+ generator_function_index);
const QueryPlan::DAGNodeIndex tablegen_index =
execution_plan_->addRelationalOperator(op);
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/query_optimizer/tests/ExecutionHeuristics_unittest.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/tests/ExecutionHeuristics_unittest.cpp b/query_optimizer/tests/ExecutionHeuristics_unittest.cpp
index a08a476..39130b8 100644
--- a/query_optimizer/tests/ExecutionHeuristics_unittest.cpp
+++ b/query_optimizer/tests/ExecutionHeuristics_unittest.cpp
@@ -75,12 +75,12 @@ class ExecutionHeuristicsTest : public ::testing::Test {
std::vector<attribute_id> build_attribute_ids;
build_attribute_ids.push_back(build_attribute_id);
QueryPlan::DAGNodeIndex build_operator_index =
- query_plan->addRelationalOperator(new BuildHashOperator(*build_relation,
+ query_plan->addRelationalOperator(new BuildHashOperator(0, /* dummy query ID */
+ *build_relation,
true,
build_attribute_ids,
false,
- join_hash_table_index,
- 0 /* dummy query ID */));
+ join_hash_table_index));
return build_operator_index;
}
@@ -92,17 +92,18 @@ class ExecutionHeuristicsTest : public ::testing::Test {
std::vector<attribute_id> probe_attribute_ids;
probe_attribute_ids.push_back(probe_attribute_id);
QueryPlan::DAGNodeIndex join_operator_index =
- query_plan->addRelationalOperator(new HashJoinOperator(*build_relation,
- *probe_relation,
- true,
- probe_attribute_ids,
- false,
- *probe_relation,
- 0,
- join_hash_table_index,
- 0,
- 0,
- 0 /* dummy query ID */));
+ query_plan->addRelationalOperator(
+ new HashJoinOperator(0 /* dummy query ID */,
+ *build_relation,
+ *probe_relation,
+ true,
+ probe_attribute_ids,
+ false,
+ *probe_relation,
+ 0,
+ join_hash_table_index,
+ 0,
+ 0));
return join_operator_index;
}
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/BuildHashOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/BuildHashOperator.cpp b/relational_operators/BuildHashOperator.cpp
index c6f6f96..9dc4afe 100644
--- a/relational_operators/BuildHashOperator.cpp
+++ b/relational_operators/BuildHashOperator.cpp
@@ -69,11 +69,11 @@ bool BuildHashOperator::getAllWorkOrders(
if (!started_) {
for (const block_id input_block_id : input_relation_block_ids_) {
container->addNormalWorkOrder(
- new BuildHashWorkOrder(input_relation_,
+ new BuildHashWorkOrder(query_id_,
+ input_relation_,
join_key_attributes_,
any_join_key_attributes_nullable_,
input_block_id,
- query_id_,
hash_table,
storage_manager),
op_index_);
@@ -85,11 +85,11 @@ bool BuildHashOperator::getAllWorkOrders(
while (num_workorders_generated_ < input_relation_block_ids_.size()) {
container->addNormalWorkOrder(
new BuildHashWorkOrder(
+ query_id_,
input_relation_,
join_key_attributes_,
any_join_key_attributes_nullable_,
input_relation_block_ids_[num_workorders_generated_],
- query_id_,
hash_table,
storage_manager),
op_index_);
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/BuildHashOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/BuildHashOperator.hpp b/relational_operators/BuildHashOperator.hpp
index 5a46d8b..50dd7d6 100644
--- a/relational_operators/BuildHashOperator.hpp
+++ b/relational_operators/BuildHashOperator.hpp
@@ -59,6 +59,7 @@ class BuildHashOperator : public RelationalOperator {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param input_relation The relation to build hash table on.
* @param input_relation_is_stored If input_relation is a stored relation and
* is fully available to the operator before it can start generating
@@ -69,14 +70,13 @@ class BuildHashOperator : public RelationalOperator {
* @param hash_table_index The index of the JoinHashTable in QueryContext.
* The HashTable's key Type(s) should be the Type(s) of the
* join_key_attributes in input_relation.
- * @param query_id The ID of the query to which this operator belongs.
**/
- BuildHashOperator(const CatalogRelation &input_relation,
+ BuildHashOperator(const std::size_t query_id,
+ const CatalogRelation &input_relation,
const bool input_relation_is_stored,
const std::vector<attribute_id> &join_key_attributes,
const bool any_join_key_attributes_nullable,
- const QueryContext::join_hash_table_id hash_table_index,
- const std::size_t query_id)
+ const QueryContext::join_hash_table_id hash_table_index)
: RelationalOperator(query_id),
input_relation_(input_relation),
input_relation_is_stored_(input_relation_is_stored),
@@ -131,20 +131,20 @@ class BuildHashWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query.
* @param input_relation The relation to build hash table on.
* @param join_key_attributes The IDs of equijoin attributes in
* input_relation.
* @param any_join_key_attributes_nullable If any attribute is nullable.
* @param build_block_id The block id.
- * @param query_id The ID of the query.
* @param hash_table The JoinHashTable to use.
* @param storage_manager The StorageManager to use.
**/
- BuildHashWorkOrder(const CatalogRelationSchema &input_relation,
+ BuildHashWorkOrder(const std::size_t query_id,
+ const CatalogRelationSchema &input_relation,
const std::vector<attribute_id> &join_key_attributes,
const bool any_join_key_attributes_nullable,
const block_id build_block_id,
- const std::size_t query_id,
JoinHashTable *hash_table,
StorageManager *storage_manager)
: WorkOrder(query_id),
@@ -158,20 +158,20 @@ class BuildHashWorkOrder : public WorkOrder {
/**
* @brief Constructor for the distributed version.
*
+ * @param query_id The ID of the query.
* @param input_relation The relation to build hash table on.
* @param join_key_attributes The IDs of equijoin attributes in
* input_relation.
* @param any_join_key_attributes_nullable If any attribute is nullable.
- * @param query_id The ID of the query.
* @param build_block_id The block id.
* @param hash_table The JoinHashTable to use.
* @param storage_manager The StorageManager to use.
**/
- BuildHashWorkOrder(const CatalogRelationSchema &input_relation,
+ BuildHashWorkOrder(const std::size_t query_id,
+ const CatalogRelationSchema &input_relation,
std::vector<attribute_id> &&join_key_attributes,
const bool any_join_key_attributes_nullable,
const block_id build_block_id,
- const std::size_t query_id,
JoinHashTable *hash_table,
StorageManager *storage_manager)
: WorkOrder(query_id),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/CreateIndexOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/CreateIndexOperator.hpp b/relational_operators/CreateIndexOperator.hpp
index ede3f02..11a01ae 100644
--- a/relational_operators/CreateIndexOperator.hpp
+++ b/relational_operators/CreateIndexOperator.hpp
@@ -51,14 +51,14 @@ class CreateIndexOperator : public RelationalOperator {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param relation The relation to create index upon.
* @param index_name The index to create.
- * @param query_id The ID of the query to which this operator belongs.
* @param index_description The index_description associated with this index.
**/
- CreateIndexOperator(CatalogRelation *relation,
+ CreateIndexOperator(const std::size_t query_id,
+ CatalogRelation *relation,
const std::string &index_name,
- const std::size_t query_id,
IndexSubBlockDescription &&index_description) // NOLINT(whitespace/operators)
: RelationalOperator(query_id),
relation_(DCHECK_NOTNULL(relation)),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/DeleteOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/DeleteOperator.cpp b/relational_operators/DeleteOperator.cpp
index 94169ed..15dc9e3 100644
--- a/relational_operators/DeleteOperator.cpp
+++ b/relational_operators/DeleteOperator.cpp
@@ -54,13 +54,13 @@ bool DeleteOperator::getAllWorkOrders(
if (!started_) {
for (const block_id input_block_id : relation_block_ids_) {
container->addNormalWorkOrder(
- new DeleteWorkOrder(relation_,
+ new DeleteWorkOrder(query_id_,
+ relation_,
input_block_id,
predicate,
storage_manager,
op_index_,
scheduler_client_id,
- query_id_,
bus),
op_index_);
}
@@ -70,13 +70,13 @@ bool DeleteOperator::getAllWorkOrders(
} else {
while (num_workorders_generated_ < relation_block_ids_.size()) {
container->addNormalWorkOrder(
- new DeleteWorkOrder(relation_,
+ new DeleteWorkOrder(query_id_,
+ relation_,
relation_block_ids_[num_workorders_generated_],
predicate,
storage_manager,
op_index_,
scheduler_client_id,
- query_id_,
bus),
op_index_);
++num_workorders_generated_;
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/DeleteOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/DeleteOperator.hpp b/relational_operators/DeleteOperator.hpp
index ba1f825..c55f585 100644
--- a/relational_operators/DeleteOperator.hpp
+++ b/relational_operators/DeleteOperator.hpp
@@ -55,18 +55,18 @@ class DeleteOperator : public RelationalOperator {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param relation The relation to perform the DELETE over.
* @param predicate_index The index of Predicate in QueryContext. All tuples
* matching pred will be deleted (If kInvalidPredicateId, then all
* tuples will be deleted).
* @param relation_is_stored If relation is a stored relation and is fully
* available to the operator before it can start generating workorders.
- * @param query_id The ID of the query to which this operator belongs.
**/
- DeleteOperator(const CatalogRelation &relation,
+ DeleteOperator(const std::size_t query_id,
+ const CatalogRelation &relation,
const QueryContext::predicate_id predicate_index,
- const bool relation_is_stored,
- const std::size_t query_id)
+ const bool relation_is_stored)
: RelationalOperator(query_id),
relation_(relation),
predicate_index_(predicate_index),
@@ -122,6 +122,7 @@ class DeleteWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this workorder belongs.
* @param input_relation The relation to perform the DELETE over.
* @param input_block_id The block Id.
* @param predicate All tuples matching \c predicate will be deleted (If
@@ -130,16 +131,15 @@ class DeleteWorkOrder : public WorkOrder {
* @param delete_operator_index The index of the Delete Operator in the query
* plan DAG.
* @param scheduler_client_id The TMB client ID of the scheduler thread.
- * @param query_id The ID of the query to which this workorder belongs.
* @param bus A pointer to the TMB.
**/
- DeleteWorkOrder(const CatalogRelationSchema &input_relation,
+ DeleteWorkOrder(const std::size_t query_id,
+ const CatalogRelationSchema &input_relation,
const block_id input_block_id,
const Predicate *predicate,
StorageManager *storage_manager,
const std::size_t delete_operator_index,
const tmb::client_id scheduler_client_id,
- const std::size_t query_id,
MessageBus *bus)
: WorkOrder(query_id),
input_relation_(input_relation),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/DestroyHashOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/DestroyHashOperator.cpp b/relational_operators/DestroyHashOperator.cpp
index c92117a..8aa40b4 100644
--- a/relational_operators/DestroyHashOperator.cpp
+++ b/relational_operators/DestroyHashOperator.cpp
@@ -33,7 +33,7 @@ bool DestroyHashOperator::getAllWorkOrders(
if (blocking_dependencies_met_ && !work_generated_) {
work_generated_ = true;
container->addNormalWorkOrder(
- new DestroyHashWorkOrder(hash_table_index_, query_id_, query_context),
+ new DestroyHashWorkOrder(query_id_, hash_table_index_, query_context),
op_index_);
}
return work_generated_;
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/DestroyHashOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/DestroyHashOperator.hpp b/relational_operators/DestroyHashOperator.hpp
index 086c279..7d8acb7 100644
--- a/relational_operators/DestroyHashOperator.hpp
+++ b/relational_operators/DestroyHashOperator.hpp
@@ -46,11 +46,11 @@ class DestroyHashOperator : public RelationalOperator {
/**
* @brief Constructor.
*
- * @param hash_table_index The index of the JoinHashTable in QueryContext.
* @param query_id The ID of the query to which this operator belongs.
+ * @param hash_table_index The index of the JoinHashTable in QueryContext.
**/
- DestroyHashOperator(const QueryContext::join_hash_table_id hash_table_index,
- const std::size_t query_id)
+ DestroyHashOperator(const std::size_t query_id,
+ const QueryContext::join_hash_table_id hash_table_index)
: RelationalOperator(query_id),
hash_table_index_(hash_table_index),
work_generated_(false) {}
@@ -78,12 +78,12 @@ class DestroyHashWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
- * @param hash_table_index The index of the JoinHashTable in QueryContext.
* @param query_id The ID of the query to which this WorkOrder belongs.
+ * @param hash_table_index The index of the JoinHashTable in QueryContext.
* @param query_context The QueryContext to use.
**/
- DestroyHashWorkOrder(const QueryContext::join_hash_table_id hash_table_index,
- const std::size_t query_id,
+ DestroyHashWorkOrder(const std::size_t query_id,
+ const QueryContext::join_hash_table_id hash_table_index,
QueryContext *query_context)
: WorkOrder(query_id),
hash_table_index_(hash_table_index),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/DropTableOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/DropTableOperator.hpp b/relational_operators/DropTableOperator.hpp
index 0bbb718..a0a8d6e 100644
--- a/relational_operators/DropTableOperator.hpp
+++ b/relational_operators/DropTableOperator.hpp
@@ -55,14 +55,14 @@ class DropTableOperator : public RelationalOperator {
/**
* @brief Constructor.
*
- * @param relation The relation to drop.
* @param query_id The ID of the query to which this operator belongs.
+ * @param relation The relation to drop.
* @param database The databse where to drop \c relation.
* @param only_drop_blocks If true, only drop the blocks belonging to \c
* relation, but leave \c relation in \c database.
**/
- DropTableOperator(const CatalogRelation &relation,
- const std::size_t query_id,
+ DropTableOperator(const std::size_t query_id,
+ const CatalogRelation &relation,
CatalogDatabase *database,
const bool only_drop_blocks = false)
: RelationalOperator(query_id),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/FinalizeAggregationOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/FinalizeAggregationOperator.hpp b/relational_operators/FinalizeAggregationOperator.hpp
index 51e55dc..e8a403f 100644
--- a/relational_operators/FinalizeAggregationOperator.hpp
+++ b/relational_operators/FinalizeAggregationOperator.hpp
@@ -54,16 +54,17 @@ class FinalizeAggregationOperator : public RelationalOperator {
* @brief Constructor for finalizing aggregation state and writing output
* tuples. The actual aggregation is computed by the AggregationOperator.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param aggr_state_index The index of the AggregationState in QueryContext.
* @param output_relation The output relation.
* @param output_destination_index The index of the InsertDestination in the
* QueryContext to insert aggregation results.
- * @param query_id The ID of the query to which this operator belongs.
*/
- FinalizeAggregationOperator(const QueryContext::aggregation_state_id aggr_state_index,
- const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const std::size_t query_id)
+ FinalizeAggregationOperator(
+ const std::size_t query_id,
+ const QueryContext::aggregation_state_id aggr_state_index,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index)
: RelationalOperator(query_id),
aggr_state_index_(aggr_state_index),
output_relation_(output_relation),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/HashJoinOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/HashJoinOperator.cpp b/relational_operators/HashJoinOperator.cpp
index d8c7304..b89cfb3 100644
--- a/relational_operators/HashJoinOperator.cpp
+++ b/relational_operators/HashJoinOperator.cpp
@@ -290,7 +290,8 @@ bool HashJoinOperator::getAllNonOuterJoinWorkOrders(
if (!started_) {
for (const block_id probe_block_id : probe_relation_block_ids_) {
container->addNormalWorkOrder(
- new JoinWorkOrderClass(build_relation_,
+ new JoinWorkOrderClass(query_id_,
+ build_relation_,
probe_relation_,
join_key_attributes_,
any_join_key_attributes_nullable_,
@@ -298,7 +299,6 @@ bool HashJoinOperator::getAllNonOuterJoinWorkOrders(
residual_predicate,
selection,
hash_table,
- query_id_,
output_destination,
storage_manager),
op_index_);
@@ -309,17 +309,18 @@ bool HashJoinOperator::getAllNonOuterJoinWorkOrders(
} else {
while (num_workorders_generated_ < probe_relation_block_ids_.size()) {
container->addNormalWorkOrder(
- new JoinWorkOrderClass(build_relation_,
- probe_relation_,
- join_key_attributes_,
- any_join_key_attributes_nullable_,
- probe_relation_block_ids_[num_workorders_generated_],
- residual_predicate,
- selection,
- hash_table,
- query_id_,
- output_destination,
- storage_manager),
+ new JoinWorkOrderClass(
+ query_id_,
+ build_relation_,
+ probe_relation_,
+ join_key_attributes_,
+ any_join_key_attributes_nullable_,
+ probe_relation_block_ids_[num_workorders_generated_],
+ residual_predicate,
+ selection,
+ hash_table,
+ output_destination,
+ storage_manager),
op_index_);
++num_workorders_generated_;
} // end while
@@ -350,6 +351,7 @@ bool HashJoinOperator::getAllOuterJoinWorkOrders(
for (const block_id probe_block_id : probe_relation_block_ids_) {
container->addNormalWorkOrder(
new HashOuterJoinWorkOrder(
+ query_id_,
build_relation_,
probe_relation_,
join_key_attributes_,
@@ -358,7 +360,6 @@ bool HashJoinOperator::getAllOuterJoinWorkOrders(
selection,
is_selection_on_build_,
hash_table,
- query_id_,
output_destination,
storage_manager),
op_index_);
@@ -370,6 +371,7 @@ bool HashJoinOperator::getAllOuterJoinWorkOrders(
while (num_workorders_generated_ < probe_relation_block_ids_.size()) {
container->addNormalWorkOrder(
new HashOuterJoinWorkOrder(
+ query_id_,
build_relation_,
probe_relation_,
join_key_attributes_,
@@ -378,7 +380,6 @@ bool HashJoinOperator::getAllOuterJoinWorkOrders(
selection,
is_selection_on_build_,
hash_table,
- query_id_,
output_destination,
storage_manager),
op_index_);
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/HashJoinOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/HashJoinOperator.hpp b/relational_operators/HashJoinOperator.hpp
index 825f360..621b8cf 100644
--- a/relational_operators/HashJoinOperator.hpp
+++ b/relational_operators/HashJoinOperator.hpp
@@ -85,6 +85,7 @@ class HashJoinOperator : public RelationalOperator {
* dependent on the selectivity of the predicates involved. The decision
* is left to the query optimizer.
*
+ * @param query_id The ID of the query.
* @param build_relation The relation that the hash table was originally
* built on (i.e. the inner relation in the join).
* @param probe_relation The relation to probe the hash table with (i.e. the
@@ -108,25 +109,25 @@ class HashJoinOperator : public RelationalOperator {
* corresponding to the attributes of the relation referred by
* output_relation_id. Each Scalar is evaluated for the joined tuples,
* and the resulting value is inserted into the join result.
- * @param query_id The ID of the query.
* @param is_selection_on_build Whether each selection Scalar is using attributes
* from the build relation as input. Can be NULL for inner/semi/anti
* joins since this information is not utilized by these joins.
* @param join_type The type of join corresponding to this operator.
**/
- HashJoinOperator(const CatalogRelation &build_relation,
- const CatalogRelation &probe_relation,
- const bool probe_relation_is_stored,
- const std::vector<attribute_id> &join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const QueryContext::join_hash_table_id hash_table_index,
- const QueryContext::predicate_id residual_predicate_index,
- const QueryContext::scalar_group_id selection_index,
- const std::size_t query_id,
- const std::vector<bool> *is_selection_on_build = nullptr,
- const JoinType join_type = JoinType::kInnerJoin)
+ HashJoinOperator(
+ const std::size_t query_id,
+ const CatalogRelation &build_relation,
+ const CatalogRelation &probe_relation,
+ const bool probe_relation_is_stored,
+ const std::vector<attribute_id> &join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const QueryContext::join_hash_table_id hash_table_index,
+ const QueryContext::predicate_id residual_predicate_index,
+ const QueryContext::scalar_group_id selection_index,
+ const std::vector<bool> *is_selection_on_build = nullptr,
+ const JoinType join_type = JoinType::kInnerJoin)
: RelationalOperator(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
@@ -230,6 +231,7 @@ class HashInnerJoinWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param build_relation The relation that the hash table was originally built
* on (i.e. the inner relation in the join).
* @param probe_relation The relation to probe the hash table with (i.e. the
@@ -246,21 +248,21 @@ class HashInnerJoinWorkOrder : public WorkOrder {
* in \c output_destination. Each Scalar is evaluated for the joined
* tuples, and the resulting value is inserted into the join result.
* @param hash_table The JoinHashTable to use.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- HashInnerJoinWorkOrder(const CatalogRelationSchema &build_relation,
- const CatalogRelationSchema &probe_relation,
- const std::vector<attribute_id> &join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const block_id lookup_block_id,
- const Predicate *residual_predicate,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- const JoinHashTable &hash_table,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ HashInnerJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &build_relation,
+ const CatalogRelationSchema &probe_relation,
+ const std::vector<attribute_id> &join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const block_id lookup_block_id,
+ const Predicate *residual_predicate,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ const JoinHashTable &hash_table,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
@@ -276,6 +278,7 @@ class HashInnerJoinWorkOrder : public WorkOrder {
/**
* @brief Constructor for the distributed version.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param build_relation The relation that the hash table was originally built
* on (i.e. the inner relation in the join).
* @param probe_relation The relation to probe the hash table with (i.e. the
@@ -292,21 +295,21 @@ class HashInnerJoinWorkOrder : public WorkOrder {
* in \c output_destination. Each Scalar is evaluated for the joined
* tuples, and the resulting value is inserted into the join result.
* @param hash_table The JoinHashTable to use.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- HashInnerJoinWorkOrder(const CatalogRelationSchema &build_relation,
- const CatalogRelationSchema &probe_relation,
- std::vector<attribute_id> &&join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const block_id lookup_block_id,
- const Predicate *residual_predicate,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- const JoinHashTable &hash_table,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ HashInnerJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &build_relation,
+ const CatalogRelationSchema &probe_relation,
+ std::vector<attribute_id> &&join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const block_id lookup_block_id,
+ const Predicate *residual_predicate,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ const JoinHashTable &hash_table,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
@@ -359,6 +362,7 @@ class HashSemiJoinWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param build_relation The relation that the hash table was originally built
* on (i.e. the inner relation in the join).
* @param probe_relation The relation to probe the hash table with (i.e. the
@@ -375,21 +379,21 @@ class HashSemiJoinWorkOrder : public WorkOrder {
* in \c output_destination. Each Scalar is evaluated for the joined
* tuples, and the resulting value is inserted into the join result.
* @param hash_table The JoinHashTable to use.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- HashSemiJoinWorkOrder(const CatalogRelationSchema &build_relation,
- const CatalogRelationSchema &probe_relation,
- const std::vector<attribute_id> &join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const block_id lookup_block_id,
- const Predicate *residual_predicate,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- const JoinHashTable &hash_table,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ HashSemiJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &build_relation,
+ const CatalogRelationSchema &probe_relation,
+ const std::vector<attribute_id> &join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const block_id lookup_block_id,
+ const Predicate *residual_predicate,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ const JoinHashTable &hash_table,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
@@ -405,6 +409,7 @@ class HashSemiJoinWorkOrder : public WorkOrder {
/**
* @brief Constructor for the distributed version.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param build_relation The relation that the hash table was originally built
* on (i.e. the inner relation in the join).
* @param probe_relation The relation to probe the hash table with (i.e. the
@@ -421,21 +426,21 @@ class HashSemiJoinWorkOrder : public WorkOrder {
* in \c output_destination. Each Scalar is evaluated for the joined
* tuples, and the resulting value is inserted into the join result.
* @param hash_table The JoinHashTable to use.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- HashSemiJoinWorkOrder(const CatalogRelationSchema &build_relation,
- const CatalogRelationSchema &probe_relation,
- std::vector<attribute_id> &&join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const block_id lookup_block_id,
- const Predicate *residual_predicate,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- const JoinHashTable &hash_table,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ HashSemiJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &build_relation,
+ const CatalogRelationSchema &probe_relation,
+ std::vector<attribute_id> &&join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const block_id lookup_block_id,
+ const Predicate *residual_predicate,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ const JoinHashTable &hash_table,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
@@ -481,6 +486,7 @@ class HashAntiJoinWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param build_relation The relation that the hash table was originally built
* on (i.e. the inner relation in the join).
* @param probe_relation The relation to probe the hash table with (i.e. the
@@ -497,21 +503,21 @@ class HashAntiJoinWorkOrder : public WorkOrder {
* in \c output_destination. Each Scalar is evaluated for the joined
* tuples, and the resulting value is inserted into the join result.
* @param hash_table The JoinHashTable to use.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- HashAntiJoinWorkOrder(const CatalogRelationSchema &build_relation,
- const CatalogRelationSchema &probe_relation,
- const std::vector<attribute_id> &join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const block_id lookup_block_id,
- const Predicate *residual_predicate,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- const JoinHashTable &hash_table,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ HashAntiJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &build_relation,
+ const CatalogRelationSchema &probe_relation,
+ const std::vector<attribute_id> &join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const block_id lookup_block_id,
+ const Predicate *residual_predicate,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ const JoinHashTable &hash_table,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
@@ -527,6 +533,7 @@ class HashAntiJoinWorkOrder : public WorkOrder {
/**
* @brief Constructor for the distributed version.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param build_relation The relation that the hash table was originally built
* on (i.e. the inner relation in the join).
* @param probe_relation The relation to probe the hash table with (i.e. the
@@ -543,21 +550,21 @@ class HashAntiJoinWorkOrder : public WorkOrder {
* in \c output_destination. Each Scalar is evaluated for the joined
* tuples, and the resulting value is inserted into the join result.
* @param hash_table The JoinHashTable to use.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- HashAntiJoinWorkOrder(const CatalogRelationSchema &build_relation,
- const CatalogRelationSchema &probe_relation,
- std::vector<attribute_id> &&join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const block_id lookup_block_id,
- const Predicate *residual_predicate,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- const JoinHashTable &hash_table,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ HashAntiJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &build_relation,
+ const CatalogRelationSchema &probe_relation,
+ std::vector<attribute_id> &&join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const block_id lookup_block_id,
+ const Predicate *residual_predicate,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ const JoinHashTable &hash_table,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
@@ -627,17 +634,18 @@ class HashOuterJoinWorkOrder : public WorkOrder {
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- HashOuterJoinWorkOrder(const CatalogRelationSchema &build_relation,
- const CatalogRelationSchema &probe_relation,
- const std::vector<attribute_id> &join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const block_id lookup_block_id,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- const std::vector<bool> &is_selection_on_build,
- const JoinHashTable &hash_table,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ HashOuterJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &build_relation,
+ const CatalogRelationSchema &probe_relation,
+ const std::vector<attribute_id> &join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const block_id lookup_block_id,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ const std::vector<bool> &is_selection_on_build,
+ const JoinHashTable &hash_table,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
@@ -653,6 +661,7 @@ class HashOuterJoinWorkOrder : public WorkOrder {
/**
* @brief Constructor for the distributed version.
*
+ * @param query_id The ID of the query to which this WorkOrder belongs.
* @param build_relation The relation that the hash table was originally built
* on (i.e. the inner relation in the join).
* @param probe_relation The relation to probe the hash table with (i.e. the
@@ -668,21 +677,21 @@ class HashOuterJoinWorkOrder : public WorkOrder {
* is using attributes from the build relation as input. Note that the
* length of this vector should equal the length of \p selection.
* @param hash_table The JoinHashTable to use.
- * @param query_id The ID of the query to which this WorkOrder belongs.
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- HashOuterJoinWorkOrder(const CatalogRelationSchema &build_relation,
- const CatalogRelationSchema &probe_relation,
- std::vector<attribute_id> &&join_key_attributes,
- const bool any_join_key_attributes_nullable,
- const block_id lookup_block_id,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- std::vector<bool> &&is_selection_on_build,
- const JoinHashTable &hash_table,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ HashOuterJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &build_relation,
+ const CatalogRelationSchema &probe_relation,
+ std::vector<attribute_id> &&join_key_attributes,
+ const bool any_join_key_attributes_nullable,
+ const block_id lookup_block_id,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ std::vector<bool> &&is_selection_on_build,
+ const JoinHashTable &hash_table,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
build_relation_(build_relation),
probe_relation_(probe_relation),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/InsertOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/InsertOperator.hpp b/relational_operators/InsertOperator.hpp
index ccef444..51c606d 100644
--- a/relational_operators/InsertOperator.hpp
+++ b/relational_operators/InsertOperator.hpp
@@ -53,16 +53,17 @@ class InsertOperator : public RelationalOperator {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param output_relation_id The output relation.
* @param output_destination_index The index of the InsertDestination in the
* QueryContext to insert the tuple.
* @param tuple_index The index of the tuple to insert in the QueryContext.
- * @param query_id The ID of the query to which this operator belongs.
**/
- InsertOperator(const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const QueryContext::tuple_id tuple_index,
- const std::size_t query_id)
+ InsertOperator(
+ const std::size_t query_id,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const QueryContext::tuple_id tuple_index)
: RelationalOperator(query_id),
output_relation_(output_relation),
output_destination_index_(output_destination_index),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/NestedLoopsJoinOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/NestedLoopsJoinOperator.cpp b/relational_operators/NestedLoopsJoinOperator.cpp
index 317cc5d..5a47fca 100644
--- a/relational_operators/NestedLoopsJoinOperator.cpp
+++ b/relational_operators/NestedLoopsJoinOperator.cpp
@@ -76,15 +76,17 @@ bool NestedLoopsJoinOperator::getAllWorkOrders(
for (const block_id left_block_id : left_relation_block_ids_) {
for (const block_id right_block_id : right_relation_block_ids_) {
container->addNormalWorkOrder(
- new NestedLoopsJoinWorkOrder(left_input_relation_,
- right_input_relation_,
- left_block_id,
- right_block_id,
- query_context->getPredicate(join_predicate_index_),
- query_context->getScalarGroup(selection_index_),
- query_id_,
- query_context->getInsertDestination(output_destination_index_),
- storage_manager),
+ new NestedLoopsJoinWorkOrder(
+ query_id_,
+ left_input_relation_,
+ right_input_relation_,
+ left_block_id,
+ right_block_id,
+ query_context->getPredicate(join_predicate_index_),
+ query_context->getScalarGroup(selection_index_),
+ query_context->getInsertDestination(
+ output_destination_index_),
+ storage_manager),
op_index_);
}
}
@@ -166,15 +168,16 @@ std::size_t NestedLoopsJoinOperator::getAllWorkOrdersHelperBothNotStored(WorkOrd
right_index < right_max;
++right_index) {
container->addNormalWorkOrder(
- new NestedLoopsJoinWorkOrder(left_input_relation_,
- right_input_relation_,
- left_relation_block_ids_[left_index],
- right_relation_block_ids_[right_index],
- query_context->getPredicate(join_predicate_index_),
- query_context->getScalarGroup(selection_index_),
- query_id_,
- query_context->getInsertDestination(output_destination_index_),
- storage_manager),
+ new NestedLoopsJoinWorkOrder(
+ query_id_,
+ left_input_relation_,
+ right_input_relation_,
+ left_relation_block_ids_[left_index],
+ right_relation_block_ids_[right_index],
+ query_context->getPredicate(join_predicate_index_),
+ query_context->getScalarGroup(selection_index_),
+ query_context->getInsertDestination(output_destination_index_),
+ storage_manager),
op_index_);
}
}
@@ -201,13 +204,13 @@ bool NestedLoopsJoinOperator::getAllWorkOrdersHelperOneStored(WorkOrdersContaine
for (const block_id left_block_id : left_relation_block_ids_) {
container->addNormalWorkOrder(
new NestedLoopsJoinWorkOrder(
+ query_id_,
left_input_relation_,
right_input_relation_,
left_block_id,
right_relation_block_ids_[right_index],
join_predicate,
selection,
- query_id_,
output_destination,
storage_manager),
op_index_);
@@ -221,13 +224,13 @@ bool NestedLoopsJoinOperator::getAllWorkOrdersHelperOneStored(WorkOrdersContaine
++left_index) {
for (const block_id right_block_id : right_relation_block_ids_) {
container->addNormalWorkOrder(
- new NestedLoopsJoinWorkOrder(left_input_relation_,
+ new NestedLoopsJoinWorkOrder(query_id_,
+ left_input_relation_,
right_input_relation_,
left_relation_block_ids_[left_index],
right_block_id,
join_predicate,
selection,
- query_id_,
output_destination,
storage_manager),
op_index_);
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/NestedLoopsJoinOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/NestedLoopsJoinOperator.hpp b/relational_operators/NestedLoopsJoinOperator.hpp
index f165442..0b13842 100644
--- a/relational_operators/NestedLoopsJoinOperator.hpp
+++ b/relational_operators/NestedLoopsJoinOperator.hpp
@@ -59,6 +59,7 @@ class NestedLoopsJoinOperator : public RelationalOperator {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param left_input_relation The first relation in the join (order is not
* actually important).
* @param right_input_relation The second relation in the join (order is not
@@ -76,17 +77,17 @@ class NestedLoopsJoinOperator : public RelationalOperator {
* @param left_relation_is_stored If left_input_relation is a stored relation.
* @param right_relation_is_stored If right_input_relation is a stored
* relation.
- * @param query_id The ID of the query to which this operator belongs.
**/
- NestedLoopsJoinOperator(const CatalogRelation &left_input_relation,
- const CatalogRelation &right_input_relation,
- const CatalogRelation &output_relation,
- const QueryContext::insert_destination_id output_destination_index,
- const QueryContext::predicate_id join_predicate_index,
- const QueryContext::scalar_group_id selection_index,
- bool left_relation_is_stored,
- bool right_relation_is_stored,
- const std::size_t query_id)
+ NestedLoopsJoinOperator(
+ const std::size_t query_id,
+ const CatalogRelation &left_input_relation,
+ const CatalogRelation &right_input_relation,
+ const CatalogRelation &output_relation,
+ const QueryContext::insert_destination_id output_destination_index,
+ const QueryContext::predicate_id join_predicate_index,
+ const QueryContext::scalar_group_id selection_index,
+ bool left_relation_is_stored,
+ bool right_relation_is_stored)
: RelationalOperator(query_id),
left_input_relation_(left_input_relation),
right_input_relation_(right_input_relation),
@@ -96,10 +97,12 @@ class NestedLoopsJoinOperator : public RelationalOperator {
selection_index_(selection_index),
left_relation_is_stored_(left_relation_is_stored),
right_relation_is_stored_(right_relation_is_stored),
- left_relation_block_ids_(left_relation_is_stored ? left_input_relation.getBlocksSnapshot()
- : std::vector<block_id>()),
- right_relation_block_ids_(right_relation_is_stored ? right_input_relation.getBlocksSnapshot()
- : std::vector<block_id>()),
+ left_relation_block_ids_(left_relation_is_stored
+ ? left_input_relation.getBlocksSnapshot()
+ : std::vector<block_id>()),
+ right_relation_block_ids_(right_relation_is_stored
+ ? right_input_relation.getBlocksSnapshot()
+ : std::vector<block_id>()),
num_left_workorders_generated_(0),
num_right_workorders_generated_(0),
done_feeding_left_relation_(false),
@@ -222,6 +225,7 @@ class NestedLoopsJoinWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this operator belongs.
* @param left_input_relation The first relation in the join (order is not
* actually important).
* @param right_input_relation The second relation in the join (order is not
@@ -233,19 +237,19 @@ class NestedLoopsJoinWorkOrder : public WorkOrder {
* @param selection A list of Scalars corresponding to the relation attributes
* in \c output_destination. Each Scalar is evaluated for the joined
* tuples, and the resulting value is inserted into the join result.
- * @param query_id The ID of the query to which this operator belongs.
* @param output_destination The InsertDestination to insert the join results.
* @param storage_manager The StorageManager to use.
**/
- NestedLoopsJoinWorkOrder(const CatalogRelationSchema &left_input_relation,
- const CatalogRelationSchema &right_input_relation,
- const block_id left_block_id,
- const block_id right_block_id,
- const Predicate *join_predicate,
- const std::vector<std::unique_ptr<const Scalar>> &selection,
- const std::size_t query_id,
- InsertDestination *output_destination,
- StorageManager *storage_manager)
+ NestedLoopsJoinWorkOrder(
+ const std::size_t query_id,
+ const CatalogRelationSchema &left_input_relation,
+ const CatalogRelationSchema &right_input_relation,
+ const block_id left_block_id,
+ const block_id right_block_id,
+ const Predicate *join_predicate,
+ const std::vector<std::unique_ptr<const Scalar>> &selection,
+ InsertDestination *output_destination,
+ StorageManager *storage_manager)
: WorkOrder(query_id),
left_input_relation_(left_input_relation),
right_input_relation_(right_input_relation),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/RebuildWorkOrder.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/RebuildWorkOrder.hpp b/relational_operators/RebuildWorkOrder.hpp
index ae876ba..86f8eaf 100644
--- a/relational_operators/RebuildWorkOrder.hpp
+++ b/relational_operators/RebuildWorkOrder.hpp
@@ -48,6 +48,7 @@ class RebuildWorkOrder : public WorkOrder {
/**
* @brief Constructor.
*
+ * @param query_id The ID of the query to which this RebuildWorkOrder belongs.
* @param block_ref A MutableBlockReference to the storage block which needs
* to be rebuilt.
* @param input_operator_index The index of the relational operator in the
@@ -55,15 +56,15 @@ class RebuildWorkOrder : public WorkOrder {
* @param input_relation_id The ID of the CatalogRelation to which the given
* storage block belongs to.
* @param scheduler_client_id The TMB client ID of the scheduler thread.
- * @param query_id The ID of the query to which this RebuildWorkOrder belongs.
* @param bus A pointer to the TMB.
**/
- RebuildWorkOrder(MutableBlockReference &&block_ref,
- const std::size_t input_operator_index,
- const relation_id input_relation_id,
- const client_id scheduler_client_id,
- const std::size_t query_id,
- MessageBus *bus)
+ RebuildWorkOrder(
+ const std::size_t query_id,
+ MutableBlockReference &&block_ref, // NOLINT(whitespace/operators)
+ const std::size_t input_operator_index,
+ const relation_id input_relation_id,
+ const client_id scheduler_client_id,
+ MessageBus *bus)
: WorkOrder(query_id),
block_ref_(std::move(block_ref)),
input_operator_index_(input_operator_index),
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/d67f61e1/relational_operators/SampleOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/SampleOperator.cpp b/relational_operators/SampleOperator.cpp
index b318ce4..6669148 100644
--- a/relational_operators/SampleOperator.cpp
+++ b/relational_operators/SampleOperator.cpp
@@ -54,11 +54,11 @@ bool SampleOperator::getAllWorkOrders(
for (const block_id input_block_id : input_relation_block_ids_) {
if (distribution(generator) <= probability) {
container->addNormalWorkOrder(
- new SampleWorkOrder(input_relation_,
+ new SampleWorkOrder(query_id_,
+ input_relation_,
input_block_id,
is_block_sample_,
percentage_,
- query_id_,
output_destination,
storage_manager),
op_index_);
@@ -68,15 +68,14 @@ bool SampleOperator::getAllWorkOrders(
// Add all the blocks for tuple sampling which would handle
// the sampling from each block
for (const block_id input_block_id : input_relation_block_ids_) {
- container->addNormalWorkOrder(
- new SampleWorkOrder(input_relation_,
- input_block_id,
- is_block_sample_,
- percentage_,
- query_id_,
- output_destination,
- storage_manager),
- op_index_);
+ container->addNormalWorkOrder(new SampleWorkOrder(query_id_,
+ input_relation_,
+ input_block_id,
+ is_block_sample_,
+ percentage_,
+ output_destination,
+ storage_manager),
+ op_index_);
}
}
started_ = true;
@@ -87,13 +86,14 @@ bool SampleOperator::getAllWorkOrders(
while (num_workorders_generated_ < input_relation_block_ids_.size()) {
if (distribution(generator) <= probability) {
container->addNormalWorkOrder(
- new SampleWorkOrder(input_relation_,
- input_relation_block_ids_[num_workorders_generated_],
- is_block_sample_,
- percentage_,
- query_id_,
- output_destination,
- storage_manager),
+ new SampleWorkOrder(
+ query_id_,
+ input_relation_,
+ input_relation_block_ids_[num_workorders_generated_],
+ is_block_sample_,
+ percentage_,
+ output_destination,
+ storage_manager),
op_index_);
++num_workorders_generated_;
}
@@ -101,13 +101,14 @@ bool SampleOperator::getAllWorkOrders(
} else {
while (num_workorders_generated_ < input_relation_block_ids_.size()) {
container->addNormalWorkOrder(
- new SampleWorkOrder(input_relation_,
- input_relation_block_ids_[num_workorders_generated_],
- is_block_sample_,
- percentage_,
- query_id_,
- output_destination,
- storage_manager),
+ new SampleWorkOrder(
+ query_id_,
+ input_relation_,
+ input_relation_block_ids_[num_workorders_generated_],
+ is_block_sample_,
+ percentage_,
+ output_destination,
+ storage_manager),
op_index_);
++num_workorders_generated_;
}