Add common-subexpression support.
Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/364eb40d Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/364eb40d Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/364eb40d Branch: refs/heads/frontend-backend Commit: 364eb40dd66cea27b81f10856bb90f67a26e39c3 Parents: a4bfab9 Author: Jianqiao Zhu <jianq...@cs.wisc.edu> Authored: Thu Apr 20 15:28:12 2017 -0500 Committer: Hakan Memisoglu <hakanmemiso...@apache.org> Committed: Tue May 2 00:12:54 2017 -0500 ---------------------------------------------------------------------- expressions/CMakeLists.txt | 6 + expressions/Expression.hpp | 53 ++ expressions/ExpressionFactories.cpp | 10 + expressions/Expressions.proto | 8 + expressions/predicate/CMakeLists.txt | 4 +- expressions/predicate/ComparisonPredicate.cpp | 87 ++- expressions/predicate/ComparisonPredicate.hpp | 12 + expressions/predicate/NegationPredicate.cpp | 21 + expressions/predicate/NegationPredicate.hpp | 12 + expressions/predicate/Predicate.cpp | 16 + expressions/predicate/Predicate.hpp | 20 +- expressions/predicate/PredicateWithList.cpp | 54 ++ expressions/predicate/PredicateWithList.hpp | 11 + expressions/scalar/CMakeLists.txt | 18 + expressions/scalar/Scalar.cpp | 15 + expressions/scalar/Scalar.hpp | 40 +- expressions/scalar/ScalarAttribute.cpp | 42 +- expressions/scalar/ScalarAttribute.hpp | 22 +- expressions/scalar/ScalarBinaryExpression.cpp | 257 +++--- expressions/scalar/ScalarBinaryExpression.hpp | 23 +- expressions/scalar/ScalarCaseExpression.cpp | 124 ++- expressions/scalar/ScalarCaseExpression.hpp | 33 +- expressions/scalar/ScalarLiteral.cpp | 48 +- expressions/scalar/ScalarLiteral.hpp | 23 +- expressions/scalar/ScalarSharedExpression.cpp | 141 ++++ expressions/scalar/ScalarSharedExpression.hpp | 127 +++ expressions/scalar/ScalarUnaryExpression.cpp | 84 +- expressions/scalar/ScalarUnaryExpression.hpp | 22 +- .../tests/ScalarCaseExpression_unittest.cpp | 33 +- query_optimizer/CMakeLists.txt | 3 + query_optimizer/PhysicalGenerator.cpp | 35 +- .../expressions/AttributeReference.cpp | 19 + .../expressions/AttributeReference.hpp | 6 + .../expressions/BinaryExpression.cpp | 37 + .../expressions/BinaryExpression.hpp | 4 + query_optimizer/expressions/CMakeLists.txt | 32 +- query_optimizer/expressions/Cast.cpp | 17 + query_optimizer/expressions/Cast.hpp | 4 + .../expressions/CommonSubexpression.cpp | 72 ++ .../expressions/CommonSubexpression.hpp | 141 ++++ query_optimizer/expressions/ExpressionType.hpp | 3 +- query_optimizer/expressions/ExpressionUtil.hpp | 6 +- query_optimizer/expressions/NamedExpression.hpp | 13 - query_optimizer/expressions/PatternMatcher.hpp | 9 +- query_optimizer/expressions/Scalar.hpp | 41 + query_optimizer/expressions/ScalarLiteral.cpp | 23 + query_optimizer/expressions/ScalarLiteral.hpp | 5 + query_optimizer/expressions/SimpleCase.cpp | 46 ++ query_optimizer/expressions/SimpleCase.hpp | 5 + query_optimizer/expressions/UnaryExpression.cpp | 17 + query_optimizer/expressions/UnaryExpression.hpp | 5 + query_optimizer/rules/CMakeLists.txt | 66 ++ query_optimizer/rules/CollapseSelection.cpp | 59 ++ query_optimizer/rules/CollapseSelection.hpp | 62 ++ .../rules/ExtractCommonSubexpression.cpp | 376 +++++++++ .../rules/ExtractCommonSubexpression.hpp | 179 +++++ .../rules/ReuseAggregateExpressions.cpp | 349 +++++++++ .../rules/ReuseAggregateExpressions.hpp | 154 ++++ .../tests/execution_generator/CMakeLists.txt | 12 + .../CommonSubexpression.test | 52 ++ .../tests/physical_generator/CMakeLists.txt | 4 + .../physical_generator/CommonSubexpression.test | 772 +++++++++++++++++++ .../tests/physical_generator/Select.test | 112 +-- relational_operators/CMakeLists.txt | 2 + relational_operators/HashJoinOperator.cpp | 51 +- .../NestedLoopsJoinOperator.cpp | 6 +- storage/AggregationOperationState.cpp | 4 +- storage/CMakeLists.txt | 3 + storage/StorageBlock.cpp | 10 +- storage/WindowAggregationOperationState.cpp | 8 +- types/containers/CMakeLists.txt | 3 +- types/containers/ColumnVector.hpp | 14 +- types/containers/ColumnVectorsValueAccessor.hpp | 23 +- .../binary_operations/AddBinaryOperation.hpp | 4 + .../binary_operations/BinaryOperation.hpp | 13 + .../MultiplyBinaryOperation.hpp | 4 + utility/CMakeLists.txt | 7 + utility/ColumnVectorCache.hpp | 89 +++ utility/HashError.hpp | 62 ++ 79 files changed, 4040 insertions(+), 369 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/CMakeLists.txt b/expressions/CMakeLists.txt index b1f1fb1..33606cd 100644 --- a/expressions/CMakeLists.txt +++ b/expressions/CMakeLists.txt @@ -25,12 +25,16 @@ QS_PROTOBUF_GENERATE_CPP(expressions_Expressions_proto_srcs expressions_Expressions_proto_hdrs Expressions.proto) +add_library(quickstep_expressions_Expression ../empty_src.cpp Expression.hpp) add_library(quickstep_expressions_ExpressionFactories ExpressionFactories.cpp ExpressionFactories.hpp) add_library(quickstep_expressions_Expressions_proto ${expressions_Expressions_proto_srcs}) +target_link_libraries(quickstep_expressions_Expression + quickstep_utility_Macros + quickstep_utility_TreeStringSerializable) target_link_libraries(quickstep_expressions_ExpressionFactories glog quickstep_catalog_CatalogDatabaseLite @@ -48,6 +52,7 @@ target_link_libraries(quickstep_expressions_ExpressionFactories quickstep_expressions_scalar_ScalarBinaryExpression quickstep_expressions_scalar_ScalarCaseExpression quickstep_expressions_scalar_ScalarLiteral + quickstep_expressions_scalar_ScalarSharedExpression quickstep_expressions_scalar_ScalarUnaryExpression quickstep_types_TypeFactory quickstep_types_TypedValue @@ -64,6 +69,7 @@ target_link_libraries(quickstep_expressions_Expressions_proto # Module all-in-one library: add_library(quickstep_expressions ../empty_src.cpp ExpressionsModule.hpp) target_link_libraries(quickstep_expressions + quickstep_expressions_Expression quickstep_expressions_ExpressionFactories quickstep_expressions_Expressions_proto quickstep_expressions_aggregation http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/Expression.hpp ---------------------------------------------------------------------- diff --git a/expressions/Expression.hpp b/expressions/Expression.hpp new file mode 100644 index 0000000..39815c3 --- /dev/null +++ b/expressions/Expression.hpp @@ -0,0 +1,53 @@ +/** + * 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_EXPRESSIONS_EXPRESSION_HPP_ +#define QUICKSTEP_EXPRESSIONS_EXPRESSION_HPP_ + +#include "utility/Macros.hpp" +#include "utility/TreeStringSerializable.hpp" + +namespace quickstep { + +/** \addtogroup Expressions + * @{ + */ + +/** + * @brief Base class for all expressions (scalars and predicates) in the backend. + */ +class Expression : public TreeStringSerializable<const Expression*> { + public: + /** + * @brief Virtual destructor. + **/ + virtual ~Expression() {} + + protected: + Expression() {} + + private: + DISALLOW_COPY_AND_ASSIGN(Expression); +}; + +/** @} */ + +} // namespace quickstep + +#endif // QUICKSTEP_EXPRESSIONS_EXPRESSION_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/ExpressionFactories.cpp ---------------------------------------------------------------------- diff --git a/expressions/ExpressionFactories.cpp b/expressions/ExpressionFactories.cpp index 01d22a0..871db50 100644 --- a/expressions/ExpressionFactories.cpp +++ b/expressions/ExpressionFactories.cpp @@ -39,6 +39,7 @@ #include "expressions/scalar/ScalarBinaryExpression.hpp" #include "expressions/scalar/ScalarCaseExpression.hpp" #include "expressions/scalar/ScalarLiteral.hpp" +#include "expressions/scalar/ScalarSharedExpression.hpp" #include "expressions/scalar/ScalarUnaryExpression.hpp" #include "types/TypeFactory.hpp" #include "types/TypedValue.hpp" @@ -210,6 +211,11 @@ Scalar* ScalarFactory::ReconstructFromProto(const serialization::Scalar &proto, std::move(result_expressions), else_result_expression.release()); } + case serialization::Scalar::SHARED_EXPRESSION: { + return new ScalarSharedExpression( + proto.GetExtension(serialization::ScalarSharedExpression::share_id), + ReconstructFromProto(proto.GetExtension(serialization::ScalarSharedExpression::operand), database)); + } default: FATAL_ERROR("Unknown Scalar data source in ScalarFactory::ReconstructFromProto"); } @@ -302,6 +308,10 @@ bool ScalarFactory::ProtoIsValid(const serialization::Scalar &proto, // Everything checks out. return true; } + case serialization::Scalar::SHARED_EXPRESSION: { + return proto.HasExtension(serialization::ScalarSharedExpression::share_id) + && proto.HasExtension(serialization::ScalarSharedExpression::operand); + } default: { break; } http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/Expressions.proto ---------------------------------------------------------------------- diff --git a/expressions/Expressions.proto b/expressions/Expressions.proto index 8d923c5..8b4611e 100644 --- a/expressions/Expressions.proto +++ b/expressions/Expressions.proto @@ -50,6 +50,7 @@ message Scalar { UNARY_EXPRESSION = 2; BINARY_EXPRESSION = 3; CASE_EXPRESSION = 4; + SHARED_EXPRESSION = 5; } required ScalarDataSource data_source = 1; @@ -123,3 +124,10 @@ message ScalarCaseExpression { optional Scalar else_result_expression = 163; } } + +message ScalarSharedExpression { + extend Scalar { + optional int32 share_id = 196; + optional Scalar operand = 197; + } +} http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/predicate/CMakeLists.txt b/expressions/predicate/CMakeLists.txt index b90562c..04abfc7 100644 --- a/expressions/predicate/CMakeLists.txt +++ b/expressions/predicate/CMakeLists.txt @@ -35,7 +35,7 @@ add_library(quickstep_expressions_predicate_PredicateCost ../../empty_src.cpp PredicateCost.hpp) add_library(quickstep_expressions_predicate_PredicateWithList - ../../empty_src.cpp + PredicateWithList.cpp PredicateWithList.hpp) add_library(quickstep_expressions_predicate_TrivialPredicates ../../empty_src.cpp @@ -61,6 +61,7 @@ target_link_libraries(quickstep_expressions_predicate_ComparisonPredicate quickstep_types_containers_ColumnVector quickstep_types_operations_Operation_proto quickstep_types_operations_comparisons_Comparison + quickstep_types_operations_comparisons_ComparisonID quickstep_utility_Macros quickstep_utility_PtrVector) target_link_libraries(quickstep_expressions_predicate_ConjunctionPredicate @@ -92,6 +93,7 @@ target_link_libraries(quickstep_expressions_predicate_NegationPredicate quickstep_utility_Macros) target_link_libraries(quickstep_expressions_predicate_Predicate quickstep_catalog_CatalogTypedefs + quickstep_expressions_Expression quickstep_expressions_Expressions_proto quickstep_storage_StorageBlockInfo quickstep_storage_TupleIdSequence http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/ComparisonPredicate.cpp ---------------------------------------------------------------------- diff --git a/expressions/predicate/ComparisonPredicate.cpp b/expressions/predicate/ComparisonPredicate.cpp index 5f8612e..2f7b84b 100644 --- a/expressions/predicate/ComparisonPredicate.cpp +++ b/expressions/predicate/ComparisonPredicate.cpp @@ -23,6 +23,7 @@ #include <limits> #include <memory> #include <string> +#include <type_traits> #include <utility> #include <vector> @@ -41,6 +42,7 @@ #include "types/containers/ColumnVector.hpp" #include "types/operations/Operation.pb.h" #include "types/operations/comparisons/Comparison.hpp" +#include "types/operations/comparisons/ComparisonID.hpp" #include "utility/Macros.hpp" #include "utility/PtrVector.hpp" @@ -190,18 +192,20 @@ TupleIdSequence* ComparisonPredicate::getAllMatches( #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION if (short_circuit_adapter) { - std::unique_ptr<ColumnVector> right_values(right_operand_->getAllValues( + ColumnVectorPtr right_values(right_operand_->getAllValues( short_circuit_adapter.get(), - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareStaticValueAndColumnVector( left_operand_->getStaticValue(), *right_values, nullptr, filter); } else { - std::unique_ptr<ColumnVector> right_values(right_operand_->getAllValues( + ColumnVectorPtr right_values(right_operand_->getAllValues( accessor, - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareStaticValueAndColumnVector( left_operand_->getStaticValue(), *right_values, @@ -222,18 +226,20 @@ TupleIdSequence* ComparisonPredicate::getAllMatches( #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION if (short_circuit_adapter) { - std::unique_ptr<ColumnVector> left_values(left_operand_->getAllValues( + ColumnVectorPtr left_values(left_operand_->getAllValues( short_circuit_adapter.get(), - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareColumnVectorAndStaticValue( *left_values, right_operand_->getStaticValue(), nullptr, filter); } else { - std::unique_ptr<ColumnVector> left_values(left_operand_->getAllValues( + ColumnVectorPtr left_values(left_operand_->getAllValues( accessor, - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareColumnVectorAndStaticValue( *left_values, right_operand_->getStaticValue(), @@ -255,9 +261,10 @@ TupleIdSequence* ComparisonPredicate::getAllMatches( filter); } else { if (short_circuit_adapter) { - std::unique_ptr<ColumnVector> right_values(right_operand_->getAllValues( + ColumnVectorPtr right_values(right_operand_->getAllValues( short_circuit_adapter.get(), - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareValueAccessorAndColumnVector( short_circuit_adapter.get(), left_operand_attr_id, @@ -265,9 +272,10 @@ TupleIdSequence* ComparisonPredicate::getAllMatches( nullptr, filter); } else { - std::unique_ptr<ColumnVector> right_values(right_operand_->getAllValues( + ColumnVectorPtr right_values(right_operand_->getAllValues( accessor, - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareValueAccessorAndColumnVector(accessor, left_operand_attr_id, *right_values, @@ -277,9 +285,10 @@ TupleIdSequence* ComparisonPredicate::getAllMatches( } } else if (right_operand_attr_id != -1) { if (short_circuit_adapter) { - std::unique_ptr<ColumnVector> left_values(left_operand_->getAllValues( + ColumnVectorPtr left_values(left_operand_->getAllValues( short_circuit_adapter.get(), - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareColumnVectorAndValueAccessor( *left_values, short_circuit_adapter.get(), @@ -287,9 +296,10 @@ TupleIdSequence* ComparisonPredicate::getAllMatches( nullptr, filter); } else { - std::unique_ptr<ColumnVector> left_values(left_operand_->getAllValues( + ColumnVectorPtr left_values(left_operand_->getAllValues( accessor, - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareColumnVectorAndValueAccessor(*left_values, accessor, right_operand_attr_id, @@ -300,23 +310,27 @@ TupleIdSequence* ComparisonPredicate::getAllMatches( #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION if (short_circuit_adapter) { - std::unique_ptr<ColumnVector> left_values(left_operand_->getAllValues( + ColumnVectorPtr left_values(left_operand_->getAllValues( short_circuit_adapter.get(), - sub_blocks_ref)); - std::unique_ptr<ColumnVector> right_values(right_operand_->getAllValues( + sub_blocks_ref, + nullptr /* cv_cache */)); + ColumnVectorPtr right_values(right_operand_->getAllValues( short_circuit_adapter.get(), - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareColumnVectors(*left_values, *right_values, nullptr, filter); } else { - std::unique_ptr<ColumnVector> left_values(left_operand_->getAllValues( + ColumnVectorPtr left_values(left_operand_->getAllValues( accessor, - sub_blocks_ref)); - std::unique_ptr<ColumnVector> right_values(right_operand_->getAllValues( + sub_blocks_ref, + nullptr /* cv_cache */)); + ColumnVectorPtr right_values(right_operand_->getAllValues( accessor, - sub_blocks_ref)); + sub_blocks_ref, + nullptr /* cv_cache */)); return fast_comparator_->compareColumnVectors(*left_values, *right_values, filter, @@ -373,4 +387,29 @@ void ComparisonPredicate::initHelper(bool own_children) { } } +void ComparisonPredicate::getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const { + Predicate::getFieldStringItems(inline_field_names, + inline_field_values, + non_container_child_field_names, + non_container_child_fields, + container_child_field_names, + container_child_fields); + + inline_field_names->emplace_back("comparison"); + inline_field_values->emplace_back( + kComparisonNames[static_cast<std::underlying_type<ComparisonID>::type>( + comparison_.getComparisonID())]); + + non_container_child_field_names->emplace_back("left_operand"); + non_container_child_fields->emplace_back(left_operand_.get()); + non_container_child_field_names->emplace_back("right_operand"); + non_container_child_fields->emplace_back(right_operand_.get()); +} + } // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/ComparisonPredicate.hpp ---------------------------------------------------------------------- diff --git a/expressions/predicate/ComparisonPredicate.hpp b/expressions/predicate/ComparisonPredicate.hpp index 9030857..1ef2cb1 100644 --- a/expressions/predicate/ComparisonPredicate.hpp +++ b/expressions/predicate/ComparisonPredicate.hpp @@ -21,7 +21,9 @@ #define QUICKSTEP_EXPRESSIONS_PREDICATE_COMPARISON_PREDICATE_HPP_ #include <memory> +#include <string> #include <utility> +#include <vector> #include "catalog/CatalogTypedefs.hpp" #include "expressions/Expressions.pb.h" @@ -35,6 +37,7 @@ namespace quickstep { +class Expression; class TupleIdSequence; class ValueAccessor; @@ -137,6 +140,15 @@ class ComparisonPredicate : public Predicate { **/ std::pair<bool, attribute_id> getAttributeFromAttributeLiteralComparison() const; + protected: + void getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const override; + private: const Comparison &comparison_; std::unique_ptr<Scalar> left_operand_; http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/NegationPredicate.cpp ---------------------------------------------------------------------- diff --git a/expressions/predicate/NegationPredicate.cpp b/expressions/predicate/NegationPredicate.cpp index bee1c8d..92a8411 100644 --- a/expressions/predicate/NegationPredicate.cpp +++ b/expressions/predicate/NegationPredicate.cpp @@ -19,6 +19,9 @@ #include "expressions/predicate/NegationPredicate.hpp" +#include <string> +#include <vector> + #include "expressions/Expressions.pb.h" #include "expressions/predicate/Predicate.hpp" #include "storage/TupleIdSequence.hpp" @@ -120,4 +123,22 @@ Predicate* NegationPredicate::NegatePredicate(Predicate *operand) { } } +void NegationPredicate::getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const { + Predicate::getFieldStringItems(inline_field_names, + inline_field_values, + non_container_child_field_names, + non_container_child_fields, + container_child_field_names, + container_child_fields); + + non_container_child_field_names->emplace_back("operand"); + non_container_child_fields->emplace_back(operand_.get()); +} + } // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/NegationPredicate.hpp ---------------------------------------------------------------------- diff --git a/expressions/predicate/NegationPredicate.hpp b/expressions/predicate/NegationPredicate.hpp index 33c6df8..ec005ea 100644 --- a/expressions/predicate/NegationPredicate.hpp +++ b/expressions/predicate/NegationPredicate.hpp @@ -21,6 +21,8 @@ #define QUICKSTEP_EXPRESSIONS_PREDICATE_NEGATION_PREDICATE_HPP_ #include <memory> +#include <string> +#include <vector> #include "catalog/CatalogTypedefs.hpp" #include "expressions/Expressions.pb.h" @@ -30,6 +32,7 @@ namespace quickstep { +class Expression; class TupleIdSequence; class ValueAccessor; @@ -105,6 +108,15 @@ class NegationPredicate : public Predicate { bool getStaticResult() const override; + protected: + void getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const override; + private: void initHelper(); http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/Predicate.cpp ---------------------------------------------------------------------- diff --git a/expressions/predicate/Predicate.cpp b/expressions/predicate/Predicate.cpp index 006e8f1..1f61d62 100644 --- a/expressions/predicate/Predicate.cpp +++ b/expressions/predicate/Predicate.cpp @@ -19,6 +19,9 @@ #include "expressions/predicate/Predicate.hpp" +#include <string> +#include <vector> + #include "storage/TupleIdSequence.hpp" #include "storage/ValueAccessor.hpp" #include "utility/Macros.hpp" @@ -57,4 +60,17 @@ TupleIdSequence* Predicate::GenerateSequenceForStaticResult( return result; } +void Predicate::getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const { + if (hasStaticResult()) { + inline_field_names->emplace_back("static_result"); + inline_field_values->emplace_back(getStaticResult() ? "true" : "false"); + } +} + } // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/Predicate.hpp ---------------------------------------------------------------------- diff --git a/expressions/predicate/Predicate.hpp b/expressions/predicate/Predicate.hpp index 5fb3ef5..6a2ba6d 100644 --- a/expressions/predicate/Predicate.hpp +++ b/expressions/predicate/Predicate.hpp @@ -20,7 +20,12 @@ #ifndef QUICKSTEP_EXPRESSIONS_PREDICATE_PREDICATE_HPP_ #define QUICKSTEP_EXPRESSIONS_PREDICATE_PREDICATE_HPP_ +#include <string> +#include <type_traits> +#include <vector> + #include "catalog/CatalogTypedefs.hpp" +#include "expressions/Expression.hpp" #include "expressions/Expressions.pb.h" #include "storage/StorageBlockInfo.hpp" #include "utility/Macros.hpp" @@ -39,7 +44,7 @@ struct SubBlocksReference; /** * @brief Base class for all predicates. **/ -class Predicate { +class Predicate : public Expression { public: /** * @brief The possible types of predicates. @@ -67,6 +72,11 @@ class Predicate { virtual ~Predicate() { } + std::string getName() const override { + return kPredicateTypeNames[ + static_cast<std::underlying_type<PredicateType>::type>(getPredicateType())]; + } + /** * @brief Serialize this predicate in Protocol Buffer form. * @@ -189,6 +199,14 @@ class Predicate { virtual bool getStaticResult() const; protected: + void getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const override; + Predicate() { } http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/PredicateWithList.cpp ---------------------------------------------------------------------- diff --git a/expressions/predicate/PredicateWithList.cpp b/expressions/predicate/PredicateWithList.cpp new file mode 100644 index 0000000..6b3d7a7 --- /dev/null +++ b/expressions/predicate/PredicateWithList.cpp @@ -0,0 +1,54 @@ +/** + * 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 "expressions/predicate/PredicateWithList.hpp" + +#include <string> +#include <vector> + +namespace quickstep { + +void PredicateWithList::getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const { + Predicate::getFieldStringItems(inline_field_names, + inline_field_values, + non_container_child_field_names, + non_container_child_fields, + container_child_field_names, + container_child_fields); + + container_child_field_names->emplace_back("static_operand_list"); + container_child_fields->emplace_back(); + for (const auto &static_operand : static_operand_list_) { + container_child_fields->back().emplace_back(&static_operand); + } + + container_child_field_names->emplace_back("dynamic_operand_list"); + container_child_fields->emplace_back(); + for (const auto &dynamic_operand : dynamic_operand_list_) { + container_child_fields->back().emplace_back(&dynamic_operand); + } +} + +} // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/predicate/PredicateWithList.hpp ---------------------------------------------------------------------- diff --git a/expressions/predicate/PredicateWithList.hpp b/expressions/predicate/PredicateWithList.hpp index b1bf7e5..c6fb99d 100644 --- a/expressions/predicate/PredicateWithList.hpp +++ b/expressions/predicate/PredicateWithList.hpp @@ -20,6 +20,9 @@ #ifndef QUICKSTEP_EXPRESSIONS_PREDICATE_PREDICATE_WITH_LIST_HPP_ #define QUICKSTEP_EXPRESSIONS_PREDICATE_PREDICATE_WITH_LIST_HPP_ +#include <string> +#include <vector> + #include "expressions/predicate/Predicate.hpp" #include "utility/Macros.hpp" #include "utility/PtrList.hpp" @@ -58,6 +61,14 @@ class PredicateWithList : public Predicate { } protected: + void getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const override; + PtrList<Predicate> static_operand_list_; PtrList<Predicate> dynamic_operand_list_; http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/scalar/CMakeLists.txt b/expressions/scalar/CMakeLists.txt index 8f509da..6b52231 100644 --- a/expressions/scalar/CMakeLists.txt +++ b/expressions/scalar/CMakeLists.txt @@ -29,6 +29,9 @@ add_library(quickstep_expressions_scalar_ScalarCaseExpression add_library(quickstep_expressions_scalar_ScalarLiteral ScalarLiteral.cpp ScalarLiteral.hpp) +add_library(quickstep_expressions_scalar_ScalarSharedExpression + ScalarSharedExpression.cpp + ScalarSharedExpression.hpp) add_library(quickstep_expressions_scalar_ScalarUnaryExpression ScalarUnaryExpression.cpp ScalarUnaryExpression.hpp) @@ -36,9 +39,11 @@ add_library(quickstep_expressions_scalar_ScalarUnaryExpression # Link dependencies: target_link_libraries(quickstep_expressions_scalar_Scalar quickstep_catalog_CatalogTypedefs + quickstep_expressions_Expression quickstep_expressions_Expressions_proto quickstep_storage_StorageBlockInfo quickstep_types_TypedValue + quickstep_types_containers_ColumnVector quickstep_utility_Macros) target_link_libraries(quickstep_expressions_scalar_ScalarAttribute quickstep_catalog_CatalogAttribute @@ -65,6 +70,7 @@ target_link_libraries(quickstep_expressions_scalar_ScalarBinaryExpression quickstep_types_containers_ColumnVector quickstep_types_operations_Operation_proto quickstep_types_operations_binaryoperations_BinaryOperation + quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_utility_Macros) target_link_libraries(quickstep_expressions_scalar_ScalarCaseExpression quickstep_catalog_CatalogTypedefs @@ -92,6 +98,16 @@ target_link_libraries(quickstep_expressions_scalar_ScalarLiteral quickstep_types_TypedValue_proto quickstep_types_containers_ColumnVector quickstep_utility_Macros) +target_link_libraries(quickstep_expressions_scalar_ScalarSharedExpression + quickstep_catalog_CatalogTypedefs + quickstep_expressions_Expressions_proto + quickstep_expressions_scalar_Scalar + quickstep_storage_StorageBlockInfo + quickstep_storage_ValueAccessor + quickstep_types_TypedValue + quickstep_types_containers_ColumnVector + quickstep_utility_ColumnVectorCache + quickstep_utility_Macros) target_link_libraries(quickstep_expressions_scalar_ScalarUnaryExpression quickstep_catalog_CatalogTypedefs quickstep_expressions_Expressions_proto @@ -104,6 +120,7 @@ target_link_libraries(quickstep_expressions_scalar_ScalarUnaryExpression quickstep_types_containers_ColumnVector quickstep_types_operations_Operation_proto quickstep_types_operations_unaryoperations_UnaryOperation + quickstep_types_operations_unaryoperations_UnaryOperationID quickstep_utility_Macros) # Submodule all-in-one library: @@ -114,6 +131,7 @@ target_link_libraries(quickstep_expressions_scalar quickstep_expressions_scalar_ScalarBinaryExpression quickstep_expressions_scalar_ScalarCaseExpression quickstep_expressions_scalar_ScalarLiteral + quickstep_expressions_scalar_ScalarSharedExpression quickstep_expressions_scalar_ScalarUnaryExpression) # Tests: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/Scalar.cpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/Scalar.cpp b/expressions/scalar/Scalar.cpp index a1c436c..c552d8b 100644 --- a/expressions/scalar/Scalar.cpp +++ b/expressions/scalar/Scalar.cpp @@ -19,6 +19,9 @@ #include "expressions/scalar/Scalar.hpp" +#include <string> +#include <vector> + #include "utility/Macros.hpp" namespace quickstep { @@ -28,6 +31,7 @@ const char *Scalar::kScalarDataSourceNames[] = { "Attribute", "UnaryExpression", "BinaryExpression", + "SharedExpression", "SimpleCase" }; @@ -35,4 +39,15 @@ const TypedValue& Scalar::getStaticValue() const { FATAL_ERROR("Called getStaticValue() on a Scalar which does not have a static value"); } +void Scalar::getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const { + inline_field_names->emplace_back("result_type"); + inline_field_values->emplace_back(type_.getName()); +} + } // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/Scalar.hpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/Scalar.hpp b/expressions/scalar/Scalar.hpp index 2db850a..472b71c 100644 --- a/expressions/scalar/Scalar.hpp +++ b/expressions/scalar/Scalar.hpp @@ -20,18 +20,22 @@ #ifndef QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_HPP_ #define QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_HPP_ +#include <string> +#include <type_traits> #include <utility> #include <vector> #include "catalog/CatalogTypedefs.hpp" +#include "expressions/Expression.hpp" #include "expressions/Expressions.pb.h" #include "storage/StorageBlockInfo.hpp" #include "types/TypedValue.hpp" +#include "types/containers/ColumnVector.hpp" #include "utility/Macros.hpp" namespace quickstep { -class ColumnVector; +class ColumnVectorCache; class Type; class ValueAccessor; @@ -44,7 +48,7 @@ struct SubBlocksReference; /** * @brief Base class for anything which evaluates to a Scalar value. **/ -class Scalar { +class Scalar : public Expression { public: /** * @brief The possible provenance of Scalar values. @@ -55,6 +59,7 @@ class Scalar { kUnaryExpression, kBinaryExpression, kCaseExpression, + kSharedExpression, kNumScalarDataSources // Not a real ScalarDataSource, exists for counting purposes. }; @@ -70,6 +75,11 @@ class Scalar { virtual ~Scalar() { } + std::string getName() const override { + return kScalarDataSourceNames[ + static_cast<std::underlying_type<ScalarDataSource>::type>(getDataSource())]; + } + /** * @brief Serialize this scalar in Protocol Buffer form. * @@ -197,11 +207,14 @@ class Scalar { * fast-path (non-scan) evaluation of Predicates embedded in this * scalar (e.g. WHEN predicates in ScalarCaseExpression). May be NULL, * in which case scan-based evaluation is always used. + * @param cv_cache If non-NULL, used as memoization table that is updated and + * looked up during evaluation, for results of common subexpressions. * @return A ColumnVector of this Scalar's values for each tuple accesible * via accessor. **/ - virtual ColumnVector* getAllValues(ValueAccessor *accessor, - const SubBlocksReference *sub_blocks_ref) const = 0; + virtual ColumnVectorPtr getAllValues(ValueAccessor *accessor, + const SubBlocksReference *sub_blocks_ref, + ColumnVectorCache *cv_cache) const = 0; /** * @brief Get this Scalar's value for all specified joined tuples from two @@ -215,19 +228,30 @@ class Scalar { * from the right relation. * @param joined_tuple_ids A series of pairs of tuple ids from the left and * right relations that will be joined. + * @param cv_cache If non-NULL, used as memoization table that is updated and + * looked up during evaluation, for results of common subexpressions. * @return A ColumnVector of this Scalar's values for all the joined tuples * specified by joined_tuple_ids. **/ - virtual ColumnVector* getAllValuesForJoin( + virtual ColumnVectorPtr getAllValuesForJoin( const relation_id left_relation_id, ValueAccessor *left_accessor, const relation_id right_relation_id, ValueAccessor *right_accessor, - const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const = 0; + const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids, + ColumnVectorCache *cv_cache) const = 0; protected: - explicit Scalar(const Type &type) : type_(type) { - } + void getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const override; + + explicit Scalar(const Type &type) + : Expression(), type_(type) {} const Type &type_; http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/ScalarAttribute.cpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarAttribute.cpp b/expressions/scalar/ScalarAttribute.cpp index cc42084..036eeba 100644 --- a/expressions/scalar/ScalarAttribute.cpp +++ b/expressions/scalar/ScalarAttribute.cpp @@ -19,6 +19,7 @@ #include "expressions/scalar/ScalarAttribute.hpp" +#include <string> #include <utility> #include <vector> @@ -88,13 +89,15 @@ relation_id ScalarAttribute::getRelationIdForValueAccessor() const { return attribute_.getParent().getID(); } -ColumnVector* ScalarAttribute::getAllValues(ValueAccessor *accessor, - const SubBlocksReference *sub_blocks_ref) const { +ColumnVectorPtr ScalarAttribute::getAllValues( + ValueAccessor *accessor, + const SubBlocksReference *sub_blocks_ref, + ColumnVectorCache *cv_cache) const { const attribute_id attr_id = attribute_.getID(); const Type &result_type = attribute_.getType(); return InvokeOnValueAccessorMaybeTupleIdSequenceAdapter( accessor, - [&attr_id, &result_type](auto *accessor) -> ColumnVector* { // NOLINT(build/c++11) + [&attr_id, &result_type](auto *accessor) -> ColumnVectorPtr { // NOLINT(build/c++11) if (NativeColumnVector::UsableForType(result_type)) { NativeColumnVector *result = new NativeColumnVector(result_type, accessor->getNumTuples()); @@ -139,7 +142,7 @@ ColumnVector* ScalarAttribute::getAllValues(ValueAccessor *accessor, } } } - return result; + return ColumnVectorPtr(result); } else { IndirectColumnVector *result = new IndirectColumnVector(result_type, accessor->getNumTuples()); @@ -147,17 +150,18 @@ ColumnVector* ScalarAttribute::getAllValues(ValueAccessor *accessor, while (accessor->next()) { result->appendTypedValue(accessor->getTypedValue(attr_id)); } - return result; + return ColumnVectorPtr(result); } }); } -ColumnVector* ScalarAttribute::getAllValuesForJoin( +ColumnVectorPtr ScalarAttribute::getAllValuesForJoin( const relation_id left_relation_id, ValueAccessor *left_accessor, const relation_id right_relation_id, ValueAccessor *right_accessor, - const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const { + const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids, + ColumnVectorCache *cv_cache) const { DCHECK((attribute_.getParent().getID() == left_relation_id) || (attribute_.getParent().getID() == right_relation_id)); @@ -173,7 +177,7 @@ ColumnVector* ScalarAttribute::getAllValuesForJoin( [&joined_tuple_ids, &attr_id, &result_type, - &using_left_relation](auto *accessor) -> ColumnVector* { // NOLINT(build/c++11) + &using_left_relation](auto *accessor) -> ColumnVectorPtr { // NOLINT(build/c++11) if (NativeColumnVector::UsableForType(result_type)) { NativeColumnVector *result = new NativeColumnVector(result_type, joined_tuple_ids.size()); @@ -196,7 +200,7 @@ ColumnVector* ScalarAttribute::getAllValuesForJoin( using_left_relation ? joined_pair.first : joined_pair.second)); } } - return result; + return ColumnVectorPtr(result); } else { IndirectColumnVector *result = new IndirectColumnVector(result_type, joined_tuple_ids.size()); @@ -206,9 +210,27 @@ ColumnVector* ScalarAttribute::getAllValuesForJoin( attr_id, using_left_relation ? joined_pair.first : joined_pair.second)); } - return result; + return ColumnVectorPtr(result); } }); } +void ScalarAttribute::getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const { + Scalar::getFieldStringItems(inline_field_names, + inline_field_values, + non_container_child_field_names, + non_container_child_fields, + container_child_field_names, + container_child_fields); + + inline_field_names->emplace_back("attribute"); + inline_field_values->emplace_back(std::to_string(attribute_.getID())); +} + } // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/ScalarAttribute.hpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarAttribute.hpp b/expressions/scalar/ScalarAttribute.hpp index c6a41df..4d30fe9 100644 --- a/expressions/scalar/ScalarAttribute.hpp +++ b/expressions/scalar/ScalarAttribute.hpp @@ -20,6 +20,7 @@ #ifndef QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_ATTRIBUTE_HPP_ #define QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_ATTRIBUTE_HPP_ +#include <string> #include <utility> #include <vector> @@ -28,12 +29,13 @@ #include "expressions/scalar/Scalar.hpp" #include "storage/StorageBlockInfo.hpp" #include "types/TypedValue.hpp" +#include "types/containers/ColumnVector.hpp" #include "utility/Macros.hpp" namespace quickstep { class CatalogAttribute; -class ColumnVector; +class ColumnVectorCache; class ValueAccessor; struct SubBlocksReference; @@ -77,21 +79,31 @@ class ScalarAttribute : public Scalar { relation_id getRelationIdForValueAccessor() const override; - ColumnVector* getAllValues(ValueAccessor *accessor, - const SubBlocksReference *sub_blocks_ref) const override; + ColumnVectorPtr getAllValues(ValueAccessor *accessor, + const SubBlocksReference *sub_blocks_ref, + ColumnVectorCache *cv_cache) const override; - ColumnVector* getAllValuesForJoin( + ColumnVectorPtr getAllValuesForJoin( const relation_id left_relation_id, ValueAccessor *left_accessor, const relation_id right_relation_id, ValueAccessor *right_accessor, - const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const override; + const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids, + ColumnVectorCache *cv_cache) const override; const CatalogAttribute& getAttribute() const { return attribute_; } protected: + void getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const override; + const CatalogAttribute &attribute_; private: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/ScalarBinaryExpression.cpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarBinaryExpression.cpp b/expressions/scalar/ScalarBinaryExpression.cpp index 5fe6cde..b3568f8 100644 --- a/expressions/scalar/ScalarBinaryExpression.cpp +++ b/expressions/scalar/ScalarBinaryExpression.cpp @@ -21,6 +21,7 @@ #include <memory> #include <string> +#include <type_traits> #include <utility> #include <vector> @@ -33,6 +34,7 @@ #include "types/containers/ColumnVector.hpp" #include "types/operations/Operation.pb.h" #include "types/operations/binary_operations/BinaryOperation.hpp" +#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "glog/logging.h" @@ -101,13 +103,15 @@ TypedValue ScalarBinaryExpression::getValueForJoinedTuples( } } -ColumnVector* ScalarBinaryExpression::getAllValues( +ColumnVectorPtr ScalarBinaryExpression::getAllValues( ValueAccessor *accessor, - const SubBlocksReference *sub_blocks_ref) const { + const SubBlocksReference *sub_blocks_ref, + ColumnVectorCache *cv_cache) const { if (fast_operator_.get() == nullptr) { - return ColumnVector::MakeVectorOfValue(getType(), - static_value_, - accessor->getNumTuplesVirtual()); + return ColumnVectorPtr( + ColumnVector::MakeVectorOfValue(getType(), + static_value_, + accessor->getNumTuplesVirtual())); } else { // NOTE(chasseur): We don't check if BOTH operands have a static value, // because if they did then this expression would also have a static value @@ -117,35 +121,39 @@ ColumnVector* ScalarBinaryExpression::getAllValues( const attribute_id right_operand_attr_id = right_operand_->getAttributeIdForValueAccessor(); if (right_operand_attr_id != -1) { - return fast_operator_->applyToStaticValueAndValueAccessor( - left_operand_->getStaticValue(), - accessor, - right_operand_attr_id); + return ColumnVectorPtr( + fast_operator_->applyToStaticValueAndValueAccessor( + left_operand_->getStaticValue(), + accessor, + right_operand_attr_id)); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION - std::unique_ptr<ColumnVector> right_result( - right_operand_->getAllValues(accessor, sub_blocks_ref)); - return fast_operator_->applyToStaticValueAndColumnVector( - left_operand_->getStaticValue(), - *right_result); + ColumnVectorPtr right_result( + right_operand_->getAllValues(accessor, sub_blocks_ref, cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToStaticValueAndColumnVector( + left_operand_->getStaticValue(), + *right_result)); } else if (right_operand_->hasStaticValue()) { #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION const attribute_id left_operand_attr_id = left_operand_->getAttributeIdForValueAccessor(); if (left_operand_attr_id != -1) { - return fast_operator_->applyToValueAccessorAndStaticValue( - accessor, - left_operand_attr_id, - right_operand_->getStaticValue()); + return ColumnVectorPtr( + fast_operator_->applyToValueAccessorAndStaticValue( + accessor, + left_operand_attr_id, + right_operand_->getStaticValue())); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION - std::unique_ptr<ColumnVector> left_result( - left_operand_->getAllValues(accessor, sub_blocks_ref)); - return fast_operator_->applyToColumnVectorAndStaticValue( - *left_result, - right_operand_->getStaticValue()); + ColumnVectorPtr left_result( + left_operand_->getAllValues(accessor, sub_blocks_ref, cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToColumnVectorAndStaticValue( + *left_result, + right_operand_->getStaticValue())); } else { #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION const attribute_id left_operand_attr_id @@ -155,44 +163,53 @@ ColumnVector* ScalarBinaryExpression::getAllValues( if (left_operand_attr_id != -1) { if (right_operand_attr_id != -1) { - return fast_operator_->applyToSingleValueAccessor(accessor, - left_operand_attr_id, - right_operand_attr_id); + return ColumnVectorPtr( + fast_operator_->applyToSingleValueAccessor( + accessor, + left_operand_attr_id, + right_operand_attr_id)); } else { - std::unique_ptr<ColumnVector> right_result( - right_operand_->getAllValues(accessor, sub_blocks_ref)); - return fast_operator_->applyToValueAccessorAndColumnVector(accessor, - left_operand_attr_id, - *right_result); + ColumnVectorPtr right_result( + right_operand_->getAllValues(accessor, sub_blocks_ref, cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToValueAccessorAndColumnVector( + accessor, + left_operand_attr_id, + *right_result)); } } else if (right_operand_attr_id != -1) { - std::unique_ptr<ColumnVector> left_result( - left_operand_->getAllValues(accessor, sub_blocks_ref)); - return fast_operator_->applyToColumnVectorAndValueAccessor(*left_result, - accessor, - right_operand_attr_id); + ColumnVectorPtr left_result( + left_operand_->getAllValues(accessor, sub_blocks_ref, cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToColumnVectorAndValueAccessor( + *left_result, + accessor, + right_operand_attr_id)); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION - std::unique_ptr<ColumnVector> left_result( - left_operand_->getAllValues(accessor, sub_blocks_ref)); - std::unique_ptr<ColumnVector> right_result( - right_operand_->getAllValues(accessor, sub_blocks_ref)); - return fast_operator_->applyToColumnVectors(*left_result, *right_result); + ColumnVectorPtr left_result( + left_operand_->getAllValues(accessor, sub_blocks_ref, cv_cache)); + ColumnVectorPtr right_result( + right_operand_->getAllValues(accessor, sub_blocks_ref, cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToColumnVectors(*left_result, *right_result)); } } } -ColumnVector* ScalarBinaryExpression::getAllValuesForJoin( +ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin( const relation_id left_relation_id, ValueAccessor *left_accessor, const relation_id right_relation_id, ValueAccessor *right_accessor, - const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const { + const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids, + ColumnVectorCache *cv_cache) const { if (fast_operator_.get() == nullptr) { - return ColumnVector::MakeVectorOfValue(getType(), - static_value_, - joined_tuple_ids.size()); + return ColumnVectorPtr( + ColumnVector::MakeVectorOfValue(getType(), + static_value_, + joined_tuple_ids.size())); } else { if (left_operand_->hasStaticValue()) { #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN @@ -207,24 +224,27 @@ ColumnVector* ScalarBinaryExpression::getAllValuesForJoin( const bool using_left_relation = (right_operand_relation_id == left_relation_id); ValueAccessor *right_operand_accessor = using_left_relation ? left_accessor : right_accessor; - return fast_operator_->applyToStaticValueAndValueAccessorForJoin( - left_operand_->getStaticValue(), - right_operand_accessor, - using_left_relation, - right_operand_attr_id, - joined_tuple_ids); + return ColumnVectorPtr( + fast_operator_->applyToStaticValueAndValueAccessorForJoin( + left_operand_->getStaticValue(), + right_operand_accessor, + using_left_relation, + right_operand_attr_id, + joined_tuple_ids)); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN - std::unique_ptr<ColumnVector> right_result( + ColumnVectorPtr right_result( right_operand_->getAllValuesForJoin(left_relation_id, left_accessor, right_relation_id, right_accessor, - joined_tuple_ids)); - return fast_operator_->applyToStaticValueAndColumnVector( - left_operand_->getStaticValue(), - *right_result); + joined_tuple_ids, + cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToStaticValueAndColumnVector( + left_operand_->getStaticValue(), + *right_result)); } else if (right_operand_->hasStaticValue()) { #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN const attribute_id left_operand_attr_id @@ -238,24 +258,27 @@ ColumnVector* ScalarBinaryExpression::getAllValuesForJoin( const bool using_left_relation = (left_operand_relation_id == left_relation_id); ValueAccessor *left_operand_accessor = using_left_relation ? left_accessor : right_accessor; - return fast_operator_->applyToValueAccessorAndStaticValueForJoin( - left_operand_accessor, - using_left_relation, - left_operand_attr_id, - right_operand_->getStaticValue(), - joined_tuple_ids); + return ColumnVectorPtr( + fast_operator_->applyToValueAccessorAndStaticValueForJoin( + left_operand_accessor, + using_left_relation, + left_operand_attr_id, + right_operand_->getStaticValue(), + joined_tuple_ids)); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN - std::unique_ptr<ColumnVector> left_result( + ColumnVectorPtr left_result( left_operand_->getAllValuesForJoin(left_relation_id, left_accessor, right_relation_id, right_accessor, - joined_tuple_ids)); - return fast_operator_->applyToColumnVectorAndStaticValue( - *left_result, - right_operand_->getStaticValue()); + joined_tuple_ids, + cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToColumnVectorAndStaticValue( + *left_result, + right_operand_->getStaticValue())); } else { #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN const attribute_id left_operand_attr_id @@ -284,28 +307,31 @@ ColumnVector* ScalarBinaryExpression::getAllValuesForJoin( = (right_operand_relation_id == left_relation_id); ValueAccessor *right_operand_accessor = using_left_relation_for_right_operand ? left_accessor : right_accessor; - return fast_operator_->applyToValueAccessorsForJoin(left_operand_accessor, - using_left_relation_for_left_operand, - left_operand_attr_id, - right_operand_accessor, - using_left_relation_for_right_operand, - right_operand_attr_id, - joined_tuple_ids); + return ColumnVectorPtr( + fast_operator_->applyToValueAccessorsForJoin(left_operand_accessor, + using_left_relation_for_left_operand, + left_operand_attr_id, + right_operand_accessor, + using_left_relation_for_right_operand, + right_operand_attr_id, + joined_tuple_ids)); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN_WITH_BINARY_EXPRESSIONS - std::unique_ptr<ColumnVector> right_result( + ColumnVectorPtr right_result( right_operand_->getAllValuesForJoin(left_relation_id, left_accessor, right_relation_id, right_accessor, - joined_tuple_ids)); + joined_tuple_ids, + cv_cache)); - return fast_operator_->applyToValueAccessorAndColumnVectorForJoin( - left_operand_accessor, - using_left_relation_for_left_operand, - left_operand_attr_id, - *right_result, - joined_tuple_ids); + return ColumnVectorPtr( + fast_operator_->applyToValueAccessorAndColumnVectorForJoin( + left_operand_accessor, + using_left_relation_for_left_operand, + left_operand_attr_id, + *right_result, + joined_tuple_ids)); } else if (right_operand_attr_id != -1) { const relation_id right_operand_relation_id = right_operand_->getRelationIdForValueAccessor(); @@ -317,34 +343,39 @@ ColumnVector* ScalarBinaryExpression::getAllValuesForJoin( ValueAccessor *right_operand_accessor = using_left_relation_for_right_operand ? left_accessor : right_accessor; - std::unique_ptr<ColumnVector> left_result( + ColumnVectorPtr left_result( left_operand_->getAllValuesForJoin(left_relation_id, left_accessor, right_relation_id, right_accessor, - joined_tuple_ids)); - return fast_operator_->applyToColumnVectorAndValueAccessorForJoin( - *left_result, - right_operand_accessor, - using_left_relation_for_right_operand, - right_operand_attr_id, - joined_tuple_ids); + joined_tuple_ids, + cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToColumnVectorAndValueAccessorForJoin( + *left_result, + right_operand_accessor, + using_left_relation_for_right_operand, + right_operand_attr_id, + joined_tuple_ids)); } #endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN - std::unique_ptr<ColumnVector> left_result( + ColumnVectorPtr left_result( left_operand_->getAllValuesForJoin(left_relation_id, left_accessor, right_relation_id, right_accessor, - joined_tuple_ids)); - std::unique_ptr<ColumnVector> right_result( + joined_tuple_ids, + cv_cache)); + ColumnVectorPtr right_result( right_operand_->getAllValuesForJoin(left_relation_id, left_accessor, right_relation_id, right_accessor, - joined_tuple_ids)); - return fast_operator_->applyToColumnVectors(*left_result, *right_result); + joined_tuple_ids, + cv_cache)); + return ColumnVectorPtr( + fast_operator_->applyToColumnVectors(*left_result, *right_result)); } } } @@ -374,4 +405,38 @@ void ScalarBinaryExpression::initHelper(bool own_children) { } } +void ScalarBinaryExpression::getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const { + Scalar::getFieldStringItems(inline_field_names, + inline_field_values, + non_container_child_field_names, + non_container_child_fields, + container_child_field_names, + container_child_fields); + + if (fast_operator_ == nullptr) { + inline_field_names->emplace_back("static_value"); + if (static_value_.isNull()) { + inline_field_values->emplace_back("NULL"); + } else { + inline_field_values->emplace_back(type_.printValueToString(static_value_)); + } + } + + inline_field_names->emplace_back("operation"); + inline_field_values->emplace_back( + kBinaryOperationNames[static_cast<std::underlying_type<BinaryOperationID>::type>( + operation_.getBinaryOperationID())]); + + non_container_child_field_names->emplace_back("left_operand"); + non_container_child_fields->emplace_back(left_operand_.get()); + non_container_child_field_names->emplace_back("right_operand"); + non_container_child_fields->emplace_back(right_operand_.get()); +} + } // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/ScalarBinaryExpression.hpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarBinaryExpression.hpp b/expressions/scalar/ScalarBinaryExpression.hpp index c84792a..4ac1f62 100644 --- a/expressions/scalar/ScalarBinaryExpression.hpp +++ b/expressions/scalar/ScalarBinaryExpression.hpp @@ -21,6 +21,7 @@ #define QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_BINARY_EXPRESSION_HPP_ #include <memory> +#include <string> #include <utility> #include <vector> @@ -29,6 +30,7 @@ #include "expressions/scalar/Scalar.hpp" #include "storage/StorageBlockInfo.hpp" #include "types/TypedValue.hpp" +#include "types/containers/ColumnVector.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "utility/Macros.hpp" @@ -36,7 +38,7 @@ namespace quickstep { -class ColumnVector; +class ColumnVectorCache; class ValueAccessor; struct SubBlocksReference; @@ -97,15 +99,26 @@ class ScalarBinaryExpression : public Scalar { return static_value_; } - ColumnVector* getAllValues(ValueAccessor *accessor, - const SubBlocksReference *sub_blocks_ref) const override; + ColumnVectorPtr getAllValues(ValueAccessor *accessor, + const SubBlocksReference *sub_blocks_ref, + ColumnVectorCache *cv_cache) const override; - ColumnVector* getAllValuesForJoin( + ColumnVectorPtr getAllValuesForJoin( const relation_id left_relation_id, ValueAccessor *left_accessor, const relation_id right_relation_id, ValueAccessor *right_accessor, - const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const override; + const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids, + ColumnVectorCache *cv_cache) const override; + + protected: + void getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const override; private: void initHelper(bool own_children); http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/ScalarCaseExpression.cpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarCaseExpression.cpp b/expressions/scalar/ScalarCaseExpression.cpp index c81f723..00a7710 100644 --- a/expressions/scalar/ScalarCaseExpression.cpp +++ b/expressions/scalar/ScalarCaseExpression.cpp @@ -21,6 +21,7 @@ #include <cstddef> #include <memory> +#include <string> #include <utility> #include <vector> @@ -193,18 +194,21 @@ TypedValue ScalarCaseExpression::getValueForJoinedTuples( } } -ColumnVector* ScalarCaseExpression::getAllValues( +ColumnVectorPtr ScalarCaseExpression::getAllValues( ValueAccessor *accessor, - const SubBlocksReference *sub_blocks_ref) const { + const SubBlocksReference *sub_blocks_ref, + ColumnVectorCache *cv_cache) const { return InvokeOnValueAccessorMaybeTupleIdSequenceAdapter( accessor, - [&](auto *accessor) -> ColumnVector* { // NOLINT(build/c++11) + [&](auto *accessor) -> ColumnVectorPtr { // NOLINT(build/c++11) if (has_static_value_) { - return ColumnVector::MakeVectorOfValue(type_, - static_value_, - accessor->getNumTuples()); + return ColumnVectorPtr( + ColumnVector::MakeVectorOfValue(type_, + static_value_, + accessor->getNumTuples())); } else if (fixed_result_expression_ != nullptr) { - return fixed_result_expression_->getAllValues(accessor, sub_blocks_ref); + return fixed_result_expression_->getAllValues( + accessor, sub_blocks_ref, cv_cache); } const TupleIdSequence *accessor_sequence = accessor->getTupleIdSequence(); @@ -238,21 +242,23 @@ ColumnVector* ScalarCaseExpression::getAllValues( } // Generate a ColumnVector of all the values for each case. - std::vector<std::unique_ptr<ColumnVector>> case_results; + std::vector<ColumnVectorPtr> case_results; for (std::vector<std::unique_ptr<TupleIdSequence>>::size_type case_idx = 0; case_idx < case_matches.size(); ++case_idx) { std::unique_ptr<ValueAccessor> case_accessor( accessor->createSharedTupleIdSequenceAdapter(*case_matches[case_idx])); case_results.emplace_back( - result_expressions_[case_idx]->getAllValues(case_accessor.get(), sub_blocks_ref)); + result_expressions_[case_idx]->getAllValues( + case_accessor.get(), sub_blocks_ref, cv_cache)); } - std::unique_ptr<ColumnVector> else_results; + ColumnVectorPtr else_results; if (!else_matches->empty()) { std::unique_ptr<ValueAccessor> else_accessor( accessor->createSharedTupleIdSequenceAdapter(*else_matches)); - else_results.reset(else_result_expression_->getAllValues(else_accessor.get(), sub_blocks_ref)); + else_results = else_result_expression_->getAllValues( + else_accessor.get(), sub_blocks_ref, cv_cache); } // Multiplex per-case results into a single ColumnVector with values in the @@ -262,17 +268,18 @@ ColumnVector* ScalarCaseExpression::getAllValues( accessor_sequence, case_matches, *else_matches, - &case_results, - else_results.get()); + case_results, + else_results); }); } -ColumnVector* ScalarCaseExpression::getAllValuesForJoin( +ColumnVectorPtr ScalarCaseExpression::getAllValuesForJoin( const relation_id left_relation_id, ValueAccessor *left_accessor, const relation_id right_relation_id, ValueAccessor *right_accessor, - const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const { + const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids, + ColumnVectorCache *cv_cache) const { // Slice 'joined_tuple_ids' apart by case. // // NOTE(chasseur): We use TupleIdSequence to keep track of the positions in @@ -321,7 +328,7 @@ ColumnVector* ScalarCaseExpression::getAllValuesForJoin( } // Generate a ColumnVector of all the values for each case. - std::vector<std::unique_ptr<ColumnVector>> case_results; + std::vector<ColumnVectorPtr> case_results; for (std::vector<std::vector<std::pair<tuple_id, tuple_id>>>::size_type case_idx = 0; case_idx < case_matches.size(); ++case_idx) { @@ -330,22 +337,24 @@ ColumnVector* ScalarCaseExpression::getAllValuesForJoin( left_accessor, right_relation_id, right_accessor, - case_matches[case_idx])); + case_matches[case_idx], + cv_cache)); } - std::unique_ptr<ColumnVector> else_results; + ColumnVectorPtr else_results; if (!else_positions.empty()) { std::vector<std::pair<tuple_id, tuple_id>> else_matches; for (tuple_id pos : else_positions) { else_matches.emplace_back(joined_tuple_ids[pos]); } - else_results.reset(else_result_expression_->getAllValuesForJoin( + else_results = else_result_expression_->getAllValuesForJoin( left_relation_id, left_accessor, right_relation_id, right_accessor, - else_matches)); + else_matches, + cv_cache); } // Multiplex per-case results into a single ColumnVector with values in the @@ -355,8 +364,8 @@ ColumnVector* ScalarCaseExpression::getAllValuesForJoin( nullptr, case_positions, else_positions, - &case_results, - else_results.get()); + case_results, + else_results); } void ScalarCaseExpression::MultiplexNativeColumnVector( @@ -420,15 +429,15 @@ void ScalarCaseExpression::MultiplexNativeColumnVector( void ScalarCaseExpression::MultiplexIndirectColumnVector( const TupleIdSequence *source_sequence, const TupleIdSequence &case_matches, - IndirectColumnVector *case_result, + const IndirectColumnVector &case_result, IndirectColumnVector *output) { if (source_sequence == nullptr) { TupleIdSequence::const_iterator output_pos_it = case_matches.begin(); for (std::size_t input_pos = 0; - input_pos < case_result->size(); + input_pos < case_result.size(); ++input_pos, ++output_pos_it) { output->positionalWriteTypedValue(*output_pos_it, - case_result->moveTypedValue(input_pos)); + case_result.getTypedValue(input_pos)); } } else { std::size_t input_pos = 0; @@ -438,20 +447,20 @@ void ScalarCaseExpression::MultiplexIndirectColumnVector( ++output_pos, ++source_sequence_it) { if (case_matches.get(*source_sequence_it)) { output->positionalWriteTypedValue(output_pos, - case_result->moveTypedValue(input_pos++)); + case_result.getTypedValue(input_pos++)); } } } } -ColumnVector* ScalarCaseExpression::multiplexColumnVectors( +ColumnVectorPtr ScalarCaseExpression::multiplexColumnVectors( const std::size_t output_size, const TupleIdSequence *source_sequence, const std::vector<std::unique_ptr<TupleIdSequence>> &case_matches, const TupleIdSequence &else_matches, - std::vector<std::unique_ptr<ColumnVector>> *case_results, - ColumnVector *else_result) const { - DCHECK_EQ(case_matches.size(), case_results->size()); + const std::vector<ColumnVectorPtr> &case_results, + const ColumnVectorPtr &else_result) const { + DCHECK_EQ(case_matches.size(), case_results.size()); if (NativeColumnVector::UsableForType(type_)) { std::unique_ptr<NativeColumnVector> native_result( @@ -461,12 +470,12 @@ ColumnVector* ScalarCaseExpression::multiplexColumnVectors( for (std::vector<std::unique_ptr<TupleIdSequence>>::size_type case_idx = 0; case_idx < case_matches.size(); ++case_idx) { - DCHECK((*case_results)[case_idx]->isNative()); + DCHECK(case_results[case_idx]->isNative()); if (!case_matches[case_idx]->empty()) { MultiplexNativeColumnVector( source_sequence, *case_matches[case_idx], - static_cast<const NativeColumnVector&>(*(*case_results)[case_idx]), + static_cast<const NativeColumnVector&>(*case_results[case_idx]), native_result.get()); } } @@ -480,7 +489,7 @@ ColumnVector* ScalarCaseExpression::multiplexColumnVectors( native_result.get()); } - return native_result.release(); + return ColumnVectorPtr(native_result.release()); } else { std::unique_ptr<IndirectColumnVector> indirect_result( new IndirectColumnVector(type_, output_size)); @@ -489,12 +498,12 @@ ColumnVector* ScalarCaseExpression::multiplexColumnVectors( for (std::vector<std::unique_ptr<TupleIdSequence>>::size_type case_idx = 0; case_idx < case_matches.size(); ++case_idx) { - DCHECK(!(*case_results)[case_idx]->isNative()); + DCHECK(!case_results[case_idx]->isNative()); if (!case_matches[case_idx]->empty()) { MultiplexIndirectColumnVector( source_sequence, *case_matches[case_idx], - static_cast<IndirectColumnVector*>((*case_results)[case_idx].get()), + static_cast<const IndirectColumnVector&>(*case_results[case_idx]), indirect_result.get()); } } @@ -504,11 +513,52 @@ ColumnVector* ScalarCaseExpression::multiplexColumnVectors( DCHECK(!else_matches.empty()); MultiplexIndirectColumnVector(source_sequence, else_matches, - static_cast<IndirectColumnVector*>(else_result), + static_cast<const IndirectColumnVector&>(*else_result), indirect_result.get()); } - return indirect_result.release(); + return ColumnVectorPtr(indirect_result.release()); + } +} + +void ScalarCaseExpression::getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const { + Scalar::getFieldStringItems(inline_field_names, + inline_field_values, + non_container_child_field_names, + non_container_child_fields, + container_child_field_names, + container_child_fields); + + if (has_static_value_) { + inline_field_names->emplace_back("static_value"); + if (static_value_.isNull()) { + inline_field_values->emplace_back("NULL"); + } else { + inline_field_values->emplace_back(type_.printValueToString(static_value_)); + } + } + + container_child_field_names->emplace_back("when_predicates"); + container_child_fields->emplace_back(); + for (const auto &predicate : when_predicates_) { + container_child_fields->back().emplace_back(predicate.get()); + } + + container_child_field_names->emplace_back("result_expressions"); + container_child_fields->emplace_back(); + for (const auto &expression : result_expressions_) { + container_child_fields->back().emplace_back(expression.get()); + } + + if (else_result_expression_ != nullptr) { + non_container_child_field_names->emplace_back("else_result_expression"); + non_container_child_fields->emplace_back(else_result_expression_.get()); } } http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/364eb40d/expressions/scalar/ScalarCaseExpression.hpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarCaseExpression.hpp b/expressions/scalar/ScalarCaseExpression.hpp index e6809fa..3d0ed71 100644 --- a/expressions/scalar/ScalarCaseExpression.hpp +++ b/expressions/scalar/ScalarCaseExpression.hpp @@ -22,6 +22,7 @@ #include <cstddef> #include <memory> +#include <string> #include <utility> #include <vector> @@ -31,15 +32,14 @@ #include "expressions/scalar/Scalar.hpp" #include "storage/StorageBlockInfo.hpp" #include "types/TypedValue.hpp" +#include "types/containers/ColumnVector.hpp" #include "utility/Macros.hpp" #include "glog/logging.h" namespace quickstep { -class ColumnVector; -class IndirectColumnVector; -class NativeColumnVector; +class ColumnVectorCache; class TupleIdSequence; class Type; class ValueAccessor; @@ -132,15 +132,26 @@ class ScalarCaseExpression : public Scalar { } } - ColumnVector* getAllValues(ValueAccessor *accessor, - const SubBlocksReference *sub_blocks_ref) const override; + ColumnVectorPtr getAllValues(ValueAccessor *accessor, + const SubBlocksReference *sub_blocks_ref, + ColumnVectorCache *cv_cache) const override; - ColumnVector* getAllValuesForJoin( + ColumnVectorPtr getAllValuesForJoin( const relation_id left_relation_id, ValueAccessor *left_accessor, const relation_id right_relation_id, ValueAccessor *right_accessor, - const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const override; + const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids, + ColumnVectorCache *cv_cache) const override; + + protected: + void getFieldStringItems( + std::vector<std::string> *inline_field_names, + std::vector<std::string> *inline_field_values, + std::vector<std::string> *non_container_child_field_names, + std::vector<const Expression*> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<const Expression*>> *container_child_fields) const override; private: // Merge the values in the NativeColumnVector 'case_result' into '*output' at @@ -158,7 +169,7 @@ class ScalarCaseExpression : public Scalar { static void MultiplexIndirectColumnVector( const TupleIdSequence *source_sequence, const TupleIdSequence &case_matches, - IndirectColumnVector *case_result, + const IndirectColumnVector &case_result, IndirectColumnVector *output); // Create and return a new ColumnVector by multiplexing the ColumnVectors @@ -171,13 +182,13 @@ class ScalarCaseExpression : public Scalar { // the explicit WHEN clauses. Similarly, '*case_results' are the values // generated for the tuples matching each WHEN clause, and '*else_results' // are the values generated for the ELSE tuples. - ColumnVector* multiplexColumnVectors( + ColumnVectorPtr multiplexColumnVectors( const std::size_t output_size, const TupleIdSequence *source_sequence, const std::vector<std::unique_ptr<TupleIdSequence>> &case_matches, const TupleIdSequence &else_matches, - std::vector<std::unique_ptr<ColumnVector>> *case_results, - ColumnVector *else_result) const; + const std::vector<ColumnVectorPtr> &case_results, + const ColumnVectorPtr &else_result) const; std::vector<std::unique_ptr<Predicate>> when_predicates_; std::vector<std::unique_ptr<Scalar>> result_expressions_;