You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@quickstep.apache.org by ha...@apache.org on 2017/04/23 23:54:11 UTC
incubator-quickstep git commit: Deserialization switch logic is
implemented. [Forced Update!]
Repository: incubator-quickstep
Updated Branches:
refs/heads/frontend-backend 0221d1358 -> 46e411354 (forced update)
Deserialization switch logic is implemented.
Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/46e41135
Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/46e41135
Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/46e41135
Branch: refs/heads/frontend-backend
Commit: 46e4113545548e0b40d8773e3949083f3eea1119
Parents: 9690858
Author: Hakan Memisoglu <ha...@apache.org>
Authored: Sun Apr 23 17:38:42 2017 -0500
Committer: Hakan Memisoglu <ha...@apache.org>
Committed: Sun Apr 23 18:53:51 2017 -0500
----------------------------------------------------------------------
query_execution/CMakeLists.txt | 2 +
query_execution/ExecutionDeserializer.cpp | 182 +++++++++++++++++++++++++
query_execution/ExecutionDeserializer.hpp | 98 +++++++++++++
query_optimizer/ExecutionSerializer.cpp | 80 +++++++----
query_optimizer/Optimizer.cpp | 9 +-
utility/DAG.hpp | 4 +-
6 files changed, 341 insertions(+), 34 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/46e41135/query_execution/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/query_execution/CMakeLists.txt b/query_execution/CMakeLists.txt
index eeed791..e4440fc 100644
--- a/query_execution/CMakeLists.txt
+++ b/query_execution/CMakeLists.txt
@@ -29,6 +29,7 @@ if (ENABLE_DISTRIBUTED)
add_library(quickstep_queryexecution_BlockLocator BlockLocator.cpp BlockLocator.hpp)
add_library(quickstep_queryexecution_BlockLocatorUtil BlockLocatorUtil.cpp BlockLocatorUtil.hpp)
endif(ENABLE_DISTRIBUTED)
+add_library(quickstep_queryexecution_ExecutionDeserializer ExecutionDeserializer.cpp ExecutionDeserializer.hpp)
add_library(quickstep_queryexecution_ForemanBase ../empty_src.cpp ForemanBase.hpp)
if (ENABLE_DISTRIBUTED)
add_library(quickstep_queryexecution_ForemanDistributed ForemanDistributed.cpp ForemanDistributed.hpp)
@@ -357,6 +358,7 @@ target_link_libraries(quickstep_queryexecution_WorkerSelectionPolicy
add_library(quickstep_queryexecution ../empty_src.cpp QueryExecutionModule.hpp)
target_link_libraries(quickstep_queryexecution
quickstep_queryexecution_AdmitRequestMessage
+ quickstep_queryexecution_ExecutionDeserializer
quickstep_queryexecution_ForemanBase
quickstep_queryexecution_ForemanSingleNode
quickstep_queryexecution_PolicyEnforcerBase
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/46e41135/query_execution/ExecutionDeserializer.cpp
----------------------------------------------------------------------
diff --git a/query_execution/ExecutionDeserializer.cpp b/query_execution/ExecutionDeserializer.cpp
new file mode 100644
index 0000000..ddfc2f2
--- /dev/null
+++ b/query_execution/ExecutionDeserializer.cpp
@@ -0,0 +1,182 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ **/
+
+#include "query_execution/ExecutionDeserializer.hpp"
+
+namespace quickstep {
+namespace optimizer {
+
+void ExecutionDeserializer::deserializePlan() {
+ const auto &vertices = query_plan_proto_.vertex();
+ for (const auto &vertex : vertices) {
+ deserializeInternal(vertex);
+ }
+}
+
+void ExecutionDeserializer::deserializeInternal(const S::Vertex &vertex) {
+ switch (vertex.operator_type()) {
+ case serialization::OP_AGGREGATION:
+ return deserializeAggregation(vertex.aggregation_operator());
+ case serialization::OP_BUILD_AGGREGATION_EXISTENCE_MAP:
+ return deserializeBuildAggregationExistenceMap(vertex.build_aggregation_existence_map_operator());
+ case serialization::OP_BUILD_HASH:
+ return deserializeBuildHash(vertex.build_hash_operator());
+ case serialization::OP_BUILD_LIP_FILTER:
+ return deserializeBuildLIPFilter(vertex.build_lip_filter_operator());
+ case serialization::OP_CREATE_INDEX:
+ return deserializeCreateIndex(vertex.create_index_operator());
+ case serialization::OP_CREATE_TABLE:
+ return deserializeCreateTable(vertex.create_table_operator());
+ case serialization::OP_DELETE:
+ return deserializeDelete(vertex.delete_operator());
+ case serialization::OP_DESTROY_AGGREGATION_STATE:
+ return deserializeDestroyAggregationState(vertex.destroy_aggregation_state_operator());
+ case serialization::OP_DESTROY_HASH:
+ return deserializeDestroyHash(vertex.destroy_hash_operator());
+ case serialization::OP_DROP_TABLE:
+ return deserializeDropTable(vertex.drop_table_operator());
+ case serialization::OP_FINALIZE_AGGREGATION:
+ return deserializeFinalizeAggregation(vertex.finalize_aggregation_operator());
+ case serialization::OP_HASH_JOIN:
+ return deserializeHashJoin(vertex.hash_join_operator());
+ case serialization::OP_INITIALIZE_AGGREGATION:
+ return deserializeInitializeAggregation(vertex.initialize_aggregation_operator());
+ case serialization::OP_INSERT:
+ return deserializeInsert(vertex.insert_operator());
+ case serialization::OP_NESTED_LOOP_JOIN:
+ return deserializeNestedLoopsJoin(vertex.nested_loops_join_operator());
+ case serialization::OP_SAMPLE:
+ return deserializeSample(vertex.sample_operator());
+ case serialization::OP_SAVE_BLOCKS:
+ return deserializeSaveBlocks(vertex.save_blocks_operator());
+ case serialization::OP_SELECT:
+ return deserializeSelect(vertex.select_operator());
+ case serialization::OP_SORT_MERGE_RUN:
+ return deserializeSortMergeRun(vertex.sort_merge_run_operator());
+ case serialization::OP_SORT_RUN_GENERATION:
+ return deserializeSortRunGeneration(vertex.sort_run_generation_operator());
+ case serialization::OP_TABLE_GENERATOR:
+ return deserializeTableGenerator(vertex.table_generator_operator());
+ case serialization::OP_TEXT_SCAN:
+ return deserializeTextScan(vertex.text_scan_operator());
+ case serialization::OP_UPDATE:
+ return deserializeUpdate(vertex.update_operator());
+ case serialization::OP_WINDOW_AGGREGATION:
+ return deserializeWindowAggregation(vertex.window_aggregation_operator());
+ }
+}
+
+void ExecutionDeserializer::deserializeAggregation(const S::AggregationOperator &aggregation_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeBuildAggregationExistenceMap(const S::BuildAggregationExistenceMapOperator &op) {
+
+}
+
+void ExecutionDeserializer::deserializeBuildHash(const S::BuildHashOperator &build_hash_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeBuildLIPFilter(const S::BuildLIPFilterOperator &build_lip_filter_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeCreateIndex(const S::CreateIndexOperator &create_index_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeCreateTable(const S::CreateTableOperator &create_table_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeDelete(const S::DeleteOperator &delete_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeDestroyAggregationState(const S::DestroyAggregationStateOperator &destroy_aggregation_state_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeDestroyHash(const S::DestroyHashOperator &destroy_hash_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeDropTable(const S::DropTableOperator &drop_table_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeFinalizeAggregation(const S::FinalizeAggregationOperator &finalize_aggregation_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeHashJoin(const S::HashJoinOperator &finalize_hash_join) {
+
+}
+
+void ExecutionDeserializer::deserializeInitializeAggregation(const S::InitializeAggregationOperator &initialize_aggregation_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeInsert(const S::InsertOperator &insert_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeNestedLoopsJoin(const S::NestedLoopsJoinOperator &nested_loops_join_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeSample(const S::SampleOperator &sample_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeSaveBlocks(const S::SaveBlocksOperator &save_blocks_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeSelect(const S::SelectOperator &select_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeSortMergeRun(const S::SortMergeRunOperator &sort_merge_run_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeSortRunGeneration(const S::SortRunGenerationOperator &sort_run_generation_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeTableGenerator(const S::TableGeneratorOperator &table_generator_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeTextScan(const S::TextScanOperator &text_scan_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeUpdate(const S::UpdateOperator &update_operator) {
+
+}
+
+void ExecutionDeserializer::deserializeWindowAggregation(const S::WindowAggregationOperator &window_aggregation_operator) {
+
+}
+
+}
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/46e41135/query_execution/ExecutionDeserializer.hpp
----------------------------------------------------------------------
diff --git a/query_execution/ExecutionDeserializer.hpp b/query_execution/ExecutionDeserializer.hpp
new file mode 100644
index 0000000..36d5588
--- /dev/null
+++ b/query_execution/ExecutionDeserializer.hpp
@@ -0,0 +1,98 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ **/
+
+#ifndef QUICKSTEP_QUERY_EXECUTION_EXECUTION_DESERIALIZER_HPP
+#define QUICKSTEP_QUERY_EXECUTION_EXECUTION_DESERIALIZER_HPP
+
+#include "relational_operators/AggregationOperator.hpp"
+#include "relational_operators/BuildAggregationExistenceMapOperator.hpp"
+#include "relational_operators/BuildHashOperator.hpp"
+#include "relational_operators/BuildLIPFilterOperator.hpp"
+#include "relational_operators/CreateIndexOperator.hpp"
+#include "relational_operators/CreateTableOperator.hpp"
+#include "relational_operators/RelationalOperator.hpp"
+#include "relational_operators/DeleteOperator.hpp"
+#include "relational_operators/DestroyAggregationStateOperator.hpp"
+#include "relational_operators/DestroyHashOperator.hpp"
+#include "relational_operators/DropTableOperator.hpp"
+#include "relational_operators/FinalizeAggregationOperator.hpp"
+#include "relational_operators/HashJoinOperator.hpp"
+#include "relational_operators/InitializeAggregationOperator.hpp"
+#include "relational_operators/InsertOperator.hpp"
+#include "relational_operators/NestedLoopsJoinOperator.hpp"
+#include "relational_operators/SampleOperator.hpp"
+#include "relational_operators/SaveBlocksOperator.hpp"
+#include "relational_operators/SelectOperator.hpp"
+#include "relational_operators/SortMergeRunOperator.hpp"
+#include "relational_operators/SortRunGenerationOperator.hpp"
+#include "relational_operators/TableGeneratorOperator.hpp"
+#include "relational_operators/TextScanOperator.hpp"
+#include "relational_operators/UpdateOperator.hpp"
+#include "relational_operators/WindowAggregationOperator.hpp"
+
+#include "query_optimizer/QueryPlan.pb.h"
+
+namespace quickstep {
+namespace optimizer {
+
+namespace S = ::quickstep::serialization;
+
+class ExecutionDeserializer {
+ public:
+ ExecutionDeserializer(const S::QueryPlan &query_plan)
+ : query_plan_proto_(query_plan) {
+ }
+
+ void deserializePlan();
+
+ private:
+ void deserializeInternal(const S::Vertex &relational_operator);
+
+ void deserializeAggregation(const S::AggregationOperator &aggregation_operator);
+ void deserializeBuildAggregationExistenceMap(const S::BuildAggregationExistenceMapOperator &op);
+ void deserializeBuildHash(const S::BuildHashOperator &build_hash_operator);
+ void deserializeBuildLIPFilter(const S::BuildLIPFilterOperator &build_lip_filter_operator);
+ void deserializeCreateIndex(const S::CreateIndexOperator &create_index_operator);
+ void deserializeCreateTable(const S::CreateTableOperator &create_table_operator);
+ void deserializeDelete(const S::DeleteOperator &delete_operator);
+ void deserializeDestroyAggregationState(const S::DestroyAggregationStateOperator &destroy_aggregation_state_operator);
+ void deserializeDestroyHash(const S::DestroyHashOperator &destroy_hash_operator);
+ void deserializeDropTable(const S::DropTableOperator &drop_table_operator);
+ void deserializeFinalizeAggregation(const S::FinalizeAggregationOperator &finalize_aggregation_operator);
+ void deserializeHashJoin(const S::HashJoinOperator &finalize_hash_join);
+ void deserializeInitializeAggregation(const S::InitializeAggregationOperator &initialize_aggregation_operator);
+ void deserializeInsert(const S::InsertOperator &insert_operator);
+ void deserializeNestedLoopsJoin(const S::NestedLoopsJoinOperator &nested_loops_join_operator);
+ void deserializeSample(const S::SampleOperator &sample_operator);
+ void deserializeSaveBlocks(const S::SaveBlocksOperator &save_blocks_operator);
+ void deserializeSelect(const S::SelectOperator &select_operator);
+ void deserializeSortMergeRun(const S::SortMergeRunOperator &sort_merge_run_operator);
+ void deserializeSortRunGeneration(const S::SortRunGenerationOperator &sort_run_generation_operator);
+ void deserializeTableGenerator(const S::TableGeneratorOperator &table_generator_operator);
+ void deserializeTextScan(const S::TextScanOperator &text_scan_operator);
+ void deserializeUpdate(const S::UpdateOperator &update_operator);
+ void deserializeWindowAggregation(const S::WindowAggregationOperator &window_aggregation_operator);
+
+ const S::QueryPlan &query_plan_proto_;
+};
+
+}
+}
+
+#endif //QUICKSTEP_EXECUTIONDESERIALIZER_HPP
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/46e41135/query_optimizer/ExecutionSerializer.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/ExecutionSerializer.cpp b/query_optimizer/ExecutionSerializer.cpp
index 892567b..885ec93 100644
--- a/query_optimizer/ExecutionSerializer.cpp
+++ b/query_optimizer/ExecutionSerializer.cpp
@@ -22,11 +22,31 @@
#include <cstddef>
#include "query_optimizer/QueryPlan.hpp"
-#include "relational_operators/RelationalOperator.hpp"
#include "relational_operators/AggregationOperator.hpp"
#include "relational_operators/BuildAggregationExistenceMapOperator.hpp"
#include "relational_operators/BuildHashOperator.hpp"
-
+#include "relational_operators/BuildLIPFilterOperator.hpp"
+#include "relational_operators/CreateIndexOperator.hpp"
+#include "relational_operators/CreateTableOperator.hpp"
+#include "relational_operators/DeleteOperator.hpp"
+#include "relational_operators/DestroyAggregationStateOperator.hpp"
+#include "relational_operators/DestroyHashOperator.hpp"
+#include "relational_operators/DropTableOperator.hpp"
+#include "relational_operators/FinalizeAggregationOperator.hpp"
+#include "relational_operators/HashJoinOperator.hpp"
+#include "relational_operators/InitializeAggregationOperator.hpp"
+#include "relational_operators/InsertOperator.hpp"
+#include "relational_operators/NestedLoopsJoinOperator.hpp"
+#include "relational_operators/RelationalOperator.hpp"
+#include "relational_operators/SampleOperator.hpp"
+#include "relational_operators/SaveBlocksOperator.hpp"
+#include "relational_operators/SelectOperator.hpp"
+#include "relational_operators/SortMergeRunOperator.hpp"
+#include "relational_operators/SortRunGenerationOperator.hpp"
+#include "relational_operators/TableGeneratorOperator.hpp"
+#include "relational_operators/TextScanOperator.hpp"
+#include "relational_operators/UpdateOperator.hpp"
+#include "relational_operators/WindowAggregationOperator.hpp"
#include "query_optimizer/QueryPlan.pb.h"
#include "relational_operators/Operator.pb.h"
@@ -38,6 +58,13 @@ namespace S = ::quickstep::serialization;
void ExecutionSerializer::serializePlan(const QueryPlan &query_plan) {
const auto &dag = query_plan.getQueryPlanDAG();
for (std::size_t i = 0; i < dag.size(); ++i) {
+ const auto &edges = dag.getDependencies(i);
+ S::OutgoingEdges *outgoing_edges = query_plan_proto_.add_outgoing();
+ for (const auto &edge : edges) {
+ S::Edge *edge_proto = outgoing_edges->add_edges();
+ edge_proto->set_outgoing_id(edge);
+ edge_proto->set_payload(dag.getLinkMetadata(i, edge));
+ }
const auto &relational_operator = dag.getNodePayload(i);
serializeInternal(relational_operator);
}
@@ -47,79 +74,79 @@ void ExecutionSerializer::serializeInternal(const RelationalOperator &relational
switch (relational_operator.getOperatorType()) {
case RelationalOperator::OperatorType::kAggregation:
return serializeAggregation(
- dynamic_cast<const AggregationOperator&>(relational_operator));
+ static_cast<const AggregationOperator&>(relational_operator));
case RelationalOperator::kBuildAggregationExistenceMap:
return serializeBuildAggregationExistenceMap(
- dynamic_cast<const BuildAggregationExistenceMapOperator&>(relational_operator));
+ static_cast<const BuildAggregationExistenceMapOperator&>(relational_operator));
case RelationalOperator::kBuildHash:
return serializeBuildHash(
- dynamic_cast<const BuildHashOperator&>(relational_operator));
+ static_cast<const BuildHashOperator&>(relational_operator));
case RelationalOperator::kBuildLIPFilter:
return serializeBuildLIPFilter(
- dynamic_cast<const BuildLIPFilterOperator&>(relational_operator));
+ static_cast<const BuildLIPFilterOperator&>(relational_operator));
case RelationalOperator::kCreateIndex:
return serializeCreateIndex(
- dynamic_cast<const CreateIndexOperator&>(relational_operator));
+ static_cast<const CreateIndexOperator&>(relational_operator));
case RelationalOperator::kCreateTable:
return serializeCreateTable(
- dynamic_cast<const CreateTableOperator&>(relational_operator));
+ static_cast<const CreateTableOperator&>(relational_operator));
case RelationalOperator::kDelete:
return serializeDelete(
- dynamic_cast<const DeleteOperator&>(relational_operator));
+ static_cast<const DeleteOperator&>(relational_operator));
case RelationalOperator::kDestroyAggregationState:
return serializeDestroyAggregationState(
- dynamic_cast<const DestroyAggregationStateOperator&>(relational_operator));
+ static_cast<const DestroyAggregationStateOperator&>(relational_operator));
case RelationalOperator::kDestroyHash:
return serializeDestroyHash(
- dynamic_cast<const DestroyHashOperator&>(relational_operator));
+ static_cast<const DestroyHashOperator&>(relational_operator));
case RelationalOperator::kDropTable:
return serializeDropTable(
- dynamic_cast<const DropTableOperator&>(relational_operator));
+ static_cast<const DropTableOperator&>(relational_operator));
case RelationalOperator::kFinalizeAggregation:
return serializeFinalizeAggregation(
- dynamic_cast<const FinalizeAggregationOperator&>(relational_operator));
+ static_cast<const FinalizeAggregationOperator&>(relational_operator));
case RelationalOperator::kInitializeAggregation:
return serializeInitializeAggregation(
- dynamic_cast<const InitializeAggregationOperator&>(relational_operator));
+ static_cast<const InitializeAggregationOperator&>(relational_operator));
case RelationalOperator::kInsert:
return serializeInsert(
- dynamic_cast<const InsertOperator&>(relational_operator));
+ static_cast<const InsertOperator&>(relational_operator));
case RelationalOperator::kInnerJoin:
case RelationalOperator::kLeftAntiJoin:
case RelationalOperator::kLeftOuterJoin:
case RelationalOperator::kLeftSemiJoin:
return serializeHashJoin(
- dynamic_cast<const HashJoinOperator&>(relational_operator));
+ static_cast<const HashJoinOperator&>(relational_operator));
case RelationalOperator::kNestedLoopsJoin:
return serializeNestedLoopsJoin(
- dynamic_cast<const NestedLoopsJoinOperator&>(relational_operator));
+ static_cast<const NestedLoopsJoinOperator&>(relational_operator));
case RelationalOperator::kSample:
return serializeSample(
- dynamic_cast<const SampleOperator&>(relational_operator));
+ static_cast<const SampleOperator&>(relational_operator));
case RelationalOperator::kSaveBlocks:
return serializeSaveBlocks(
- dynamic_cast<const SaveBlocksOperator&>(relational_operator));
+ static_cast<const SaveBlocksOperator&>(relational_operator));
case RelationalOperator::kSelect:
return serializeSelect(
- dynamic_cast<const SelectOperator&>(relational_operator));
+ static_cast<const SelectOperator&>(relational_operator));
case RelationalOperator::kSortMergeRun:
return serializeSortMergeRun(
- dynamic_cast<const SortMergeRunOperator&>(relational_operator));
+ static_cast<const SortMergeRunOperator&>(relational_operator));
case RelationalOperator::kSortRunGeneration:
return serializeSortRunGeneration(
- dynamic_cast<const SortRunGenerationOperator&>(relational_operator));
+ static_cast<const SortRunGenerationOperator&>(relational_operator));
case RelationalOperator::kTableGenerator:
return serializeTableGenerator(
- dynamic_cast<const TableGeneratorOperator&>(relational_operator));
+ static_cast<const TableGeneratorOperator&>(relational_operator));
case RelationalOperator::kTextScan:
return serializeTextScan(
- dynamic_cast<const TextScanOperator&>(relational_operator));
+ static_cast<const TextScanOperator&>(relational_operator));
case RelationalOperator::kUpdate:
return serializeUpdate(
- dynamic_cast<const UpdateOperator&>(relational_operator));
+ static_cast<const UpdateOperator&>(relational_operator));
case RelationalOperator::kWindowAggregation:
return serializeWindowAggregation(
- dynamic_cast<const WindowAggregationOperator&>(relational_operator));
+ static_cast<const WindowAggregationOperator&>(relational_operator));
case RelationalOperator::kMockOperator:
break;
}
@@ -437,6 +464,5 @@ void ExecutionSerializer::serializeWindowAggregation(const WindowAggregationOper
window_aggregation_operator.getWindowAggregationStateIndex());
}
-
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/46e41135/query_optimizer/Optimizer.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/Optimizer.cpp b/query_optimizer/Optimizer.cpp
index 35ed4ba..cb9cb24 100644
--- a/query_optimizer/Optimizer.cpp
+++ b/query_optimizer/Optimizer.cpp
@@ -20,8 +20,10 @@
#include "query_optimizer/Optimizer.hpp"
#include "query_optimizer/ExecutionGenerator.hpp"
+#include "query_optimizer/ExecutionSerializer.hpp"
#include "query_optimizer/LogicalGenerator.hpp"
+
namespace quickstep {
namespace optimizer {
@@ -32,16 +34,13 @@ void Optimizer::generateQueryHandle(const ParseStatement &parse_statement,
LogicalGenerator logical_generator(optimizer_context);
PhysicalGenerator physical_generator(optimizer_context);
ExecutionGenerator execution_generator(catalog_database, query_handle);
+ ExecutionSerializer execution_serializer;
execution_generator.generatePlan(
physical_generator.generatePlan(
logical_generator.generatePlan(*catalog_database, parse_statement)));
- // TODO(hakan): Break at this point.
- // execution_serializer.serializePlan(
- // execution_generator.generatePlan(
- // physical_generator.generatePlan(
- // logical_generator.generatePlan(*catalog_database, parse_statement))));
+ execution_serializer.serializePlan(execution_generator);
}
} // namespace optimizer
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/46e41135/utility/DAG.hpp
----------------------------------------------------------------------
diff --git a/utility/DAG.hpp b/utility/DAG.hpp
index a1f2619..fcfe1ce 100644
--- a/utility/DAG.hpp
+++ b/utility/DAG.hpp
@@ -165,7 +165,7 @@ class DAG {
* @param dependent_index Index of the dependent node in the DAG.
**/
const LinkMetadataT& getLinkMetadata(const size_type_nodes dependency_index,
- const size_type_nodes dependent_index) {
+ const size_type_nodes dependent_index) const {
return nodes_[dependency_index].getLinkMetadata(dependent_index);
}
@@ -317,7 +317,7 @@ class DAG {
*
* @return The metadata of the link.
**/
- inline const LinkMetadataT& getLinkMetadata(const size_type_nodes node_index) {
+ inline const LinkMetadataT& getLinkMetadata(const size_type_nodes node_index) const {
DCHECK(dependents_with_metadata_.find(node_index) != dependents_with_metadata_.end());
return dependents_with_metadata_[node_index];
}