You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@quickstep.apache.org by ji...@apache.org on 2017/04/21 06:33:37 UTC
[3/3] incubator-quickstep git commit: Add common-subexpression
support.
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/f3d69534
Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/f3d69534
Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/f3d69534
Branch: refs/heads/common-subexpression
Commit: f3d695347110fb5f27f1a76a3e442b9ee43817d1
Parents: 758f07a
Author: Jianqiao Zhu <ji...@cs.wisc.edu>
Authored: Thu Apr 20 15:28:12 2017 -0500
Committer: Jianqiao Zhu <ji...@cs.wisc.edu>
Committed: Fri Apr 21 01:33:28 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 | 18 +-
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 | 251 +++++++++-----
expressions/scalar/ScalarBinaryExpression.hpp | 23 +-
expressions/scalar/ScalarCaseExpression.cpp | 123 +++++--
expressions/scalar/ScalarCaseExpression.hpp | 33 +-
expressions/scalar/ScalarLiteral.cpp | 47 ++-
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 | 31 +-
.../expressions/AttributeReference.cpp | 19 +
.../expressions/AttributeReference.hpp | 5 +
.../expressions/BinaryExpression.cpp | 37 ++
.../expressions/BinaryExpression.hpp | 4 +
query_optimizer/expressions/CMakeLists.txt | 31 +-
query_optimizer/expressions/Cast.cpp | 17 +
query_optimizer/expressions/Cast.hpp | 4 +
.../expressions/CommonSubexpression.cpp | 70 ++++
.../expressions/CommonSubexpression.hpp | 138 ++++++++
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 | 16 +
query_optimizer/expressions/ScalarLiteral.hpp | 5 +
query_optimizer/expressions/SimpleCase.cpp | 46 +++
query_optimizer/expressions/SimpleCase.hpp | 5 +
query_optimizer/expressions/UnaryExpression.cpp | 18 +
query_optimizer/expressions/UnaryExpression.hpp | 5 +
query_optimizer/rules/CMakeLists.txt | 63 ++++
query_optimizer/rules/CollapseSelection.cpp | 57 +++
query_optimizer/rules/CollapseSelection.hpp | 62 ++++
.../rules/ExtractCommonSubexpression.cpp | 264 ++++++++++++++
.../rules/ExtractCommonSubexpression.hpp | 137 ++++++++
.../rules/ReuseAggregateExpressions.cpp | 346 +++++++++++++++++++
.../rules/ReuseAggregateExpressions.hpp | 154 +++++++++
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 | 61 ++++
74 files changed, 2948 insertions(+), 319 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/expressions/predicate/Predicate.hpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/Predicate.hpp b/expressions/predicate/Predicate.hpp
index 5fb3ef5..a7e89ef 100644
--- a/expressions/predicate/Predicate.hpp
+++ b/expressions/predicate/Predicate.hpp
@@ -20,7 +20,10 @@
#ifndef QUICKSTEP_EXPRESSIONS_PREDICATE_PREDICATE_HPP_
#define QUICKSTEP_EXPRESSIONS_PREDICATE_PREDICATE_HPP_
+#include <type_traits>
+
#include "catalog/CatalogTypedefs.hpp"
+#include "expressions/Expression.hpp"
#include "expressions/Expressions.pb.h"
#include "storage/StorageBlockInfo.hpp"
#include "utility/Macros.hpp"
@@ -39,7 +42,7 @@ struct SubBlocksReference;
/**
* @brief Base class for all predicates.
**/
-class Predicate {
+class Predicate : public Expression {
public:
/**
* @brief The possible types of predicates.
@@ -67,6 +70,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 +197,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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/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/f3d69534/expressions/scalar/ScalarBinaryExpression.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarBinaryExpression.cpp b/expressions/scalar/ScalarBinaryExpression.cpp
index 5fe6cde..9ac01b9 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,30 @@ 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));
- 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 +342,38 @@ 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);
+ 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 +403,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/f3d69534/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/f3d69534/expressions/scalar/ScalarCaseExpression.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarCaseExpression.cpp b/expressions/scalar/ScalarCaseExpression.cpp
index c81f723..44e40c2 100644
--- a/expressions/scalar/ScalarCaseExpression.cpp
+++ b/expressions/scalar/ScalarCaseExpression.cpp
@@ -193,18 +193,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 +241,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 +267,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 +327,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 +336,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 +363,8 @@ ColumnVector* ScalarCaseExpression::getAllValuesForJoin(
nullptr,
case_positions,
else_positions,
- &case_results,
- else_results.get());
+ case_results,
+ else_results);
}
void ScalarCaseExpression::MultiplexNativeColumnVector(
@@ -420,15 +428,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 +446,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 +469,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 +488,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 +497,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 +512,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/f3d69534/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_;