void QueryManagerBase::markOperatorFinished(const dag_node_index index) {
query_exec_state_->setExecutionFinished(index);
for (const dag_node_index dependent_op_index : blocking_dependents_[index]) {
blocking_dependencies_[dependent_op_index].erase(index);
}
for (const dag_node_index dependent_op_index : output_consumers_[index]) {
non_blocking_dependencies_[dependent_op_index].erase(index);
}
RelationalOperator *op = query_dag_->getNodePayloadMutable(index);
op->updateCatalogOnCompletion();
const relation_id output_rel = op->getOutputRelationID();
for (const pair<dag_node_index, bool> &dependent_link : query_dag_->getDependents(index)) {
const dag_node_index dependent_op_index = dependent_link.first;
if (output_rel >= 0) {
// Signal dependent operator that current operator is done feeding input blocks.
query_dag_->getNodePayloadMutable(dependent_op_index)->doneFeedingInputBlocks(output_rel);
}
if (checkAllBlockingDependenciesMet(dependent_op_index)) {
// Process the dependent operator (of the operator whose WorkOrder
// was just executed) for which all the dependencies have been met.
if (!fetchNormalWorkOrders(dependent_op_index) &&
non_blocking_dependencies_[dependent_op_index].empty() &&
checkNormalExecutionOver(dependent_op_index) &&
(!checkRebuildRequired(dependent_op_index) || initiateRebuild(dependent_op_index))) {
markOperatorFinished(dependent_op_index);
}
}
}
}
void QueryManagerBase::processFeedbackMessage(
const dag_node_index op_index, const WorkOrder::FeedbackMessage &msg) {
RelationalOperator *op =
query_dag_->getNodePayloadMutable(op_index);
op->receiveFeedbackMessage(msg);
if (query_exec_state_->hasDoneGenerationWorkOrders(op_index)) {
return;
}
fetchNormalWorkOrders(op_index);
}
void LIPFilterGenerator::deployLIPFilters(QueryPlan *execution_plan,
serialization::QueryContext *query_context_proto) {
lip_filter_builder_map_.clear();
lip_filter_deployment_protos_.clear();
// Deploy builders
const auto &build_info_map = lip_filter_configuration_->getBuildInfoMap();
for (const auto &info : builder_infos_) {
const auto build_it = build_info_map.find(info.builder_node);
if (build_it != build_info_map.end()) {
deployBuilderInternal(execution_plan,
query_context_proto,
info.builder_node,
info.builder_operator_index,
build_it->second);
}
}
// Deploy probers
const auto &probe_info_map = lip_filter_configuration_->getProbeInfoMap();
for (const auto &info : prober_infos_) {
const auto probe_it = probe_info_map.find(info.prober_node);
if (probe_it != probe_info_map.end()) {
deployProberInteral(execution_plan,
query_context_proto,
info.prober_node,
info.prober_operator_index,
probe_it->second);
}
}
// Attach LIPFilterDeployment information to the RelationalOperators.
for (const auto &entry : lip_filter_deployment_protos_) {
RelationalOperator *relop =
execution_plan->getQueryPlanDAGMutable()->getNodePayloadMutable(entry.first);
const auto &lip_filter_deployment_proto_pair = entry.second;
unordered_set<QueryContext::lip_filter_id> lip_filter_indexes;
const serialization::LIPFilterDeployment &lip_filter_deployment_proto =
*(lip_filter_deployment_proto_pair.second);
for (int i = 0; i < lip_filter_deployment_proto.build_entries_size(); ++i) {
lip_filter_indexes.insert(lip_filter_deployment_proto.build_entries(i).lip_filter_id());
}
for (int i = 0; i < lip_filter_deployment_proto.probe_entries_size(); ++i) {
lip_filter_indexes.insert(lip_filter_deployment_proto.probe_entries(i).lip_filter_id());
}
relop->deployLIPFilters(lip_filter_deployment_proto_pair.first, lip_filter_indexes);
}
}
void QueryManager::markOperatorFinished(const dag_node_index index) {
query_exec_state_->setExecutionFinished(index);
RelationalOperator *op = query_dag_->getNodePayloadMutable(index);
op->updateCatalogOnCompletion();
const relation_id output_rel = op->getOutputRelationID();
for (const pair<dag_node_index, bool> &dependent_link : query_dag_->getDependents(index)) {
const dag_node_index dependent_op_index = dependent_link.first;
RelationalOperator *dependent_op = query_dag_->getNodePayloadMutable(dependent_op_index);
// Signal dependent operator that current operator is done feeding input blocks.
if (output_rel >= 0) {
dependent_op->doneFeedingInputBlocks(output_rel);
}
if (checkAllBlockingDependenciesMet(dependent_op_index)) {
dependent_op->informAllBlockingDependenciesMet();
}
}
}
void Foreman::processFeedbackMessage(const WorkOrder::FeedbackMessage &msg) {
RelationalOperator *op =
query_dag_->getNodePayloadMutable(msg.header().rel_op_index);
op->receiveFeedbackMessage(msg);
}
