Updates
Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/4005df6e Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/4005df6e Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/4005df6e Branch: refs/heads/new-op Commit: 4005df6e31953458c4cb6e09f6c603cae90ef369 Parents: 6941f90 Author: Jianqiao Zhu <jianq...@cs.wisc.edu> Authored: Tue Mar 14 09:55:05 2017 -0500 Committer: Jianqiao Zhu <jianq...@cs.wisc.edu> Committed: Tue Mar 14 09:55:05 2017 -0500 ---------------------------------------------------------------------- expressions/CMakeLists.txt | 3 +- expressions/ExpressionFactories.cpp | 39 +- expressions/Expressions.proto | 7 +- .../aggregation/AggregateFunctionAvg.cpp | 7 +- .../aggregation/AggregateFunctionSum.cpp | 3 +- .../aggregation/AggregationHandleAvg.cpp | 11 +- .../aggregation/AggregationHandleSum.cpp | 5 +- expressions/aggregation/CMakeLists.txt | 4 - expressions/predicate/CMakeLists.txt | 1 - expressions/scalar/CMakeLists.txt | 9 +- expressions/scalar/ScalarBinaryExpression.cpp | 88 +- expressions/scalar/ScalarBinaryExpression.hpp | 31 +- expressions/scalar/ScalarUnaryExpression.cpp | 26 +- expressions/scalar/ScalarUnaryExpression.hpp | 2 - expressions/window_aggregation/CMakeLists.txt | 4 - .../WindowAggregateFunctionAvg.cpp | 7 +- .../WindowAggregateFunctionSum.cpp | 3 +- .../WindowAggregationHandle.cpp | 3 +- .../WindowAggregationHandle.hpp | 1 - .../WindowAggregationHandleAvg.cpp | 9 +- parser/CMakeLists.txt | 3 - parser/ParseBasicExpressions.cpp | 27 - parser/ParseBasicExpressions.hpp | 86 +- parser/SqlParser.ypp | 40 +- parser/preprocessed/SqlParser_gen.cpp | 2596 +++++++++--------- parser/preprocessed/SqlParser_gen.hpp | 4 +- query_optimizer/LogicalGenerator.cpp | 3 +- .../expressions/BinaryExpression.cpp | 64 +- .../expressions/BinaryExpression.hpp | 56 +- query_optimizer/expressions/CMakeLists.txt | 3 +- query_optimizer/expressions/UnaryExpression.cpp | 5 +- query_optimizer/expressions/UnaryExpression.hpp | 1 - query_optimizer/resolver/CMakeLists.txt | 2 +- query_optimizer/resolver/Resolver.cpp | 263 +- query_optimizer/rules/tests/CMakeLists.txt | 1 - query_optimizer/strategy/tests/CMakeLists.txt | 1 - query_optimizer/tests/CMakeLists.txt | 1 - query_optimizer/tests/OptimizerTest.cpp | 1 - relational_operators/CMakeLists.txt | 1 - storage/CMakeLists.txt | 1 - storage/SMAIndexSubBlock.cpp | 5 +- types/CMakeLists.txt | 6 +- types/NumericSuperType.hpp | 2 +- types/Type.hpp | 2 +- types/TypeUtil.hpp | 2 - types/containers/ColumnVector.cpp | 4 + types/containers/ColumnVector.hpp | 10 +- types/operations/CMakeLists.txt | 31 + types/operations/Operation.hpp | 10 +- types/operations/Operation.proto | 12 - types/operations/OperationFactory.cpp | 358 +++ types/operations/OperationFactory.hpp | 205 ++ types/operations/OperationSignature.hpp | 2 +- types/operations/OperationUtil.hpp | 334 +++ .../binary_operations/AddBinaryOperation.cpp | 418 --- .../binary_operations/AddBinaryOperation.hpp | 90 - .../ArithmeticBinaryFunctorOverloads.hpp | 176 ++ .../ArithmeticBinaryOperation.hpp | 404 --- .../ArithmeticBinaryOperations.hpp | 185 ++ .../ArithmeticBinaryOperators.hpp | 851 ------ .../AsciiStringBinaryOperations.hpp | 131 + .../binary_operations/BinaryOperation.cpp | 29 - .../binary_operations/BinaryOperation.hpp | 286 +- .../BinaryOperationFactory.cpp | 59 +- .../BinaryOperationFactory.hpp | 38 +- .../binary_operations/BinaryOperationID.cpp | 40 - .../binary_operations/BinaryOperationID.hpp | 62 - .../BinaryOperationWrapper.hpp | 627 +++++ .../operations/binary_operations/CMakeLists.txt | 177 +- .../binary_operations/DivideBinaryOperation.cpp | 391 --- .../binary_operations/DivideBinaryOperation.hpp | 93 - .../binary_operations/ModuloBinaryOperation.cpp | 259 -- .../binary_operations/ModuloBinaryOperation.hpp | 93 - .../MultiplyBinaryOperation.cpp | 410 --- .../MultiplyBinaryOperation.hpp | 98 - .../SubtractBinaryOperation.cpp | 459 ---- .../SubtractBinaryOperation.hpp | 93 - .../ArithmeticUnaryOperations.hpp | 27 +- .../AsciiStringUnaryOperations.hpp | 122 + .../operations/unary_operations/CMakeLists.txt | 73 +- .../unary_operations/CMathUnaryOperations.hpp | 5 +- .../unary_operations/CastOperation.cpp | 33 +- .../unary_operations/CastOperation.hpp | 25 +- .../unary_operations/DateExtractOperation.cpp | 9 +- .../unary_operations/DateExtractOperation.hpp | 38 +- .../unary_operations/SubstringOperation.cpp | 33 - .../unary_operations/UnaryOperation.hpp | 7 +- .../unary_operations/UnaryOperationFactory.cpp | 74 - .../unary_operations/UnaryOperationFactory.hpp | 97 - .../unary_operations/UnaryOperationWrapper.hpp | 414 +-- utility/TemplateUtil.hpp | 11 + 91 files changed, 4111 insertions(+), 6731 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/CMakeLists.txt b/expressions/CMakeLists.txt index 3becc71..eb1afb6 100644 --- a/expressions/CMakeLists.txt +++ b/expressions/CMakeLists.txt @@ -51,10 +51,9 @@ target_link_libraries(quickstep_expressions_ExpressionFactories quickstep_expressions_scalar_ScalarUnaryExpression quickstep_types_TypeFactory quickstep_types_TypedValue + quickstep_types_operations_OperationFactory quickstep_types_operations_OperationSignature - quickstep_types_operations_binaryoperations_BinaryOperationFactory quickstep_types_operations_comparisons_ComparisonFactory - quickstep_types_operations_unaryoperations_UnaryOperationFactory quickstep_utility_Macros) target_link_libraries(quickstep_expressions_Expressions_proto quickstep_types_Type_proto http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/ExpressionFactories.cpp ---------------------------------------------------------------------- diff --git a/expressions/ExpressionFactories.cpp b/expressions/ExpressionFactories.cpp index dd7532e..d145a4d 100644 --- a/expressions/ExpressionFactories.cpp +++ b/expressions/ExpressionFactories.cpp @@ -42,10 +42,9 @@ #include "expressions/scalar/ScalarUnaryExpression.hpp" #include "types/TypeFactory.hpp" #include "types/TypedValue.hpp" +#include "types/operations/OperationFactory.hpp" #include "types/operations/OperationSignature.hpp" -#include "types/operations/binary_operations/BinaryOperationFactory.hpp" #include "types/operations/comparisons/ComparisonFactory.hpp" -#include "types/operations/unary_operations/UnaryOperationFactory.hpp" #include "utility/Macros.hpp" #include "glog/logging.h" @@ -176,23 +175,35 @@ Scalar* ScalarFactory::ReconstructFromProto(const serialization::Scalar &proto, TypedValue::ReconstructFromProto( proto.GetExtension(serialization::ScalarUnaryExpression::static_arguments, i))); } - const OperationSignaturePtr op_signature = OperationSignature::ReconstructFromProto( proto.GetExtension(serialization::ScalarUnaryExpression::op_signature)); - return new ScalarUnaryExpression( op_signature, - UnaryOperationFactory::Instance().getUnaryOperation(op_signature), + OperationFactory::Instance().getUnaryOperation(op_signature), ReconstructFromProto(proto.GetExtension(serialization::ScalarUnaryExpression::operand), database), std::make_shared<std::vector<TypedValue>>(std::move(static_arguments))); } case serialization::Scalar::BINARY_EXPRESSION: { + std::vector<TypedValue> static_arguments; + const int num_static_args = + proto.ExtensionSize(serialization::ScalarBinaryExpression::static_arguments); + for (int i = 0; i < num_static_args; ++i) { + static_arguments.emplace_back( + TypedValue::ReconstructFromProto( + proto.GetExtension(serialization::ScalarBinaryExpression::static_arguments, i))); + } + const OperationSignaturePtr op_signature = + OperationSignature::ReconstructFromProto( + proto.GetExtension(serialization::ScalarBinaryExpression::op_signature)); return new ScalarBinaryExpression( - BinaryOperationFactory::ReconstructFromProto( - proto.GetExtension(serialization::ScalarBinaryExpression::operation)), - ReconstructFromProto(proto.GetExtension(serialization::ScalarBinaryExpression::left_operand), database), - ReconstructFromProto(proto.GetExtension(serialization::ScalarBinaryExpression::right_operand), database)); + op_signature, + OperationFactory::Instance().getBinaryOperation(op_signature), + ReconstructFromProto( + proto.GetExtension(serialization::ScalarBinaryExpression::left_operand), database), + ReconstructFromProto( + proto.GetExtension(serialization::ScalarBinaryExpression::right_operand), database), + std::make_shared<std::vector<TypedValue>>(std::move(static_arguments))); } case serialization::Scalar::CASE_EXPRESSION: { const Type &result_type = TypeFactory::ReconstructFromProto( @@ -262,14 +273,8 @@ bool ScalarFactory::ProtoIsValid(const serialization::Scalar &proto, break; } case serialization::Scalar::BINARY_EXPRESSION: { - if (proto.HasExtension(serialization::ScalarBinaryExpression::operation) - && proto.HasExtension(serialization::ScalarBinaryExpression::left_operand) - && proto.HasExtension(serialization::ScalarBinaryExpression::right_operand)) { - return BinaryOperationFactory::ProtoIsValid( - proto.GetExtension(serialization::ScalarBinaryExpression::operation)) - && ProtoIsValid(proto.GetExtension(serialization::ScalarBinaryExpression::left_operand), database) - && ProtoIsValid(proto.GetExtension(serialization::ScalarBinaryExpression::right_operand), database); - } + // TODO + return true; break; } case serialization::Scalar::CASE_EXPRESSION: { http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/Expressions.proto ---------------------------------------------------------------------- diff --git a/expressions/Expressions.proto b/expressions/Expressions.proto index ea6228a..9f8fb3c 100644 --- a/expressions/Expressions.proto +++ b/expressions/Expressions.proto @@ -110,9 +110,10 @@ message ScalarUnaryExpression { message ScalarBinaryExpression { extend Scalar { - optional BinaryOperation operation = 128; - optional Scalar left_operand = 129; - optional Scalar right_operand = 130; + optional OperationSignature op_signature = 129; + optional Scalar left_operand = 130; + optional Scalar right_operand = 131; + repeated TypedValue static_arguments = 132; } } http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/aggregation/AggregateFunctionAvg.cpp ---------------------------------------------------------------------- diff --git a/expressions/aggregation/AggregateFunctionAvg.cpp b/expressions/aggregation/AggregateFunctionAvg.cpp index 040d7d9..b5c18c4 100644 --- a/expressions/aggregation/AggregateFunctionAvg.cpp +++ b/expressions/aggregation/AggregateFunctionAvg.cpp @@ -27,7 +27,6 @@ #include "types/TypeID.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "glog/logging.h" @@ -42,9 +41,9 @@ bool AggregateFunctionAvg::canApplyToTypes( // Argument must be addable and divisible. return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .canApplyToTypes(*argument_types.front(), *argument_types.front()) + .canApplyTo(*argument_types.front(), *argument_types.front()) && BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .canApplyToTypes(*argument_types.front(), TypeFactory::GetType(kDouble)); + .canApplyTo(*argument_types.front(), TypeFactory::GetType(kDouble)); } const Type* AggregateFunctionAvg::resultTypeForArgumentTypes( @@ -68,7 +67,7 @@ const Type* AggregateFunctionAvg::resultTypeForArgumentTypes( } return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .resultTypeForArgumentTypes(*sum_type, TypeFactory::GetType(kDouble)); + .getResultType(*sum_type, TypeFactory::GetType(kDouble)); } AggregationHandle* AggregateFunctionAvg::createHandle( http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/aggregation/AggregateFunctionSum.cpp ---------------------------------------------------------------------- diff --git a/expressions/aggregation/AggregateFunctionSum.cpp b/expressions/aggregation/AggregateFunctionSum.cpp index b62660f..b0e3f28 100644 --- a/expressions/aggregation/AggregateFunctionSum.cpp +++ b/expressions/aggregation/AggregateFunctionSum.cpp @@ -27,7 +27,6 @@ #include "types/TypeID.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "glog/logging.h" @@ -42,7 +41,7 @@ bool AggregateFunctionSum::canApplyToTypes( // Argument must be addable. return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .canApplyToTypes(*argument_types.front(), *argument_types.front()); + .canApplyTo(*argument_types.front(), *argument_types.front()); } const Type* AggregateFunctionSum::resultTypeForArgumentTypes( http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/aggregation/AggregationHandleAvg.cpp ---------------------------------------------------------------------- diff --git a/expressions/aggregation/AggregationHandleAvg.cpp b/expressions/aggregation/AggregationHandleAvg.cpp index 46bec1e..f7f2748 100644 --- a/expressions/aggregation/AggregationHandleAvg.cpp +++ b/expressions/aggregation/AggregationHandleAvg.cpp @@ -34,7 +34,6 @@ #include "types/TypedValue.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "glog/logging.h" @@ -70,22 +69,22 @@ AggregationHandleAvg::AggregationHandleAvg(const Type &type) // Add operator for summing argument values. fast_add_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .makeUncheckedBinaryOperatorForTypes(sum_type, argument_type_)); + .makeUncheckedBinaryOperator(sum_type, argument_type_)); // Add operator for merging states. merge_add_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .makeUncheckedBinaryOperatorForTypes(sum_type, sum_type)); + .makeUncheckedBinaryOperator(sum_type, sum_type)); // Divide operator for dividing sum by count to get final average. divide_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .makeUncheckedBinaryOperatorForTypes(sum_type, - TypeFactory::GetType(kDouble))); + .makeUncheckedBinaryOperator(sum_type, + TypeFactory::GetType(kDouble))); // Result is nullable, because AVG() over 0 values (or all NULL values) is // NULL. result_type_ = &(BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .resultTypeForArgumentTypes(sum_type, TypeFactory::GetType(kDouble)) + .getResultType(sum_type, TypeFactory::GetType(kDouble)) ->getNullableVersion()); } http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/aggregation/AggregationHandleSum.cpp ---------------------------------------------------------------------- diff --git a/expressions/aggregation/AggregationHandleSum.cpp b/expressions/aggregation/AggregationHandleSum.cpp index 9f5f220..f37cf2a 100644 --- a/expressions/aggregation/AggregationHandleSum.cpp +++ b/expressions/aggregation/AggregationHandleSum.cpp @@ -34,7 +34,6 @@ #include "types/TypedValue.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "glog/logging.h" @@ -69,11 +68,11 @@ AggregationHandleSum::AggregationHandleSum(const Type &type) // Add operator for summing argument values. fast_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .makeUncheckedBinaryOperatorForTypes(sum_type, argument_type_)); + .makeUncheckedBinaryOperator(sum_type, argument_type_)); // Add operator for merging states. merge_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .makeUncheckedBinaryOperatorForTypes(sum_type, sum_type)); + .makeUncheckedBinaryOperator(sum_type, sum_type)); // Result is nullable, because SUM() over 0 values (or all NULL values) is // NULL. http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/aggregation/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/aggregation/CMakeLists.txt b/expressions/aggregation/CMakeLists.txt index 4220a8d..84b0653 100644 --- a/expressions/aggregation/CMakeLists.txt +++ b/expressions/aggregation/CMakeLists.txt @@ -86,7 +86,6 @@ target_link_libraries(quickstep_expressions_aggregation_AggregateFunctionAvg quickstep_types_TypeID quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_utility_Macros) target_link_libraries(quickstep_expressions_aggregation_AggregateFunctionCount glog @@ -137,7 +136,6 @@ target_link_libraries(quickstep_expressions_aggregation_AggregateFunctionSum quickstep_types_TypeID quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_utility_Macros) target_link_libraries(quickstep_expressions_aggregation_AggregationConcreteHandle glog @@ -172,7 +170,6 @@ target_link_libraries(quickstep_expressions_aggregation_AggregationHandleAvg quickstep_types_TypedValue quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_utility_Macros) target_link_libraries(quickstep_expressions_aggregation_AggregationHandleCount glog @@ -230,7 +227,6 @@ target_link_libraries(quickstep_expressions_aggregation_AggregationHandleSum quickstep_types_TypedValue quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_utility_Macros) # Submodule all-in-one library: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/predicate/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/predicate/CMakeLists.txt b/expressions/predicate/CMakeLists.txt index b90562c..71101bd 100644 --- a/expressions/predicate/CMakeLists.txt +++ b/expressions/predicate/CMakeLists.txt @@ -148,7 +148,6 @@ target_link_libraries(Predicate_unittest quickstep_types_TypeID quickstep_types_TypedValue quickstep_types_operations_binaryoperations_BinaryOperation - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_types_operations_comparisons_Comparison quickstep_types_operations_comparisons_ComparisonFactory quickstep_types_operations_comparisons_ComparisonID http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/scalar/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/scalar/CMakeLists.txt b/expressions/scalar/CMakeLists.txt index 79d1a96..fd412e6 100644 --- a/expressions/scalar/CMakeLists.txt +++ b/expressions/scalar/CMakeLists.txt @@ -63,6 +63,7 @@ target_link_libraries(quickstep_expressions_scalar_ScalarBinaryExpression quickstep_types_TypeErrors quickstep_types_TypedValue quickstep_types_containers_ColumnVector + quickstep_types_operations_OperationSignature quickstep_types_operations_Operation_proto quickstep_types_operations_binaryoperations_BinaryOperation quickstep_utility_Macros) @@ -145,11 +146,8 @@ target_link_libraries(ScalarCaseExpression_unittest quickstep_types_containers_ColumnVector quickstep_types_containers_ColumnVectorsValueAccessor quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_types_operations_comparisons_ComparisonFactory - quickstep_types_operations_comparisons_ComparisonID - quickstep_types_operations_unaryoperations_UnaryOperationFactory - quickstep_types_operations_unaryoperations_UnaryOperationID) + quickstep_types_operations_comparisons_ComparisonID) add_test(ScalarCaseExpression_unittest ScalarCaseExpression_unittest) add_executable(Scalar_unittest "${CMAKE_CURRENT_SOURCE_DIR}/tests/Scalar_unittest.cpp") @@ -173,10 +171,7 @@ target_link_libraries(Scalar_unittest quickstep_types_TypedValue quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_types_operations_unaryoperations_CastOperation quickstep_types_operations_unaryoperations_UnaryOperation - quickstep_types_operations_unaryoperations_UnaryOperationFactory - quickstep_types_operations_unaryoperations_UnaryOperationID quickstep_utility_Macros) add_test(Scalar_unittest Scalar_unittest) http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/scalar/ScalarBinaryExpression.cpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarBinaryExpression.cpp b/expressions/scalar/ScalarBinaryExpression.cpp index 5fe6cde..51abde5 100644 --- a/expressions/scalar/ScalarBinaryExpression.cpp +++ b/expressions/scalar/ScalarBinaryExpression.cpp @@ -38,37 +38,66 @@ namespace quickstep { -ScalarBinaryExpression::ScalarBinaryExpression(const BinaryOperation &operation, - Scalar *left_operand, - Scalar *right_operand) - : Scalar(*operation.resultTypeForArgumentTypes(left_operand->getType(), - right_operand->getType())), +ScalarBinaryExpression::ScalarBinaryExpression( + const OperationSignaturePtr &op_signature, + const BinaryOperationPtr &operation, + Scalar *left_operand, + Scalar *right_operand, + const std::shared_ptr<const std::vector<TypedValue>> &static_arguments) + : Scalar(*operation->getResultType(left_operand->getType(), + right_operand->getType(), + *static_arguments)), + op_signature_(op_signature), operation_(operation), left_operand_(left_operand), - right_operand_(right_operand) { - initHelper(false); + right_operand_(right_operand), + static_arguments_(static_arguments) { + DCHECK(operation_->canApplyTo(left_operand_->getType(), + right_operand_->getType(), + *static_arguments)); + fast_operator_.reset( + operation_->makeUncheckedBinaryOperator(left_operand_->getType(), + right_operand_->getType(), + *static_arguments)); + if (left_operand_->hasStaticValue() && right_operand_->hasStaticValue()) { + static_value_.reset(new TypedValue( + fast_operator_->applyToTypedValues(left_operand_->getStaticValue(), + right_operand_->getStaticValue()))); + } } serialization::Scalar ScalarBinaryExpression::getProto() const { serialization::Scalar proto; proto.set_data_source(serialization::Scalar::BINARY_EXPRESSION); - proto.MutableExtension(serialization::ScalarBinaryExpression::operation)->CopyFrom(operation_.getProto()); - proto.MutableExtension(serialization::ScalarBinaryExpression::left_operand)->CopyFrom(left_operand_->getProto()); - proto.MutableExtension(serialization::ScalarBinaryExpression::right_operand)->CopyFrom(right_operand_->getProto()); - + proto.MutableExtension( + serialization::ScalarBinaryExpression::op_signature)->CopyFrom( + op_signature_->getProto()); + proto.MutableExtension( + serialization::ScalarBinaryExpression::left_operand)->CopyFrom( + left_operand_->getProto()); + proto.MutableExtension( + serialization::ScalarBinaryExpression::right_operand)->CopyFrom( + right_operand_->getProto()); + for (const TypedValue &value : *static_arguments_) { + proto.AddExtension( + serialization::ScalarUnaryExpression::static_arguments)->CopyFrom( + value.getProto()); + } return proto; } Scalar* ScalarBinaryExpression::clone() const { - return new ScalarBinaryExpression(operation_, + return new ScalarBinaryExpression(op_signature_, + operation_, left_operand_->clone(), - right_operand_->clone()); + right_operand_->clone(), + static_arguments_); } TypedValue ScalarBinaryExpression::getValueForSingleTuple(const ValueAccessor &accessor, const tuple_id tuple) const { if (fast_operator_.get() == nullptr) { - return static_value_.makeReferenceToThis(); + return static_value_->makeReferenceToThis(); } else { return fast_operator_->applyToTypedValues(left_operand_->getValueForSingleTuple(accessor, tuple), right_operand_->getValueForSingleTuple(accessor, tuple)); @@ -83,7 +112,7 @@ TypedValue ScalarBinaryExpression::getValueForJoinedTuples( const relation_id right_relation_id, const tuple_id right_tuple_id) const { if (fast_operator_.get() == nullptr) { - return static_value_.makeReferenceToThis(); + return static_value_->makeReferenceToThis(); } else { return fast_operator_->applyToTypedValues( left_operand_->getValueForJoinedTuples(left_accessor, @@ -106,7 +135,7 @@ ColumnVector* ScalarBinaryExpression::getAllValues( const SubBlocksReference *sub_blocks_ref) const { if (fast_operator_.get() == nullptr) { return ColumnVector::MakeVectorOfValue(getType(), - static_value_, + *static_value_, accessor->getNumTuplesVirtual()); } else { // NOTE(chasseur): We don't check if BOTH operands have a static value, @@ -191,7 +220,7 @@ ColumnVector* ScalarBinaryExpression::getAllValuesForJoin( const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const { if (fast_operator_.get() == nullptr) { return ColumnVector::MakeVectorOfValue(getType(), - static_value_, + *static_value_, joined_tuple_ids.size()); } else { if (left_operand_->hasStaticValue()) { @@ -349,29 +378,4 @@ ColumnVector* ScalarBinaryExpression::getAllValuesForJoin( } } -void ScalarBinaryExpression::initHelper(bool own_children) { - if (operation_.canApplyToTypes(left_operand_->getType(), right_operand_->getType())) { - if (left_operand_->hasStaticValue() && right_operand_->hasStaticValue()) { - static_value_ = operation_.applyToChecked(left_operand_->getStaticValue(), - left_operand_->getType(), - right_operand_->getStaticValue(), - right_operand_->getType()); - } else { - fast_operator_.reset(operation_.makeUncheckedBinaryOperatorForTypes(left_operand_->getType(), - right_operand_->getType())); - } - } else { - const Type &left_operand_type = left_operand_->getType(); - const Type &right_operand_type = right_operand_->getType(); - if (!own_children) { - left_operand_.release(); - right_operand_.release(); - } - throw OperationInapplicableToType(operation_.getName(), - 2, - left_operand_type.getName().c_str(), - right_operand_type.getName().c_str()); - } -} - } // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/scalar/ScalarBinaryExpression.hpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarBinaryExpression.hpp b/expressions/scalar/ScalarBinaryExpression.hpp index c84792a..0bf6abe 100644 --- a/expressions/scalar/ScalarBinaryExpression.hpp +++ b/expressions/scalar/ScalarBinaryExpression.hpp @@ -29,6 +29,7 @@ #include "expressions/scalar/Scalar.hpp" #include "storage/StorageBlockInfo.hpp" #include "types/TypedValue.hpp" +#include "types/operations/OperationSignature.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "utility/Macros.hpp" @@ -50,18 +51,11 @@ struct SubBlocksReference; **/ class ScalarBinaryExpression : public Scalar { public: - /** - * @brief Constructor. - * - * @param operation The binary operation to be performed. - * @param left_operand The left argument of the operation, which this - * ScalarBinaryExpression takes ownership of. - * @param right_operand The right argument of the operation, which this - * ScalarBinaryExpression takes ownership of. - **/ - ScalarBinaryExpression(const BinaryOperation &operation, + ScalarBinaryExpression(const OperationSignaturePtr &op_signature, + const BinaryOperationPtr &operation, Scalar *left_operand, - Scalar *right_operand); + Scalar *right_operand, + const std::shared_ptr<const std::vector<TypedValue>> &static_arguments); /** * @brief Destructor @@ -89,12 +83,12 @@ class ScalarBinaryExpression : public Scalar { const tuple_id right_tuple_id) const override; bool hasStaticValue() const override { - return fast_operator_.get() == nullptr; + return static_value_ != nullptr; } const TypedValue& getStaticValue() const override { DCHECK(hasStaticValue()); - return static_value_; + return *static_value_; } ColumnVector* getAllValues(ValueAccessor *accessor, @@ -108,13 +102,14 @@ class ScalarBinaryExpression : public Scalar { const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const override; private: - void initHelper(bool own_children); + const OperationSignaturePtr op_signature_; + const BinaryOperationPtr operation_; - const BinaryOperation &operation_; + const std::unique_ptr<Scalar> left_operand_; + const std::unique_ptr<Scalar> right_operand_; + const std::shared_ptr<const std::vector<TypedValue>> static_arguments_; - std::unique_ptr<Scalar> left_operand_; - std::unique_ptr<Scalar> right_operand_; - TypedValue static_value_; + std::unique_ptr<TypedValue> static_value_; std::unique_ptr<UncheckedBinaryOperator> fast_operator_; friend class PredicateTest; http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/scalar/ScalarUnaryExpression.cpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarUnaryExpression.cpp b/expressions/scalar/ScalarUnaryExpression.cpp index 61405af..b3d52b6 100644 --- a/expressions/scalar/ScalarUnaryExpression.cpp +++ b/expressions/scalar/ScalarUnaryExpression.cpp @@ -34,9 +34,7 @@ #include "types/operations/Operation.pb.h" #include "types/operations/unary_operations/UnaryOperation.hpp" -#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN #include "glog/logging.h" -#endif // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN namespace quickstep { @@ -52,17 +50,14 @@ ScalarUnaryExpression::ScalarUnaryExpression( operation_(operation), operand_(operand), static_arguments_(static_arguments) { - if (operation_->canApplyTo(operand_->getType(), *static_arguments_)) { - fast_operator_.reset( - operation_->makeUncheckedUnaryOperator(operand_->getType(), - *static_arguments_)); - if (operand_->hasStaticValue()) { - static_value_.reset(new TypedValue( - fast_operator_->applyToTypedValue(operand_->getStaticValue()))); - } - } else { - const Type &operand_type = operand_->getType(); - throw OperationInapplicableToType(operation_->getName(), 1, operand_type.getName().c_str()); + DCHECK(operation_->canApplyTo(operand_->getType(), *static_arguments_)); + + fast_operator_.reset( + operation_->makeUncheckedUnaryOperator(operand_->getType(), + *static_arguments_)); + if (operand_->hasStaticValue()) { + static_value_.reset(new TypedValue( + fast_operator_->applyToTypedValue(operand_->getStaticValue()))); } } @@ -72,13 +67,14 @@ serialization::Scalar ScalarUnaryExpression::getProto() const { proto.MutableExtension( serialization::ScalarUnaryExpression::op_signature)->CopyFrom( op_signature_->getProto()); - proto.MutableExtension(serialization::ScalarUnaryExpression::operand)->CopyFrom(operand_->getProto()); + proto.MutableExtension( + serialization::ScalarUnaryExpression::operand)->CopyFrom( + operand_->getProto()); for (const TypedValue &value : *static_arguments_) { proto.AddExtension( serialization::ScalarUnaryExpression::static_arguments)->CopyFrom( value.getProto()); } - return proto; } http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/scalar/ScalarUnaryExpression.hpp ---------------------------------------------------------------------- diff --git a/expressions/scalar/ScalarUnaryExpression.hpp b/expressions/scalar/ScalarUnaryExpression.hpp index c84e2bb..2f3a2ee 100644 --- a/expressions/scalar/ScalarUnaryExpression.hpp +++ b/expressions/scalar/ScalarUnaryExpression.hpp @@ -101,8 +101,6 @@ class ScalarUnaryExpression : public Scalar { const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const override; private: - void initHelper(bool own_children); - const OperationSignaturePtr op_signature_; const UnaryOperationPtr operation_; http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/window_aggregation/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/CMakeLists.txt b/expressions/window_aggregation/CMakeLists.txt index b33a401..538a7f5 100644 --- a/expressions/window_aggregation/CMakeLists.txt +++ b/expressions/window_aggregation/CMakeLists.txt @@ -73,7 +73,6 @@ target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFun quickstep_types_TypeID quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_utility_Macros) target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionCount glog @@ -124,7 +123,6 @@ target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFun quickstep_types_TypeID quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_utility_Macros) target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregationHandle glog @@ -140,7 +138,6 @@ target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregationH quickstep_types_containers_ColumnVectorsValueAccessor quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_types_operations_comparisons_Comparison quickstep_types_operations_comparisons_ComparisonFactory quickstep_types_operations_comparisons_ComparisonID @@ -157,7 +154,6 @@ target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregationH quickstep_types_containers_ColumnVectorsValueAccessor quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_types_operations_comparisons_Comparison quickstep_utility_Macros) http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp b/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp index 20c296b..1114c84 100644 --- a/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp +++ b/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp @@ -27,7 +27,6 @@ #include "types/TypeID.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "glog/logging.h" @@ -42,9 +41,9 @@ bool WindowAggregateFunctionAvg::canApplyToTypes( // Argument must be addable and divisible. return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .canApplyToTypes(*argument_types.front(), *argument_types.front()) && + .canApplyTo(*argument_types.front(), *argument_types.front()) && BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .canApplyToTypes(*argument_types.front(), TypeFactory::GetType(kDouble)); + .canApplyTo(*argument_types.front(), TypeFactory::GetType(kDouble)); } const Type* WindowAggregateFunctionAvg::resultTypeForArgumentTypes( @@ -68,7 +67,7 @@ const Type* WindowAggregateFunctionAvg::resultTypeForArgumentTypes( } return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .resultTypeForArgumentTypes(*sum_type, TypeFactory::GetType(kDouble)); + .getResultType(*sum_type, TypeFactory::GetType(kDouble)); } WindowAggregationHandle* WindowAggregateFunctionAvg::createHandle( http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/window_aggregation/WindowAggregateFunctionSum.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionSum.cpp b/expressions/window_aggregation/WindowAggregateFunctionSum.cpp index 14c51d8..406edb5 100644 --- a/expressions/window_aggregation/WindowAggregateFunctionSum.cpp +++ b/expressions/window_aggregation/WindowAggregateFunctionSum.cpp @@ -27,7 +27,6 @@ #include "types/TypeID.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "glog/logging.h" @@ -42,7 +41,7 @@ bool WindowAggregateFunctionSum::canApplyToTypes( // Argument must be addable. return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .canApplyToTypes(*argument_types.front(), *argument_types.front()); + .canApplyTo(*argument_types.front(), *argument_types.front()); } const Type* WindowAggregateFunctionSum::resultTypeForArgumentTypes( http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/window_aggregation/WindowAggregationHandle.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregationHandle.cpp b/expressions/window_aggregation/WindowAggregationHandle.cpp index f26656d..df63095 100644 --- a/expressions/window_aggregation/WindowAggregationHandle.cpp +++ b/expressions/window_aggregation/WindowAggregationHandle.cpp @@ -32,7 +32,6 @@ #include "types/containers/ColumnVectorsValueAccessor.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "types/operations/comparisons/Comparison.hpp" #include "glog/logging.h" @@ -84,7 +83,7 @@ WindowAggregationHandle::WindowAggregationHandle( range_add_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .makeUncheckedBinaryOperatorForTypes(*first_order_key_type, long_type)); + .makeUncheckedBinaryOperator(*first_order_key_type, long_type)); range_comparator_.reset( ComparisonFactory::GetComparison(ComparisonID::kLessOrEqual) .makeUncheckedComparatorForTypes(*range_compare_type_, *range_compare_type_)); http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/window_aggregation/WindowAggregationHandle.hpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregationHandle.hpp b/expressions/window_aggregation/WindowAggregationHandle.hpp index 3569123..c33f947 100644 --- a/expressions/window_aggregation/WindowAggregationHandle.hpp +++ b/expressions/window_aggregation/WindowAggregationHandle.hpp @@ -38,7 +38,6 @@ #include "types/operations/comparisons/ComparisonID.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "utility/Macros.hpp" namespace quickstep { http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/expressions/window_aggregation/WindowAggregationHandleAvg.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregationHandleAvg.cpp b/expressions/window_aggregation/WindowAggregationHandleAvg.cpp index b1c6e3b..921579b 100644 --- a/expressions/window_aggregation/WindowAggregationHandleAvg.cpp +++ b/expressions/window_aggregation/WindowAggregationHandleAvg.cpp @@ -33,7 +33,6 @@ #include "types/containers/ColumnVectorsValueAccessor.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" #include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "types/operations/comparisons/Comparison.hpp" #include "glog/logging.h" @@ -75,24 +74,24 @@ WindowAggregationHandleAvg::WindowAggregationHandleAvg( // NULL. result_type_ = &(BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .resultTypeForArgumentTypes(*sum_type_, TypeFactory::GetType(kDouble)) + .getResultType(*sum_type_, TypeFactory::GetType(kDouble)) ->getNullableVersion()); // Make operators to do arithmetic: // Add operator for summing argument values. fast_add_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .makeUncheckedBinaryOperatorForTypes(*sum_type_, *argument_type)); + .makeUncheckedBinaryOperator(*sum_type_, *argument_type)); // Subtract operator for dropping argument values off the window. fast_subtract_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kSubtract) - .makeUncheckedBinaryOperatorForTypes(*sum_type_, *argument_type)); + .makeUncheckedBinaryOperator(*sum_type_, *argument_type)); // Divide operator for dividing sum by count to get final average. divide_operator_.reset( BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .makeUncheckedBinaryOperatorForTypes(*sum_type_, TypeFactory::GetType(kDouble))); + .makeUncheckedBinaryOperator(*sum_type_, TypeFactory::GetType(kDouble))); } ColumnVector* WindowAggregationHandleAvg::calculate( http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/parser/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/parser/CMakeLists.txt b/parser/CMakeLists.txt index 7a8e04e..6eb3c47 100644 --- a/parser/CMakeLists.txt +++ b/parser/CMakeLists.txt @@ -359,9 +359,6 @@ target_link_libraries(quickstep_parser_SqlParser quickstep_types_Type quickstep_types_TypeFactory quickstep_types_TypeID - quickstep_types_operations_binaryoperations_BinaryOperation - quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID quickstep_types_operations_comparisons_Comparison quickstep_types_operations_comparisons_ComparisonFactory quickstep_types_operations_comparisons_ComparisonID http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/parser/ParseBasicExpressions.cpp ---------------------------------------------------------------------- diff --git a/parser/ParseBasicExpressions.cpp b/parser/ParseBasicExpressions.cpp index 8212286..580cd09 100644 --- a/parser/ParseBasicExpressions.cpp +++ b/parser/ParseBasicExpressions.cpp @@ -68,33 +68,6 @@ void ParseAttribute::getFieldStringItems( } } -std::string ParseBinaryExpression::getName() const { - return op_.getName(); -} - -string ParseBinaryExpression::generateName() const { - string name("("); - name.append(left_operand_->generateName()); - name.append(op_.getShortName()); - name.append(right_operand_->generateName()); - name.push_back(')'); - return name; -} - -void ParseBinaryExpression::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 ParseTreeNode*> *non_container_child_fields, - std::vector<std::string> *container_child_field_names, - std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const { - non_container_child_field_names->push_back("left_operand"); - non_container_child_fields->push_back(left_operand_.get()); - - non_container_child_field_names->push_back("right_operand"); - non_container_child_fields->push_back(right_operand_.get()); -} - std::string ParseFunctionCall::generateName() const { string name(name_->value()); name.push_back('('); http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/parser/ParseBasicExpressions.hpp ---------------------------------------------------------------------- diff --git a/parser/ParseBasicExpressions.hpp b/parser/ParseBasicExpressions.hpp index edf5aab..4572214 100644 --- a/parser/ParseBasicExpressions.hpp +++ b/parser/ParseBasicExpressions.hpp @@ -36,9 +36,6 @@ namespace quickstep { -class BinaryOperation; -class UnaryOperation; - /** \addtogroup Parser * @{ */ @@ -173,88 +170,6 @@ class ParseAttribute : public ParseExpression { /** - * @brief The parsed representation of a binary operation applied to two - * expressions. - **/ -class ParseBinaryExpression : public ParseExpression { - public: - /** - * @brief Constructor. - * - * @param line_number Line number of the binary operator token in the SQL statement. - * @param column_number Column number of the binary operator token in the SQL statement. - * @param op The BinaryOperation from the quickstep type system to apply. - * @param left_operand The parsed scalar representation of the binary - * operation's left argument, which becomes owned by this - * ParseScalarBinaryExpression. - * @param right_operand The parsed scalar representation of the binary - * operation's right argument, which becomes owned by this - * ParseScalarBinaryExpression. - **/ - ParseBinaryExpression(const int line_number, - const int column_number, - const BinaryOperation &op, - ParseExpression *left_operand, - ParseExpression *right_operand) - : ParseExpression(line_number, column_number), - op_(op), - left_operand_(left_operand), - right_operand_(right_operand) { - } - - /** - * @brief Destructor. - */ - ~ParseBinaryExpression() override { - } - - ExpressionType getExpressionType() const override { - return kBinaryExpression; - } - - std::string getName() const override; - - /** - * @return The binary operation. - */ - const BinaryOperation& op() const { - return op_; - } - - /** - * @return The left operand expression. - */ - const ParseExpression* left_operand() const { - return left_operand_.get(); - } - - /** - * @return The right operand expression. - */ - const ParseExpression* right_operand() const { - return right_operand_.get(); - } - - std::string generateName() 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 ParseTreeNode*> *non_container_child_fields, - std::vector<std::string> *container_child_field_names, - std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override; - - private: - const BinaryOperation &op_; - std::unique_ptr<ParseExpression> left_operand_; - std::unique_ptr<ParseExpression> right_operand_; - - DISALLOW_COPY_AND_ASSIGN(ParseBinaryExpression); -}; - -/** * @brief The parsed representation of '*' as a function argument. */ class ParseStar : public ParseTreeNode { @@ -279,6 +194,7 @@ class ParseStar : public ParseTreeNode { DISALLOW_COPY_AND_ASSIGN(ParseStar); }; + /** * @brief Parsed function call in the form of a name with a list of arguments in parentheses. */ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/4005df6e/parser/SqlParser.ypp ---------------------------------------------------------------------- diff --git a/parser/SqlParser.ypp b/parser/SqlParser.ypp index fd13aa7..68f5f72 100644 --- a/parser/SqlParser.ypp +++ b/parser/SqlParser.ypp @@ -101,9 +101,6 @@ typedef struct YYLTYPE { #include "types/Type.hpp" #include "types/TypeFactory.hpp" #include "types/TypeID.hpp" -#include "types/operations/binary_operations/BinaryOperation.hpp" -#include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" #include "types/operations/comparisons/Comparison.hpp" #include "types/operations/comparisons/ComparisonFactory.hpp" #include "types/operations/comparisons/ComparisonID.hpp" @@ -185,7 +182,7 @@ typedef void* yyscan_t; const quickstep::Comparison *comparison_; quickstep::ParseString *unary_operation_; - const quickstep::BinaryOperation *binary_operation_; + quickstep::ParseString *binary_operation_; quickstep::ParseFunctionCall *function_call_; quickstep::PtrList<quickstep::ParseExpression> *expression_list_; @@ -612,7 +609,6 @@ void NotSupported(const YYLTYPE *location, yyscan_t yyscanner, const std::string %destructor { } <boolean_value_> %destructor { } <comparison_> -%destructor { } <binary_operation_> %destructor { } <join_type_> %destructor { @@ -1614,7 +1610,10 @@ predicate_expression_base: /* Scalars */ add_expression: add_expression add_operation multiply_expression { - $$ = new quickstep::ParseBinaryExpression(@2.first_line, @2.first_column, *$2, $1, $3); + auto *arguments = new quickstep::PtrList<quickstep::ParseExpression>(); + arguments->push_back($1); + arguments->push_back($3); + $$ = new quickstep::ParseFunctionCall(@1.first_line, @1.first_column, false, $2, arguments); } | multiply_expression { $$ = $1; @@ -1622,7 +1621,10 @@ add_expression: multiply_expression: multiply_expression multiply_operation unary_expression { - $$ = new quickstep::ParseBinaryExpression(@2.first_line, @2.first_column, *$2, $1, $3); + auto *arguments = new quickstep::PtrList<quickstep::ParseExpression>(); + arguments->push_back($1); + arguments->push_back($3); + $$ = new quickstep::ParseFunctionCall(@1.first_line, @1.first_column, false, $2, arguments); } | unary_expression { $$ = $1; @@ -1632,8 +1634,7 @@ unary_expression: unary_operation expression_base { auto *arguments = new quickstep::PtrList<quickstep::ParseExpression>(); arguments->push_back($2); - $$ = new quickstep::ParseFunctionCall( - @1.first_line, @1.first_column, false, $1, arguments); + $$ = new quickstep::ParseFunctionCall(@1.first_line, @1.first_column, false, $1, arguments); } | expression_base { $$ = $1; @@ -1693,7 +1694,7 @@ function_call: }; cast_function: - TOKEN_CAST '(' add_expression TOKEN_AS data_type ')' { + TOKEN_CAST '(' add_expression TOKEN_AS data_type ')' { auto *arguments = new quickstep::PtrList<quickstep::ParseExpression>(); arguments->push_back($3); arguments->push_back(new quickstep::ParseScalarLiteral( @@ -1706,6 +1707,15 @@ cast_function: auto *name = new quickstep::ParseString(@1.first_line, @1.first_column, "cast"); $$ = new quickstep::ParseFunctionCall( @1.first_line, @1.first_column, false, name, arguments); + } + | TOKEN_CAST '(' add_expression TOKEN_AS any_name ')' { + auto *arguments = new quickstep::PtrList<quickstep::ParseExpression>(); + arguments->push_back($3); + arguments->push_back(new quickstep::ParseScalarLiteral( + new quickstep::StringParseLiteralValue($5, nullptr))); + auto *name = new quickstep::ParseString(@1.first_line, @1.first_column, "cast"); + $$ = new quickstep::ParseFunctionCall( + @1.first_line, @1.first_column, false, name, arguments); }; extract_function: @@ -1960,21 +1970,21 @@ unary_operation: add_operation: '+' { - $$ = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kAdd); + $$ = new quickstep::ParseString(@1.first_line, @1.first_column, std::string("+")); } | '-' { - $$ = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kSubtract); + $$ = new quickstep::ParseString(@1.first_line, @1.first_column, std::string("-")); }; multiply_operation: '%' { - $$ = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kModulo); + $$ = new quickstep::ParseString(@1.first_line, @1.first_column, std::string("%")); } | '*' { - $$ = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kMultiply); + $$ = new quickstep::ParseString(@1.first_line, @1.first_column, std::string("*")); } | '/' { - $$ = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kDivide); + $$ = new quickstep::ParseString(@1.first_line, @1.first_column, std::string("/")); }; /* General Utility Stuff */
