anonymous_namespace{RelAlgExecutionDescriptor.cpp} Namespace Reference

Functions
std::vector< Vertex >	merge_sort_with_input (const std::vector< Vertex > &vertices, const DAG &graph)
DAG	build_dag (const RelAlgNode *sink)
std::unordered_set< Vertex >	get_join_vertices (const std::vector< Vertex > &vertices, const DAG &graph)

Function Documentation

DAG anonymous_namespace{RelAlgExecutionDescriptor.cpp}::build_dag

(

const RelAlgNode *

sink

)

Definition at line 163 of file RelAlgExecutionDescriptor.cpp.

References CHECK, and i.

Referenced by RaExecutionSequence::RaExecutionSequence().

                                      {
  DAG graph(1);
  graph[0] = sink;
  std::unordered_map<const RelAlgNode*, int> node_ptr_to_vert_idx{
      std::make_pair(sink, 0)};
  std::vector<const RelAlgNode*> stack(1, sink);
  while (!stack.empty()) {
    const auto node = stack.back();
    stack.pop_back();
    if (dynamic_cast<const RelScan*>(node)) {
      continue;
    }

    const auto input_num = node->inputCount();
    switch (input_num) {
      case 0:
        CHECK(dynamic_cast<const RelLogicalValues*>(node));
      case 1:
        break;
      case 2:
        CHECK(dynamic_cast<const RelJoin*>(node) ||
              dynamic_cast<const RelLeftDeepInnerJoin*>(node) ||
              dynamic_cast<const RelLogicalUnion*>(node) ||
              dynamic_cast<const RelTableFunction*>(node));
        break;
      default:
        CHECK(dynamic_cast<const RelLeftDeepInnerJoin*>(node) ||
              dynamic_cast<const RelLogicalUnion*>(node) ||
              dynamic_cast<const RelTableFunction*>(node));
    }
    for (size_t i = 0; i < input_num; ++i) {
      const auto input = node->getInput(i);
      CHECK(input);
      const bool visited = node_ptr_to_vert_idx.count(input) > 0;
      if (!visited) {
        node_ptr_to_vert_idx.insert(std::make_pair(input, node_ptr_to_vert_idx.size()));
      }
      boost::add_edge(node_ptr_to_vert_idx[input], node_ptr_to_vert_idx[node], graph);
      if (!visited) {
        graph[node_ptr_to_vert_idx[input]] = input;
        stack.push_back(input);
      }
    }
  }
  return graph;
}

Here is the caller graph for this function:

std::unordered_set<Vertex> anonymous_namespace{RelAlgExecutionDescriptor.cpp}::get_join_vertices	(	const std::vector< Vertex > &	vertices,
		const DAG &	graph
	)

Definition at line 210 of file RelAlgExecutionDescriptor.cpp.

References CHECK.

Referenced by RaExecutionSequence::RaExecutionSequence().

                                                               {
  std::unordered_set<Vertex> joins;
  for (const auto vert : vertices) {
    if (dynamic_cast<const RelLeftDeepInnerJoin*>(graph[vert])) {
      joins.insert(vert);
      continue;
    }
    if (!dynamic_cast<const RelJoin*>(graph[vert])) {
      continue;
    }
    if (boost::out_degree(vert, graph) > 1) {
      throw std::runtime_error("Join used more than once not supported yet");
    }
    auto [oe_iter, oe_end] = boost::out_edges(vert, graph);
    CHECK(std::next(oe_iter) == oe_end);
    const auto out_vert = boost::target(*oe_iter, graph);
    if (!dynamic_cast<const RelJoin*>(graph[out_vert])) {
      joins.insert(vert);
    }
  }
  return joins;
}

Here is the caller graph for this function:

std::vector<Vertex> anonymous_namespace{RelAlgExecutionDescriptor.cpp}::merge_sort_with_input	(	const std::vector< Vertex > &	vertices,
		const DAG &	graph
	)

Definition at line 133 of file RelAlgExecutionDescriptor.cpp.

References CHECK, and gpu_enabled::sort().

Referenced by RaExecutionSequence::RaExecutionSequence().

                                                            {
  DAG::in_edge_iterator ie_iter, ie_end;
  std::unordered_set<Vertex> inputs;
  for (const auto vert : vertices) {
    if (const auto sort = dynamic_cast<const RelSort*>(graph[vert])) {
      boost::tie(ie_iter, ie_end) = boost::in_edges(vert, graph);
      CHECK(size_t(1) == sort->inputCount() && boost::next(ie_iter) == ie_end);
      const auto in_vert = boost::source(*ie_iter, graph);
      const auto input = graph[in_vert];
      if (dynamic_cast<const RelScan*>(input)) {
        throw std::runtime_error("Standalone sort not supported yet");
      }
      if (boost::out_degree(in_vert, graph) > 1) {
        throw std::runtime_error("Sort's input node used by others not supported yet");
      }
      inputs.insert(in_vert);
    }
  }

  std::vector<Vertex> new_vertices;
  for (const auto vert : vertices) {
    if (inputs.count(vert)) {
      continue;
    }
    new_vertices.push_back(vert);
  }
  return new_vertices;
}

Here is the call graph for this function:

Here is the caller graph for this function: