More updates, refactor names
Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/1cb97e35 Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/1cb97e35 Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/1cb97e35 Branch: refs/heads/refactor-type Commit: 1cb97e3547846240f3ceb0a7f086dbe912174b72 Parents: 9cb664c Author: Jianqiao Zhu <[email protected]> Authored: Thu Oct 5 17:02:33 2017 -0500 Committer: Jianqiao Zhu <[email protected]> Committed: Wed Oct 11 13:37:54 2017 -0500 ---------------------------------------------------------------------- query_optimizer/ExecutionGenerator.cpp | 3 +- query_optimizer/expressions/CMakeLists.txt | 15 + query_optimizer/expressions/Cast.cpp | 107 ++++++ query_optimizer/expressions/Cast.hpp | 125 +++++++ query_optimizer/resolver/CMakeLists.txt | 3 + query_optimizer/resolver/Resolver.cpp | 10 + types/AsciiStringSuperType.hpp | 7 +- types/CharType.cpp | 64 +++- types/CharType.hpp | 13 + types/GenericValue.hpp | 4 + types/MetaType-decl.hpp | 3 +- types/NumericTypeSafeCoercibility.hpp | 10 +- types/TypeRegistrar.hpp | 6 +- types/TypeSynthesizer.hpp | 136 +++++++- types/operations/CMakeLists.txt | 23 +- types/operations/OperationFactory.cpp | 12 +- types/operations/OperationUtil.hpp | 334 ------------------ .../binary_operations/AddBinaryOperation.hpp | 94 ------ .../ArithmeticBinaryFunctors.hpp | 182 ++++++++++ .../ArithmeticBinaryOperations.hpp | 182 ---------- .../AsciiStringBinaryFunctors.hpp | 130 +++++++ .../AsciiStringBinaryOperations.hpp | 130 ------- .../BinaryOperationWrapper.hpp | 8 +- .../operations/binary_operations/CMakeLists.txt | 30 +- .../binary_operations/CMathBinaryFunctors.hpp | 78 +++++ .../binary_operations/CMathBinaryOperations.hpp | 78 ----- .../MultiplyBinaryOperation.hpp | 102 ------ .../ArithmeticUnaryFunctors.hpp | 80 +++++ .../ArithmeticUnaryOperations.hpp | 81 ----- .../AsciiStringUnaryFunctors.hpp | 122 +++++++ .../AsciiStringUnaryOperations.hpp | 122 ------- .../operations/unary_operations/CMakeLists.txt | 40 ++- .../unary_operations/CMathUnaryFunctors.hpp | 116 +++++++ .../unary_operations/CMathUnaryOperations.hpp | 116 ------- .../unary_operations/CastFunctorOverloads.hpp | 183 ++++++++++ .../unary_operations/CastOperation.cpp | 314 +++++------------ .../unary_operations/CastOperation.hpp | 60 +--- .../unary_operations/UnaryOperationWrapper.hpp | 6 +- types/operations/utility/CMakeLists.txt | 37 ++ types/operations/utility/CastUtil.cpp | 0 types/operations/utility/CastUtil.hpp | 0 .../utility/OperationSynthesizeUtil.hpp | 335 +++++++++++++++++++ utility/meta/Common.hpp | 15 +- utility/meta/Dispatchers.hpp | 2 +- utility/meta/MetaprogrammingModule.hpp | 24 ++ utility/meta/TransitiveClosure.hpp | 2 +- utility/meta/TypeList.hpp | 63 ++-- utility/meta/TypeListMetaFunctions.hpp | 80 ++++- 48 files changed, 2045 insertions(+), 1642 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/query_optimizer/ExecutionGenerator.cpp ---------------------------------------------------------------------- diff --git a/query_optimizer/ExecutionGenerator.cpp b/query_optimizer/ExecutionGenerator.cpp index 372d576..d4544a0 100644 --- a/query_optimizer/ExecutionGenerator.cpp +++ b/query_optimizer/ExecutionGenerator.cpp @@ -1466,7 +1466,8 @@ void ExecutionGenerator::convertInsertTuple( S::Tuple *tuple_proto = query_context_proto_->add_tuples(); for (const E::ScalarLiteralPtr &literal : physical_plan->column_values()) { - tuple_proto->add_attribute_values()->CopyFrom(literal->value().getProto()); + tuple_proto->add_attribute_values()->CopyFrom( + literal->value().toTypedValue().getProto()); } // FIXME(qzeng): A better way is using a traits struct to look up whether a storage http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/query_optimizer/expressions/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/query_optimizer/expressions/CMakeLists.txt b/query_optimizer/expressions/CMakeLists.txt index cf2727f..b51a0a8 100644 --- a/query_optimizer/expressions/CMakeLists.txt +++ b/query_optimizer/expressions/CMakeLists.txt @@ -20,6 +20,7 @@ add_library(quickstep_queryoptimizer_expressions_AggregateFunction AggregateFunc add_library(quickstep_queryoptimizer_expressions_Alias Alias.cpp Alias.hpp) add_library(quickstep_queryoptimizer_expressions_AttributeReference AttributeReference.cpp AttributeReference.hpp) add_library(quickstep_queryoptimizer_expressions_BinaryExpression BinaryExpression.cpp BinaryExpression.hpp) +add_library(quickstep_queryoptimizer_expressions_Cast Cast.cpp Cast.hpp) add_library(quickstep_queryoptimizer_expressions_CommonSubexpression CommonSubexpression.cpp CommonSubexpression.hpp) @@ -102,6 +103,20 @@ target_link_libraries(quickstep_queryoptimizer_expressions_BinaryExpression quickstep_types_operations_binaryoperations_BinaryOperation quickstep_utility_HashPair quickstep_utility_Macros) +target_link_libraries(quickstep_queryoptimizer_expressions_Cast + quickstep_expressions_scalar_Scalar + quickstep_expressions_scalar_ScalarUnaryExpression + quickstep_queryoptimizer_OptimizerTree + quickstep_queryoptimizer_expressions_AttributeReference + quickstep_queryoptimizer_expressions_ExprId + quickstep_queryoptimizer_expressions_Expression + quickstep_queryoptimizer_expressions_ExpressionType + quickstep_queryoptimizer_expressions_PatternMatcher + quickstep_queryoptimizer_expressions_Scalar + quickstep_types_Type + quickstep_types_operations_unaryoperations_CastOperation + quickstep_utility_HashPair + quickstep_utility_Macros) target_link_libraries(quickstep_queryoptimizer_expressions_CommonSubexpression glog quickstep_expressions_scalar_ScalarSharedExpression http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/query_optimizer/expressions/Cast.cpp ---------------------------------------------------------------------- diff --git a/query_optimizer/expressions/Cast.cpp b/query_optimizer/expressions/Cast.cpp new file mode 100644 index 0000000..6b2015f --- /dev/null +++ b/query_optimizer/expressions/Cast.cpp @@ -0,0 +1,107 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + **/ + +#include "query_optimizer/expressions/Cast.hpp" + +#include <cstddef> +#include <memory> +#include <string> +#include <unordered_map> +#include <vector> + +#include "expressions/scalar/Scalar.hpp" +#include "expressions/scalar/ScalarUnaryExpression.hpp" +#include "query_optimizer/OptimizerTree.hpp" +#include "query_optimizer/expressions/AttributeReference.hpp" +#include "query_optimizer/expressions/ExprId.hpp" +#include "query_optimizer/expressions/Expression.hpp" +#include "query_optimizer/expressions/PatternMatcher.hpp" +#include "query_optimizer/expressions/Scalar.hpp" +#include "types/MetaType.hpp" +#include "types/Type.hpp" +#include "types/operations/OperationSignature.hpp" +#include "types/operations/OperationFactory.hpp" +#include "types/operations/unary_operations/UnaryOperation.hpp" +#include "utility/HashPair.hpp" + +#include "glog/logging.h" + +namespace quickstep { +namespace optimizer { +namespace expressions { + +ExpressionPtr Cast::copyWithNewChildren( + const std::vector<ExpressionPtr> &new_children) const { + DCHECK_EQ(getNumChildren(), new_children.size()); + ScalarPtr scalar; + CHECK(SomeScalar::MatchesWithConditionalCast(new_children[0], &scalar)) + << new_children[0]->toString(); + return Create(scalar, target_type_); +} + +::quickstep::Scalar *Cast::concretize( + const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const { + const OperationSignaturePtr op_signature = + OperationSignature::Create( + "cast", {operand_->getValueType().getTypeID(), kMetaType}, 1); + const UnaryOperationPtr cast_operation = + OperationFactory::Instance().getUnaryOperation(op_signature); + + std::vector<TypedValue> meta_type_value = + { GenericValue::CreateWithLiteral( + MetaType::InstanceNonNullable(), &target_type_).toTypedValue() }; + DCHECK(cast_operation->canApplyTo(operand_->getValueType(), meta_type_value)); + + return new ::quickstep::ScalarUnaryExpression( + op_signature, cast_operation, operand_->concretize(substitution_map), + std::make_shared<const std::vector<TypedValue>>(std::move(meta_type_value))); +} + +std::size_t Cast::computeHash() const { + return CombineHashes( + CombineHashes(static_cast<std::size_t>(ExpressionType::kCast), + operand_->hash()), + static_cast<std::size_t>(target_type_.getTypeID())); +} + +bool Cast::equals(const ScalarPtr &other) const { + CastPtr expr; + if (SomeCast::MatchesWithConditionalCast(other, &expr)) { + return operand_->equals(expr->operand_) && target_type_.equals(expr->target_type_); + } + return false; +} + +void Cast::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<OptimizerTreeBaseNodePtr> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const { + inline_field_names->push_back("target_type"); + inline_field_values->push_back(target_type_.getName()); + + non_container_child_field_names->push_back("operand"); + non_container_child_fields->push_back(operand_); +} + +} // namespace expressions +} // namespace optimizer +} // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/query_optimizer/expressions/Cast.hpp ---------------------------------------------------------------------- diff --git a/query_optimizer/expressions/Cast.hpp b/query_optimizer/expressions/Cast.hpp new file mode 100644 index 0000000..11be775 --- /dev/null +++ b/query_optimizer/expressions/Cast.hpp @@ -0,0 +1,125 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + **/ + +#ifndef QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_CAST_HPP_ +#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_CAST_HPP_ + +#include <memory> +#include <string> +#include <unordered_map> +#include <vector> + +#include "query_optimizer/OptimizerTree.hpp" +#include "query_optimizer/expressions/AttributeReference.hpp" +#include "query_optimizer/expressions/ExprId.hpp" +#include "query_optimizer/expressions/Expression.hpp" +#include "query_optimizer/expressions/ExpressionType.hpp" +#include "query_optimizer/expressions/Scalar.hpp" +#include "utility/Macros.hpp" + +#include "glog/logging.h" + +namespace quickstep { + +class CatalogAttribute; +class Type; + +namespace optimizer { +namespace expressions { + +/** \addtogroup OptimizerExpressions + * @{ + */ + +class Cast; +typedef std::shared_ptr<const Cast> CastPtr; + +/** + * @brief Converts a value of a type to another type. + */ +class Cast : public Scalar { + public: + ExpressionType getExpressionType() const override { return ExpressionType::kCast; } + + std::string getName() const override { return "Cast"; } + + const Type& getValueType() const override { return target_type_; } + + bool isConstant() const override { return operand_->isConstant(); } + + /** + * @return The expression to be coerced. + */ + const ScalarPtr& operand() const { return operand_; } + + std::vector<AttributeReferencePtr> getReferencedAttributes() const override { + return operand_->getReferencedAttributes(); + } + + ExpressionPtr copyWithNewChildren( + const std::vector<ExpressionPtr> &new_children) const override; + + ::quickstep::Scalar* concretize( + const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override; + + bool equals(const ScalarPtr &other) const override; + + /** + * @brief Creates a Cast expression that converts \p operand to \p target_type. + * + * @param operand The input expression to be coerced. + * @param target_type The target type that the expression is converted to. + * @return A Cast expression. + */ + static CastPtr Create(const ScalarPtr &operand, const Type &target_type) { + return CastPtr(new Cast(operand, target_type)); + } + + protected: + std::size_t computeHash() const override; + + 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<OptimizerTreeBaseNodePtr> *non_container_child_fields, + std::vector<std::string> *container_child_field_names, + std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const override; + + private: + Cast(const ScalarPtr &operand, const Type &target_type) + : operand_(operand), + target_type_(target_type) { + addChild(operand); + DCHECK(target_type.isCoercibleFrom(operand->getValueType())); + } + + ScalarPtr operand_; + const Type &target_type_; + + DISALLOW_COPY_AND_ASSIGN(Cast); +}; + +/** @} */ + +} // namespace expressions +} // namespace optimizer +} // namespace quickstep + +#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_CAST_HPP_ */ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/query_optimizer/resolver/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/query_optimizer/resolver/CMakeLists.txt b/query_optimizer/resolver/CMakeLists.txt index 8a1116a..4dd13f2 100644 --- a/query_optimizer/resolver/CMakeLists.txt +++ b/query_optimizer/resolver/CMakeLists.txt @@ -47,6 +47,7 @@ target_link_libraries(quickstep_queryoptimizer_resolver_Resolver quickstep_parser_ParseBasicExpressions quickstep_parser_ParseBlockProperties quickstep_parser_ParseCaseExpressions + quickstep_parser_ParseDataType quickstep_parser_ParseExpression quickstep_parser_ParseGeneratorTableReference quickstep_parser_ParseGroupBy @@ -74,6 +75,7 @@ target_link_libraries(quickstep_queryoptimizer_resolver_Resolver quickstep_queryoptimizer_expressions_Alias quickstep_queryoptimizer_expressions_AttributeReference quickstep_queryoptimizer_expressions_BinaryExpression + quickstep_queryoptimizer_expressions_Cast quickstep_queryoptimizer_expressions_ComparisonExpression quickstep_queryoptimizer_expressions_Exists quickstep_queryoptimizer_expressions_ExprId @@ -123,6 +125,7 @@ target_link_libraries(quickstep_queryoptimizer_resolver_Resolver quickstep_types_ArrayType quickstep_types_GenericValue quickstep_types_IntType + quickstep_types_LongType quickstep_types_MetaType quickstep_types_NullType quickstep_types_Type http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/query_optimizer/resolver/Resolver.cpp ---------------------------------------------------------------------- diff --git a/query_optimizer/resolver/Resolver.cpp b/query_optimizer/resolver/Resolver.cpp index 8c77403..4ffb3eb 100644 --- a/query_optimizer/resolver/Resolver.cpp +++ b/query_optimizer/resolver/Resolver.cpp @@ -71,6 +71,7 @@ #include "query_optimizer/expressions/Alias.hpp" #include "query_optimizer/expressions/AttributeReference.hpp" #include "query_optimizer/expressions/BinaryExpression.hpp" +#include "query_optimizer/expressions/Cast.hpp" #include "query_optimizer/expressions/ComparisonExpression.hpp" #include "query_optimizer/expressions/Exists.hpp" #include "query_optimizer/expressions/ExprId.hpp" @@ -2554,6 +2555,15 @@ E::ScalarPtr Resolver::resolveExpression( expression_resolution_info, true /* has_single_column */); } + case ParseExpression::kTypeCast: { + const ParseTypeCast &parse_type_cast = + static_cast<const ParseTypeCast&>(parse_expression); + return E::Cast::Create( + resolveExpression(parse_type_cast.operand(), + nullptr /* type_hint */, + expression_resolution_info), + resolveDataType(parse_type_cast.target_type())); + } default: LOG(FATAL) << "Unknown scalar type: " << parse_expression.getExpressionType(); http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/AsciiStringSuperType.hpp ---------------------------------------------------------------------- diff --git a/types/AsciiStringSuperType.hpp b/types/AsciiStringSuperType.hpp index b6abcdf..7de550f 100644 --- a/types/AsciiStringSuperType.hpp +++ b/types/AsciiStringSuperType.hpp @@ -52,7 +52,7 @@ class AsciiStringSuperType : public TypeSynthesizer<type_id> { * @return The maximum length of a string of this type. **/ inline std::size_t getStringLength() const { - return length_; + return TypeSynthesizer<type_id>::length_; } protected: @@ -61,12 +61,9 @@ class AsciiStringSuperType : public TypeSynthesizer<type_id> { const std::size_t maximum_byte_length, const std::size_t string_length) : TypeSynthesizer<type_id>( - nullable, minimum_byte_length, maximum_byte_length, string_length), - length_(string_length) { + nullable, minimum_byte_length, maximum_byte_length, string_length) { } - const std::size_t length_; - private: DISALLOW_COPY_AND_ASSIGN(AsciiStringSuperType); }; http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/CharType.cpp ---------------------------------------------------------------------- diff --git a/types/CharType.cpp b/types/CharType.cpp index eb3f64a..319ae33 100644 --- a/types/CharType.cpp +++ b/types/CharType.cpp @@ -19,6 +19,7 @@ #include "types/CharType.hpp" +#include <algorithm> #include <cstddef> #include <cstdio> #include <cstdlib> @@ -33,12 +34,9 @@ #include "types/port/strnlen.hpp" #include "utility/PtrMap.hpp" -#include "glog/logging.h" +#include "third_party/src/farmhash/farmhash.h" -using std::pair; -using std::size_t; -using std::strcmp; -using std::string; +#include "glog/logging.h" namespace quickstep { @@ -55,8 +53,8 @@ bool CharType::isSafelyCoercibleFrom(const Type &original_type) const { } } -string CharType::getName() const { - string name("Char("); +std::string CharType::getName() const { + std::string name("Char("); name.append(std::to_string(length_)); name.push_back(')'); if (nullable_) { @@ -65,10 +63,58 @@ string CharType::getName() const { return name; } +std::size_t CharType::hashValue(const UntypedLiteral *value) const { + const char *cstr = static_cast<const char*>(castValueToLiteral(value)); + const std::size_t len = strnlen(cstr, length_); + return util::Hash(cstr, len); +} + +bool CharType::checkValuesEqual(const UntypedLiteral *lhs, + const UntypedLiteral *rhs, + const Type &rhs_type) const { + return std::strncmp(static_cast<const char*>(castValueToLiteral(lhs)), + static_cast<const char*>(castValueToLiteral(rhs)), + length_); +} + +UntypedLiteral* CharType::cloneValue(const UntypedLiteral *value) const { + DCHECK(value != nullptr); + + const char *cstr = static_cast<const char*>(castValueToLiteral(value)); + const std::size_t len = strnlen(cstr, length_); + char *value_copy = static_cast<char*>(std::malloc(length_)); + std::memcpy(value_copy, cstr, len); + if (len < length_) { + value_copy[len] = 0; + } + return new cpptype(value_copy); +} + + +TypedValue CharType::marshallValue(const UntypedLiteral *value) const { + DCHECK(value != nullptr); + + const char *cstr = static_cast<const char*>(castValueToLiteral(value)); + const std::size_t len = std::min(strnlen(cstr, length_) + 1, length_); + return TypedValue(kChar, cstr, len).ensureNotReference(); +} + +UntypedLiteral* CharType::unmarshallValue(const void *data, + const std::size_t length) const { + const char *cstr = static_cast<const char*>(data); + const std::size_t len = std::min(strnlen(cstr, length), length_); + char *value = static_cast<char*>(std::malloc(length_)); + std::memcpy(value, cstr, len); + if (len < length_) { + value[len] = 0; + } + return new cpptype(value); +} + std::string CharType::printValueToString(const UntypedLiteral *value) const { DCHECK(value != nullptr); - const char *cstr = static_cast<const char*>(castValueToLiteral(value).getOutOfLineData()); + const char *cstr = static_cast<const char*>(castValueToLiteral(value)); return std::string(cstr, strnlen(cstr, length_)); } @@ -84,7 +130,7 @@ void CharType::printValueToFile(const UntypedLiteral *value, "%*.*s", padding, static_cast<int>(length_), - castValueToLiteral(value).getOutOfLineData()); + castValueToLiteral(value)); } bool CharType::parseTypedValueFromString(const std::string &value_string, http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/CharType.hpp ---------------------------------------------------------------------- diff --git a/types/CharType.hpp b/types/CharType.hpp index 81a32ff..3355243 100644 --- a/types/CharType.hpp +++ b/types/CharType.hpp @@ -53,6 +53,19 @@ class CharType : public AsciiStringSuperType<kChar> { return length_; } + std::size_t hashValue(const UntypedLiteral *value) const override; + + bool checkValuesEqual(const UntypedLiteral *lhs, + const UntypedLiteral *rhs, + const Type &rhs_type) const override; + + UntypedLiteral* cloneValue(const UntypedLiteral *value) const override; + + TypedValue marshallValue(const UntypedLiteral *value) const override; + + UntypedLiteral* unmarshallValue(const void *data, + const std::size_t length) const override; + std::string printValueToString(const UntypedLiteral *value) const override; void printValueToFile(const UntypedLiteral *value, http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/GenericValue.hpp ---------------------------------------------------------------------- diff --git a/types/GenericValue.hpp b/types/GenericValue.hpp index 3e8045b..d289a1b 100644 --- a/types/GenericValue.hpp +++ b/types/GenericValue.hpp @@ -110,6 +110,10 @@ class GenericValue { return type_; } + inline TypeID getTypeID() const { + return type_.getTypeID(); + } + inline const UntypedLiteral* getValue() const { return value_; } http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/MetaType-decl.hpp ---------------------------------------------------------------------- diff --git a/types/MetaType-decl.hpp b/types/MetaType-decl.hpp index 6942338..80c5956 100644 --- a/types/MetaType-decl.hpp +++ b/types/MetaType-decl.hpp @@ -26,14 +26,13 @@ #include "types/Type.hpp" #include "types/TypeID.hpp" #include "types/TypeSynthesizer.hpp" +#include "types/TypedValue.hpp" #include "utility/Macros.hpp" #include "glog/logging.h" namespace quickstep { -class TypedValue; - /** \addtogroup Types * @{ */ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/NumericTypeSafeCoercibility.hpp ---------------------------------------------------------------------- diff --git a/types/NumericTypeSafeCoercibility.hpp b/types/NumericTypeSafeCoercibility.hpp index 914927c..b8ff876 100644 --- a/types/NumericTypeSafeCoercibility.hpp +++ b/types/NumericTypeSafeCoercibility.hpp @@ -21,15 +21,10 @@ #define QUICKSTEP_TYPES_NUMERIC_TYPE_SAFE_COERCIBILITY_HPP_ #include "utility/meta/TMP.hpp" +#include "types/TypeRegistrar.hpp" namespace quickstep { -class BoolType; -class DoubleType; -class FloatType; -class IntType; -class LongType; - /** \addtogroup Types * @{ */ @@ -42,7 +37,8 @@ using NumericTypeSafeCoersionPartialOrder = meta::TypeList< IsSafelyCoercible<IntType, FloatType>, IsSafelyCoercible<IntType, LongType>, IsSafelyCoercible<FloatType, DoubleType>, - IsSafelyCoercible<LongType, DoubleType>>; + IsSafelyCoercible<LongType, DoubleType> +>; using NumericTypeSafeCoersionClosure = meta::TransitiveClosure<NumericTypeSafeCoersionPartialOrder>; http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/TypeRegistrar.hpp ---------------------------------------------------------------------- diff --git a/types/TypeRegistrar.hpp b/types/TypeRegistrar.hpp index 3a25226..bb6c40d 100644 --- a/types/TypeRegistrar.hpp +++ b/types/TypeRegistrar.hpp @@ -48,6 +48,8 @@ using UntypedLiteral = void; using ArrayLiteral = std::vector<UntypedLiteral*>; using MetaTypeLiteral = const Type*; +using ParInlinePodLiteral = const void*; +using ParOutOfLinePodLiteral = TypedValue; template <TypeID type_id> struct TypeIDTrait; @@ -83,9 +85,9 @@ REGISTER_TYPE(DatetimeIntervalType, kDatetimeInterval, REGISTER_TYPE(YearMonthIntervalType, kYearMonthInterval, SuperTypeID::kOther, kCxxInlinePod, YearMonthIntervalLit); REGISTER_TYPE(CharType, kChar, - SuperTypeID::kAsciiString, kParInlinePod, TypedValue); + SuperTypeID::kAsciiString, kParInlinePod, ParInlinePodLiteral); REGISTER_TYPE(VarCharType, kVarChar, - SuperTypeID::kAsciiString, kParOutOfLinePod, TypedValue); + SuperTypeID::kAsciiString, kParOutOfLinePod, ParOutOfLinePodLiteral); REGISTER_TYPE(TextType, kText, SuperTypeID::kOther, kCxxGeneric, std::string); REGISTER_TYPE(ArrayType, kArray, http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/TypeSynthesizer.hpp ---------------------------------------------------------------------- diff --git a/types/TypeSynthesizer.hpp b/types/TypeSynthesizer.hpp index 0b5842f..d69b1b4 100644 --- a/types/TypeSynthesizer.hpp +++ b/types/TypeSynthesizer.hpp @@ -175,20 +175,148 @@ class TypeSynthesizePolicy< //////////////////////////////////////////////////////////////////////////////// -/////////////////////// ParInlinePod & ParOutOfLinePod /////////////////////// +///////////////////////////////// ParInlinePod /////////////////////////////// //////////////////////////////////////////////////////////////////////////////// template <TypeID type_id> class TypeSynthesizePolicy< type_id, - std::enable_if_t<TypeIDTrait<type_id>::kMemoryLayout == kParInlinePod || - TypeIDTrait<type_id>::kMemoryLayout == kParOutOfLinePod>> : public Type { + std::enable_if_t<TypeIDTrait<type_id>::kMemoryLayout == kParInlinePod>> : public Type { + private: + using Trait = TypeIDTrait<type_id>; + using TypeClass = typename Trait::TypeClass; + using cpptype = typename Trait::cpptype; + + static_assert(std::is_same<cpptype, const void*>::value, + "Unexpected cpptype for ParInlinePod."); + + public: + static const TypeClass& InstanceNonNullable(const std::size_t length) { + return InstanceInternal<false>(length); + } + + static const TypeClass& InstanceNullable(const std::size_t length) { + return InstanceInternal<true>(length); + } + + static const TypeClass& Instance(const bool nullable, const std::size_t length) { + if (nullable) { + return InstanceNullable(length); + } else { + return InstanceNonNullable(length); + } + } + + std::size_t length() const { + return length_; + } + + std::size_t getHash() const override { + return CombineHashes(static_cast<std::size_t>(type_id), length_); + } + + std::size_t hashValue(const UntypedLiteral *value) const override { + // TODO(refactor-type): Implementation. + return TypedValue(type_id_, + *static_cast<const cpptype*>(value), + maximum_byte_length_).getHash(); + } + + bool checkValuesEqual(const UntypedLiteral *lhs, + const UntypedLiteral *rhs, + const Type &rhs_type) const override { + if (!equals(rhs_type)) { + return false; + } + return !std::memcmp(*static_cast<const cpptype*>(lhs), + *static_cast<const cpptype*>(rhs), + maximum_byte_length_); + } + + UntypedLiteral* cloneValue(const UntypedLiteral *value) const override { + DCHECK(value != nullptr); + void *value_copy = std::malloc(maximum_byte_length_); + std::memcpy(value_copy, + *static_cast<const cpptype*>(value), + maximum_byte_length_); + return new cpptype(value_copy); + } + + void destroyValue(UntypedLiteral *value) const override { + DCHECK(value != nullptr); + cpptype *value_ptr = static_cast<cpptype*>(value); + std::free(const_cast<void*>(*value_ptr)); + delete value_ptr; + } + + TypedValue marshallValue(const UntypedLiteral *value) const override { + return TypedValue(type_id_, value, maximum_byte_length_).ensureNotReference(); + } + + UntypedLiteral* unmarshallValue(const void *data, + const std::size_t length) const override { + DCHECK_EQ(maximum_byte_length_, length); + void *value = std::malloc(maximum_byte_length_); + std::memcpy(value, data, length); + return new cpptype(value); + } + + protected: + TypeSynthesizePolicy(const bool nullable, + const std::size_t minimum_byte_length, + const std::size_t maximum_byte_length, + const std::size_t length) + : Type(Trait::kStaticSuperTypeID, type_id, nullable, + minimum_byte_length, maximum_byte_length), + length_(length) {} + + const std::size_t length_; + + inline const Type& getInstance(const bool nullable) const { + return nullable ? InstanceNullable(length_) : InstanceNonNullable(length_); + } + + inline void mergeIntoProto(serialization::Type *proto) const { + proto->set_length(length_); + } + + inline UntypedLiteral* unmarshallTypedValueInl(const TypedValue &value) const { + return unmarshallValue(value.getDataPtr(), value.getDataSize()); + } + + template <typename Functor> + inline auto invokeOnUnmarshalledTypedValue(const TypedValue &value, + const Functor &functor) const { + return functor(&value); + } + + private: + template <bool nullable> + inline static const TypeClass& InstanceInternal(const std::size_t length) { + static std::unordered_map<size_t, std::unique_ptr<TypeClass>> instance_map; + auto imit = instance_map.find(length); + if (imit == instance_map.end()) { + std::unique_ptr<TypeClass> instance(new TypeClass(nullable, length)); + imit = instance_map.emplace(length, std::move(instance)).first; + } + return *(imit->second); + } +}; + + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////// ParOutOfLinePod ///////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +template <TypeID type_id> +class TypeSynthesizePolicy< + type_id, + std::enable_if_t<TypeIDTrait<type_id>::kMemoryLayout == kParOutOfLinePod>> : public Type { private: using Trait = TypeIDTrait<type_id>; using TypeClass = typename Trait::TypeClass; using cpptype = typename Trait::cpptype; static_assert(std::is_same<cpptype, TypedValue>::value, - "Unexpected cpptype for paramerized PODs."); + "Unexpected cpptype for ParOutOfLinePod."); public: static const TypeClass& InstanceNonNullable(const std::size_t length) { http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/types/operations/CMakeLists.txt b/types/operations/CMakeLists.txt index 948d013..caf5f72 100644 --- a/types/operations/CMakeLists.txt +++ b/types/operations/CMakeLists.txt @@ -18,6 +18,7 @@ add_subdirectory(binary_operations) add_subdirectory(comparisons) add_subdirectory(unary_operations) +add_subdirectory(utility) QS_PROTOBUF_GENERATE_CPP(types_operations_Operation_proto_srcs types_operations_Operation_proto_hdrs @@ -26,7 +27,6 @@ QS_PROTOBUF_GENERATE_CPP(types_operations_Operation_proto_srcs # Declare micro-libs: add_library(quickstep_types_operations_Operation Operation.cpp Operation.hpp) add_library(quickstep_types_operations_OperationFactory OperationFactory.cpp OperationFactory.hpp) -add_library(quickstep_types_operations_OperationUtil ../../empty_src.cpp OperationUtil.hpp) add_library(quickstep_types_operations_OperationSignature OperationSignature.cpp OperationSignature.hpp) add_library(quickstep_types_operations_Operation_proto ${types_operations_Operation_proto_srcs}) @@ -42,14 +42,14 @@ target_link_libraries(quickstep_types_operations_OperationFactory quickstep_types_TypedValue quickstep_types_operations_Operation quickstep_types_operations_OperationSignature - quickstep_types_operations_binaryoperations_ArithmeticBinaryOperations - quickstep_types_operations_binaryoperations_AsciiStringBinaryOperations + quickstep_types_operations_binaryoperations_ArithmeticBinaryFunctors + quickstep_types_operations_binaryoperations_AsciiStringBinaryFunctors quickstep_types_operations_binaryoperations_BinaryOperation quickstep_types_operations_binaryoperations_BinaryOperationWrapper - quickstep_types_operations_binaryoperations_CMathBinaryOperations - quickstep_types_operations_unaryoperations_ArithmeticUnaryOperations - quickstep_types_operations_unaryoperations_AsciiStringUnaryOperations - quickstep_types_operations_unaryoperations_CMathUnaryOperations + quickstep_types_operations_binaryoperations_CMathBinaryFunctors + quickstep_types_operations_unaryoperations_ArithmeticUnaryFunctors + quickstep_types_operations_unaryoperations_AsciiStringUnaryFunctors + quickstep_types_operations_unaryoperations_CMathUnaryFunctors quickstep_types_operations_unaryoperations_CastOperation quickstep_types_operations_unaryoperations_DateExtractOperation quickstep_types_operations_unaryoperations_SubstringOperation @@ -58,11 +58,6 @@ target_link_libraries(quickstep_types_operations_OperationFactory quickstep_utility_HashPair quickstep_utility_Macros quickstep_utility_StringUtil) -target_link_libraries(quickstep_types_operations_OperationUtil - quickstep_catalog_CatalogTypedefs - quickstep_types_Type - quickstep_types_TypedValue - quickstep_types_containers_ColumnVector) target_link_libraries(quickstep_types_operations_OperationSignature quickstep_types_TypeID quickstep_types_Type_proto @@ -79,9 +74,9 @@ add_library(quickstep_types_operations ../../empty_src.cpp) target_link_libraries(quickstep_types_operations quickstep_types_operations_Operation quickstep_types_operations_OperationFactory - quickstep_types_operations_OperationUtil quickstep_types_operations_OperationSignature quickstep_types_operations_Operation_proto quickstep_types_operations_binaryoperations quickstep_types_operations_comparisons - quickstep_types_operations_unaryoperations) + quickstep_types_operations_unaryoperations + quickstep_types_operations_utility) http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/OperationFactory.cpp ---------------------------------------------------------------------- diff --git a/types/operations/OperationFactory.cpp b/types/operations/OperationFactory.cpp index 253a75d..74cc3c1 100644 --- a/types/operations/OperationFactory.cpp +++ b/types/operations/OperationFactory.cpp @@ -31,13 +31,13 @@ #include "types/TypeUtil.hpp" #include "types/operations/Operation.hpp" #include "types/operations/OperationSignature.hpp" -#include "types/operations/binary_operations/ArithmeticBinaryOperations.hpp" -#include "types/operations/binary_operations/AsciiStringBinaryOperations.hpp" +#include "types/operations/binary_operations/ArithmeticBinaryFunctors.hpp" +#include "types/operations/binary_operations/AsciiStringBinaryFunctors.hpp" #include "types/operations/binary_operations/BinaryOperationWrapper.hpp" -#include "types/operations/binary_operations/CMathBinaryOperations.hpp" -#include "types/operations/unary_operations/ArithmeticUnaryOperations.hpp" -#include "types/operations/unary_operations/AsciiStringUnaryOperations.hpp" -#include "types/operations/unary_operations/CMathUnaryOperations.hpp" +#include "types/operations/binary_operations/CMathBinaryFunctors.hpp" +#include "types/operations/unary_operations/ArithmeticUnaryFunctors.hpp" +#include "types/operations/unary_operations/AsciiStringUnaryFunctors.hpp" +#include "types/operations/unary_operations/CMathUnaryFunctors.hpp" #include "types/operations/unary_operations/CastOperation.hpp" #include "types/operations/unary_operations/DateExtractOperation.hpp" #include "types/operations/unary_operations/SubstringOperation.hpp" http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/OperationUtil.hpp ---------------------------------------------------------------------- diff --git a/types/operations/OperationUtil.hpp b/types/operations/OperationUtil.hpp deleted file mode 100644 index af23b1c..0000000 --- a/types/operations/OperationUtil.hpp +++ /dev/null @@ -1,334 +0,0 @@ -/** - * 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_TYPES_OPERATIONS_OPERATION_SYNTHESIZE_UTIL_HPP_ -#define QUICKSTEP_TYPES_OPERATIONS_OPERATION_SYNTHESIZE_UTIL_HPP_ - -#include <cstddef> -#include <list> -#include <string> -#include <type_traits> - -#include "catalog/CatalogTypedefs.hpp" -#include "types/Type.hpp" -#include "types/TypedValue.hpp" -#include "types/containers/ColumnVector.hpp" - -namespace quickstep { - -/** \addtogroup Types - * @{ - */ - -template <typename FunctorT, typename ...SpecArgs> -struct FunctorSpecializer { - template <bool specialize = (sizeof...(SpecArgs) != 0), - typename EnableT = void> - struct Implementation; - - typedef Implementation<> type; -}; - -template <typename FunctorT, typename ...SpecArgs> -template <bool specialize> -struct FunctorSpecializer<FunctorT, SpecArgs...> - ::Implementation<specialize, std::enable_if_t<specialize>> { - template <typename ...FuncArgs> - inline static auto Invoke(const FunctorT &functor, FuncArgs &&...args) { - return functor.template apply<SpecArgs...>(std::forward<FuncArgs>(args)...); - } - typedef FunctorT FunctorType; -}; - -template <typename FunctorT, typename ...SpecArgs> -template <bool specialize> -struct FunctorSpecializer<FunctorT, SpecArgs...> - ::Implementation<specialize, std::enable_if_t<!specialize>> { - template <typename ...FuncArgs> - inline static auto Invoke(const FunctorT &functor, FuncArgs &&...args) { - return functor.apply(std::forward<FuncArgs>(args)...); - } - typedef FunctorT FunctorType; -}; - -template <typename ColumnVectorT> -struct ColumnVectorValueAccessor { - explicit ColumnVectorValueAccessor(const ColumnVectorT &column_vector_in) - : column_vector(column_vector_in), - length(column_vector.size()) {} - - inline void beginIteration() { - pos = static_cast<std::size_t>(-1); - } - - inline bool next() { - return (++pos) < length; - } - - inline std::size_t getNumTuples() const { - return length; - } - - template <bool nullable> - inline const void* getUntypedValue(const attribute_id) const { - return column_vector.template getUntypedValue<nullable>(pos); - } - - inline TypedValue getTypedValue(const attribute_id) const { - return column_vector.getTypedValue(pos); - } - - const ColumnVectorT &column_vector; - const std::size_t length; - std::size_t pos; -}; - -template <typename FuncSpec, typename T, typename EnableT = void> -struct Codegen; - -template <typename FuncSpec, typename T> -struct Codegen<FuncSpec, T, std::enable_if_t<T::kMemoryLayout == kCxxInlinePod>> { - using ColumnVectorType = NativeColumnVector; - using FunctorSpecializer = FuncSpec; - - using NativeType = typename T::cpptype; - using NativeTypeConst = const typename T::cpptype; - using NativeTypeConstRef = const NativeType&; - using NativeTypeConstPtr = const NativeType*; - - template <typename ArgumentGen> - inline static TypedValue ApplyUnaryTypedValue( - typename ArgumentGen::NativeTypeConstRef argument, - const Type &result_type, - const typename FuncSpec::FunctorType &functor) { - return TypedValue(FuncSpec::Invoke(functor, argument)); - } - - template <typename ArgumentGen> - inline static void ApplyUnaryColumnVector( - const typename ArgumentGen::NativeTypeConstRef argument, - const typename FuncSpec::FunctorType &functor, - ColumnVectorType *cv) { - *static_cast<NativeType *>(cv->getPtrForDirectWrite()) = - FuncSpec::Invoke(functor, argument); - } - - template <typename LeftGen, typename RightGen> - inline static TypedValue ApplyBinaryTypedValue( - typename LeftGen::NativeTypeConstRef left, - typename RightGen::NativeTypeConstRef right, - const Type &result_type, - const typename FuncSpec::FunctorType &functor) { - return TypedValue(FuncSpec::Invoke(functor, left, right)); - } - - template <typename LeftGen, typename RightGen> - inline static void ApplyBinaryColumnVector( - const typename LeftGen::NativeTypeConstRef left, - const typename RightGen::NativeTypeConstRef right, - const typename FuncSpec::FunctorType &functor, - ColumnVectorType *cv) { - *static_cast<NativeType *>(cv->getPtrForDirectWrite()) = - FuncSpec::Invoke(functor, left, right); - } - - template <bool nullable, typename AccessorT> - inline static NativeTypeConstPtr GetValuePtr( - const AccessorT *accessor, - const attribute_id attr_id) { - return static_cast<NativeTypeConstPtr>( - accessor->template getUntypedValue<nullable>(attr_id)); - } - - inline static bool IsNull(const NativeType *value) { - return value == nullptr; - } - - // Dereference: NativeTypeConstPtr& -> const NativeType& - inline static const NativeType& Dereference(const NativeType *value) { - return *value; - } - - inline static const NativeType ToNativeValueConst(const TypedValue &value) { - return value.getLiteral<NativeType>(); - } -}; - -template <typename FuncSpec, typename T> -struct Codegen<FuncSpec, T, std::enable_if_t<T::kMemoryLayout == kParInlinePod>> { - using ColumnVectorType = NativeColumnVector; - using FunctorSpecializer = FuncSpec; - - using NativeType = void*; - using NativeTypeConst = const void*; - using NativeTypeConstRef = const void*; - using NativeTypeConstPtr = const void*; - - template <typename ArgumentGen> - inline static TypedValue ApplyUnaryTypedValue( - typename ArgumentGen::NativeTypeConstRef argument, - const Type &result_type, - const typename FuncSpec::FunctorType &functor) { - void *result = std::malloc(result_type.maximumByteLength()); - FuncSpec::Invoke(functor, argument, result); - return TypedValue::CreateWithOwnedData(T::kStaticTypeID, - result, - result_type.maximumByteLength()); - } - - template <typename ArgumentGen> - inline static void ApplyUnaryColumnVector( - const typename ArgumentGen::NativeTypeConstRef argument, - const typename FuncSpec::FunctorType &functor, - ColumnVectorType *cv) { - FuncSpec::Invoke(functor, argument, cv->getPtrForDirectWrite()); - } - - template <typename LeftGen, typename RightGen> - inline static TypedValue ApplyBinaryTypedValue( - typename LeftGen::NativeTypeConstRef left, - typename RightGen::NativeTypeConstRef right, - const Type &result_type, - const typename FuncSpec::FunctorType &functor) { - void *result = std::malloc(result_type.maximumByteLength()); - FuncSpec::Invoke(functor, left, right, result); - return TypedValue::CreateWithOwnedData(T::kStaticTypeID, - result, - result_type.maximumByteLength()); - } - - template <typename LeftGen, typename RightGen> - inline static void ApplyBinaryColumnVector( - const typename LeftGen::NativeTypeConstRef left, - const typename RightGen::NativeTypeConstRef right, - const typename FuncSpec::FunctorType &functor, - ColumnVectorType *cv) { - FuncSpec::Invoke(functor, left, right, cv->getPtrForDirectWrite()); - } - - template <bool nullable, typename AccessorT> - inline static NativeTypeConstPtr GetValuePtr( - const AccessorT *accessor, - const attribute_id attr_id) { - return accessor->template getUntypedValue<nullable>(attr_id); - } - - inline static bool IsNull(const void *value) { - return value == nullptr; - } - - // Dereference: NativeTypeConstPtr& -> const NativeType& - inline static const void* Dereference(const void *value) { - return value; - } - - inline static const void* ToNativeValueConst(const TypedValue &value) { - return value.getDataPtr(); - } -}; - -template <typename FuncSpec, typename T> -struct Codegen<FuncSpec, T, std::enable_if_t<T::kMemoryLayout == kParOutOfLinePod>> { - using ColumnVectorType = IndirectColumnVector; - using FunctorSpecializer = FuncSpec; - - using NativeType = TypedValue; - using NativeTypeConst = const TypedValue; - using NativeTypeConstRef = const TypedValue&; - using NativeTypeConstPtr = const TypedValue; - - template <typename ArgumentGen> - inline static TypedValue ApplyUnaryTypedValue( - typename ArgumentGen::NativeTypeConstRef argument, - const Type &result_type, - const typename FuncSpec::FunctorType &functor) { - return FuncSpec::Invoke(functor, argument); - } - - template <typename ArgumentGen> - inline static void ApplyUnaryColumnVector( - const typename ArgumentGen::NativeTypeConstRef argument, - const typename FuncSpec::FunctorType &functor, - ColumnVectorType *cv) { - cv->appendTypedValue(FuncSpec::Invoke(functor, argument)); - } - - template <typename LeftGen, typename RightGen> - inline static TypedValue ApplyBinaryTypedValue( - typename LeftGen::NativeTypeConstRef left, - typename RightGen::NativeTypeConstRef right, - const Type &result_type, - const typename FuncSpec::FunctorType &functor) { - return FuncSpec::Invoke(functor, left, right); - } - - template <typename LeftGen, typename RightGen> - inline static void ApplyBinaryColumnVector( - const typename LeftGen::NativeTypeConstRef left, - const typename RightGen::NativeTypeConstRef right, - const typename FuncSpec::FunctorType &functor, - ColumnVectorType *cv) { - cv->appendTypedValue(FuncSpec::Invoke(functor, left, right)); - } - - template <bool nullable, typename AccessorT> - inline static NativeTypeConstPtr GetValuePtr( - const AccessorT *accessor, - const attribute_id attr_id) { - return accessor->getTypedValue(attr_id); - } - - inline static bool IsNull(NativeTypeConstPtr &value) { - return value.isNull(); - } - - // Dereference: NativeTypeConstPtr& -> const NativeType& - inline static const NativeType& Dereference(NativeTypeConstPtr &value) { - return value; - } - - inline static const NativeType& ToNativeValueConst(const TypedValue &value) { - return value; - } -}; - -template <typename ...FunctorTypes> -struct FunctorPack { - template <typename Dispatcher> - inline static std::list<OperationPtr> GenerateOperations() { - std::vector<std::list<OperationPtr>> op_list_groups = - { Dispatcher::template Generate<FunctorTypes>()... }; - - std::list<OperationPtr> operations; - for (std::list<OperationPtr> &op_list : op_list_groups) { - operations.splice(operations.end(), std::move(op_list)); - } - return operations; - } -}; - -struct OperationPack { - virtual std::vector<OperationPtr> generateOperations() = 0; -}; - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_TYPES_OPERATIONS_OPERATION_SYNTHESIZE_UTIL_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/binary_operations/AddBinaryOperation.hpp ---------------------------------------------------------------------- diff --git a/types/operations/binary_operations/AddBinaryOperation.hpp b/types/operations/binary_operations/AddBinaryOperation.hpp deleted file mode 100644 index 2309563..0000000 --- a/types/operations/binary_operations/AddBinaryOperation.hpp +++ /dev/null @@ -1,94 +0,0 @@ -/** - * 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_TYPES_OPERATIONS_BINARY_OPERATIONS_ADD_BINARY_OPERATION_HPP_ -#define QUICKSTEP_TYPES_OPERATIONS_BINARY_OPERATIONS_ADD_BINARY_OPERATION_HPP_ - -#include <utility> - -#include "types/TypedValue.hpp" -#include "types/operations/binary_operations/ArithmeticBinaryOperation.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" -#include "utility/Macros.hpp" - -namespace quickstep { - -class Type; -class UncheckedBinaryOperator; - -/** \addtogroup Types - * @{ - */ - -/** - * @brief The BinaryOperation for addition. - **/ -class AddBinaryOperation : public ArithmeticBinaryOperation { - public: - /** - * @brief Get a reference to the singleton instance of this Operation. - * - * @return A reference to the singleton instance of this Operation. - **/ - static const AddBinaryOperation& Instance() { - static AddBinaryOperation instance; - return instance; - } - - bool isCommutative() const override { - return true; - } - - bool canApplyToTypes(const Type &left, - const Type &right) const override; - - const Type* resultTypeForArgumentTypes(const Type &left, - const Type &right) const override; - - const Type* resultTypeForPartialArgumentTypes(const Type *left, - const Type *right) const override; - - bool partialTypeSignatureIsPlausible(const Type *result_type, - const Type *left_argument_type, - const Type *right_argument_type) const override; - - std::pair<const Type*, const Type*> pushDownTypeHint( - const Type *result_type_hint) const override; - - TypedValue applyToChecked(const TypedValue &left, - const Type &left_type, - const TypedValue &right, - const Type &right_type) const override; - - UncheckedBinaryOperator* makeUncheckedBinaryOperatorForTypes(const Type &left, - const Type &right) const override; - - private: - AddBinaryOperation() - : ArithmeticBinaryOperation(BinaryOperationID::kAdd) { - } - - DISALLOW_COPY_AND_ASSIGN(AddBinaryOperation); -}; - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_TYPES_OPERATIONS_BINARY_OPERATIONS_ADD_BINARY_OPERATION_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/binary_operations/ArithmeticBinaryFunctors.hpp ---------------------------------------------------------------------- diff --git a/types/operations/binary_operations/ArithmeticBinaryFunctors.hpp b/types/operations/binary_operations/ArithmeticBinaryFunctors.hpp new file mode 100644 index 0000000..402bd0a --- /dev/null +++ b/types/operations/binary_operations/ArithmeticBinaryFunctors.hpp @@ -0,0 +1,182 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + **/ + +#ifndef QUICKSTEP_TYPES_OPERATIONS_BINARY_OPERATIONS_ARITHMETIC_BINARY_FUNCTORS_HPP_ +#define QUICKSTEP_TYPES_OPERATIONS_BINARY_OPERATIONS_ARITHMETIC_BINARY_FUNCTORS_HPP_ + +#include <string> +#include <tuple> + +#include "types/DateType.hpp" +#include "types/DatetimeIntervalType.hpp" +#include "types/DatetimeLit.hpp" +#include "types/DatetimeType.hpp" +#include "types/IntervalLit.hpp" +#include "types/NumericTypeUnifier.hpp" +#include "types/Type.hpp" +#include "types/TypeErrors.hpp" +#include "types/TypeFactory.hpp" +#include "types/TypeID.hpp" +#include "types/TypedValue.hpp" +#include "types/YearMonthIntervalType.hpp" +#include "types/operations/binary_operations/ArithmeticBinaryFunctorOverloads.hpp" +#include "types/operations/binary_operations/BinaryOperationWrapper.hpp" +#include "utility/meta/Common.hpp" + +namespace quickstep { + +/** \addtogroup Types + * @{ + */ + +template <typename LeftT, typename RightT, typename ResultT, + template <typename LeftCppType, + typename RightCppType, + typename EnableT = void> class FunctorOverload, + typename FunctorName> +struct ArithmeticBinaryFunctor : public BinaryFunctor<LeftT, RightT, ResultT> { + ArithmeticBinaryFunctor() : spec() {} + inline typename ResultT::cpptype apply(const typename LeftT::cpptype &left, + const typename RightT::cpptype &right) const { + return spec(left, right); + } + inline static std::string GetName() { + return FunctorName::ToString(); + } + const FunctorOverload<typename LeftT::cpptype, + typename RightT::cpptype> spec; +}; + +template <typename LeftT, typename RightT, typename ResultT> +using AddFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, + AddFunctorOverloads, + meta::StringLiteral<'+'>>; + +template <typename LeftT, typename RightT, typename ResultT> +using SubtractFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, + SubtractFunctorOverloads, + meta::StringLiteral<'-'>>; + +template <typename LeftT, typename RightT, typename ResultT> +using MultiplyFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, + MultiplyFunctorOverloads, + meta::StringLiteral<'*'>>; + +template <typename LeftT, typename RightT, typename ResultT> +using DivideFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, + DivideFunctorOverloads, + meta::StringLiteral<'/'>>; + +template <typename LeftT, typename RightT, typename ResultT> +using ModuloFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, + ModuloFunctorOverloads, + meta::StringLiteral<'%'>>; + +// ---------------------------------------------------------------------------- +// Packs of functors: + +using AddBinaryFunctorPack = FunctorPack< +// Numeric + BinaryFunctorCrossProductPack< + std::tuple<IntType, LongType, FloatType, DoubleType>, + std::tuple<IntType, LongType, FloatType, DoubleType>, + AddFunctor, NumericTypeUnifier>, +// Date + AddFunctor<DateType, YearMonthIntervalType, DateType>, + AddFunctor<YearMonthIntervalType, DateType, DateType>, +// Datetime + AddFunctor<DatetimeType, DatetimeIntervalType, DatetimeType>, + AddFunctor<DatetimeType, YearMonthIntervalType, DatetimeType>, + AddFunctor<DatetimeIntervalType, DatetimeType, DatetimeType>, + AddFunctor<YearMonthIntervalType, DatetimeType, DatetimeType>, +// DatetimeInterval + AddFunctor<DatetimeIntervalType, DatetimeIntervalType, DatetimeIntervalType>, +// YearMonthInterval + AddFunctor<YearMonthIntervalType, YearMonthIntervalType, YearMonthIntervalType> +>; + +using SubtractBinaryFunctorPack = FunctorPack< +// Numeric + BinaryFunctorCrossProductPack< + std::tuple<IntType, LongType, FloatType, DoubleType>, + std::tuple<IntType, LongType, FloatType, DoubleType>, + SubtractFunctor, NumericTypeUnifier>, +// Date + SubtractFunctor<DateType, YearMonthIntervalType, DateType>, + // TODO(quickstep-team): + // Implement SubtractFunctor<DateType, DateType, YearMonthIntervalType>, +// Datetime + SubtractFunctor<DatetimeType, DatetimeIntervalType, DatetimeType>, + SubtractFunctor<DatetimeType, YearMonthIntervalType, DatetimeType>, + SubtractFunctor<DatetimeType, DatetimeType, DatetimeIntervalType>, +// DatetimeInterval + SubtractFunctor<DatetimeIntervalType, DatetimeIntervalType, DatetimeIntervalType>, +// YearMonthInterval + SubtractFunctor<YearMonthIntervalType, YearMonthIntervalType, YearMonthIntervalType> +>; + +using MultiplyBinaryFunctorPack = FunctorPack< +// Numeric + BinaryFunctorCrossProductPack< + std::tuple<IntType, LongType, FloatType, DoubleType>, + std::tuple<IntType, LongType, FloatType, DoubleType>, + MultiplyFunctor, NumericTypeUnifier>, +// DatetimeInterval and YearMonthInterval + BinaryFunctorCrossProductPack< + std::tuple<DatetimeIntervalType, YearMonthIntervalType>, + std::tuple<IntType, LongType, FloatType, DoubleType>, + MultiplyFunctor, meta::PairSelectorLeft>, + BinaryFunctorCrossProductPack< + std::tuple<IntType, LongType, FloatType, DoubleType>, + std::tuple<DatetimeIntervalType, YearMonthIntervalType>, + MultiplyFunctor, meta::PairSelectorRight> +>; + +using DivideBinaryFunctorPack = FunctorPack< +// Numeric + BinaryFunctorCrossProductPack< + std::tuple<IntType, LongType, FloatType, DoubleType>, + std::tuple<IntType, LongType, FloatType, DoubleType>, + DivideFunctor, NumericTypeUnifier>, +// DatetimeInterval and YearMonthInterval + BinaryFunctorCrossProductPack< + std::tuple<DatetimeIntervalType, YearMonthIntervalType>, + std::tuple<IntType, LongType, FloatType, DoubleType>, + DivideFunctor, meta::PairSelectorLeft> +>; + +using ModuloBinaryFunctorPack = FunctorPack< +// Numeric + BinaryFunctorCrossProductPack< + std::tuple<IntType, LongType, FloatType, DoubleType>, + std::tuple<IntType, LongType, FloatType, DoubleType>, + ModuloFunctor, NumericTypeUnifier> +>; + +using ArithmeticBinaryFunctorPack = FunctorPack< + AddBinaryFunctorPack, + SubtractBinaryFunctorPack, + MultiplyBinaryFunctorPack, + DivideBinaryFunctorPack, + ModuloBinaryFunctorPack +>; + +} // namespace quickstep + +#endif // QUICKSTEP_TYPES_OPERATIONS_BINARY_OPERATIONS_ARITHMETIC_BINARY_FUNCTORS_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/binary_operations/ArithmeticBinaryOperations.hpp ---------------------------------------------------------------------- diff --git a/types/operations/binary_operations/ArithmeticBinaryOperations.hpp b/types/operations/binary_operations/ArithmeticBinaryOperations.hpp deleted file mode 100644 index fa4d926..0000000 --- a/types/operations/binary_operations/ArithmeticBinaryOperations.hpp +++ /dev/null @@ -1,182 +0,0 @@ -/** - * 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_TYPES_OPERATIONS_BINARY_OPERATIONS_ARITHMETIC_BINARY_OPERATIONS_HPP_ -#define QUICKSTEP_TYPES_OPERATIONS_BINARY_OPERATIONS_ARITHMETIC_BINARY_OPERATIONS_HPP_ - -#include <string> -#include <tuple> - -#include "types/DateType.hpp" -#include "types/DatetimeIntervalType.hpp" -#include "types/DatetimeLit.hpp" -#include "types/DatetimeType.hpp" -#include "types/IntervalLit.hpp" -#include "types/NumericTypeUnifier.hpp" -#include "types/Type.hpp" -#include "types/TypeErrors.hpp" -#include "types/TypeFactory.hpp" -#include "types/TypeID.hpp" -#include "types/TypedValue.hpp" -#include "types/YearMonthIntervalType.hpp" -#include "types/operations/binary_operations/ArithmeticBinaryFunctorOverloads.hpp" -#include "types/operations/binary_operations/BinaryOperationWrapper.hpp" -#include "utility/meta/Common.hpp" - -namespace quickstep { - -/** \addtogroup Types - * @{ - */ - -template <typename LeftT, typename RightT, typename ResultT, - template <typename LeftCppType, - typename RightCppType, - typename EnableT = void> class FunctorOverloadsT, - typename FunctorNameT> -struct ArithmeticBinaryFunctor : public BinaryFunctor<LeftT, RightT, ResultT> { - ArithmeticBinaryFunctor() : spec() {} - inline typename ResultT::cpptype apply(const typename LeftT::cpptype &left, - const typename RightT::cpptype &right) const { - return spec(left, right); - } - inline static std::string GetName() { - return FunctorNameT::ToString(); - } - const FunctorOverloadsT<typename LeftT::cpptype, - typename RightT::cpptype> spec; -}; - -template <typename LeftT, typename RightT, typename ResultT> -using AddFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, - AddFunctorOverloads, - meta::StringLiteral<'+'>>; - -template <typename LeftT, typename RightT, typename ResultT> -using SubtractFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, - SubtractFunctorOverloads, - meta::StringLiteral<'-'>>; - -template <typename LeftT, typename RightT, typename ResultT> -using MultiplyFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, - MultiplyFunctorOverloads, - meta::StringLiteral<'*'>>; - -template <typename LeftT, typename RightT, typename ResultT> -using DivideFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, - DivideFunctorOverloads, - meta::StringLiteral<'/'>>; - -template <typename LeftT, typename RightT, typename ResultT> -using ModuloFunctor = ArithmeticBinaryFunctor<LeftT, RightT, ResultT, - ModuloFunctorOverloads, - meta::StringLiteral<'%'>>; - -// ---------------------------------------------------------------------------- -// Packs of functors: - -using AddBinaryFunctorPack = FunctorPack< -// Numeric - BinaryFunctorCrossProductPack< - std::tuple<IntType, LongType, FloatType, DoubleType>, - std::tuple<IntType, LongType, FloatType, DoubleType>, - AddFunctor, NumericTypeUnifier>, -// Date - AddFunctor<DateType, YearMonthIntervalType, DateType>, - AddFunctor<YearMonthIntervalType, DateType, DateType>, -// Datetime - AddFunctor<DatetimeType, DatetimeIntervalType, DatetimeType>, - AddFunctor<DatetimeType, YearMonthIntervalType, DatetimeType>, - AddFunctor<DatetimeIntervalType, DatetimeType, DatetimeType>, - AddFunctor<YearMonthIntervalType, DatetimeType, DatetimeType>, -// DatetimeInterval - AddFunctor<DatetimeIntervalType, DatetimeIntervalType, DatetimeIntervalType>, -// YearMonthInterval - AddFunctor<YearMonthIntervalType, YearMonthIntervalType, YearMonthIntervalType> ->; - -using SubtractBinaryFunctorPack = FunctorPack< -// Numeric - BinaryFunctorCrossProductPack< - std::tuple<IntType, LongType, FloatType, DoubleType>, - std::tuple<IntType, LongType, FloatType, DoubleType>, - SubtractFunctor, NumericTypeUnifier>, -// Date - SubtractFunctor<DateType, YearMonthIntervalType, DateType>, - // TODO(quickstep-team): - // Implement SubtractFunctor<DateType, DateType, YearMonthIntervalType>, -// Datetime - SubtractFunctor<DatetimeType, DatetimeIntervalType, DatetimeType>, - SubtractFunctor<DatetimeType, YearMonthIntervalType, DatetimeType>, - SubtractFunctor<DatetimeType, DatetimeType, DatetimeIntervalType>, -// DatetimeInterval - SubtractFunctor<DatetimeIntervalType, DatetimeIntervalType, DatetimeIntervalType>, -// YearMonthInterval - SubtractFunctor<YearMonthIntervalType, YearMonthIntervalType, YearMonthIntervalType> ->; - -using MultiplyBinaryFunctorPack = FunctorPack< -// Numeric - BinaryFunctorCrossProductPack< - std::tuple<IntType, LongType, FloatType, DoubleType>, - std::tuple<IntType, LongType, FloatType, DoubleType>, - MultiplyFunctor, NumericTypeUnifier>, -// DatetimeInterval and YearMonthInterval - BinaryFunctorCrossProductPack< - std::tuple<DatetimeIntervalType, YearMonthIntervalType>, - std::tuple<IntType, LongType, FloatType, DoubleType>, - MultiplyFunctor, meta::PairSelectorLeft>, - BinaryFunctorCrossProductPack< - std::tuple<IntType, LongType, FloatType, DoubleType>, - std::tuple<DatetimeIntervalType, YearMonthIntervalType>, - MultiplyFunctor, meta::PairSelectorRight> ->; - -using DivideBinaryFunctorPack = FunctorPack< -// Numeric - BinaryFunctorCrossProductPack< - std::tuple<IntType, LongType, FloatType, DoubleType>, - std::tuple<IntType, LongType, FloatType, DoubleType>, - DivideFunctor, NumericTypeUnifier>, -// DatetimeInterval and YearMonthInterval - BinaryFunctorCrossProductPack< - std::tuple<DatetimeIntervalType, YearMonthIntervalType>, - std::tuple<IntType, LongType, FloatType, DoubleType>, - DivideFunctor, meta::PairSelectorLeft> ->; - -using ModuloBinaryFunctorPack = FunctorPack< -// Numeric - BinaryFunctorCrossProductPack< - std::tuple<IntType, LongType, FloatType, DoubleType>, - std::tuple<IntType, LongType, FloatType, DoubleType>, - ModuloFunctor, NumericTypeUnifier> ->; - -using ArithmeticBinaryFunctorPack = FunctorPack< - AddBinaryFunctorPack, - SubtractBinaryFunctorPack, - MultiplyBinaryFunctorPack, - DivideBinaryFunctorPack, - ModuloBinaryFunctorPack ->; - -} // namespace quickstep - -#endif // QUICKSTEP_TYPES_OPERATIONS_BINARY_OPERATIONS_ARITHMETIC_BINARY_OPERATIONS_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/binary_operations/AsciiStringBinaryFunctors.hpp ---------------------------------------------------------------------- diff --git a/types/operations/binary_operations/AsciiStringBinaryFunctors.hpp b/types/operations/binary_operations/AsciiStringBinaryFunctors.hpp new file mode 100644 index 0000000..5fd54d6 --- /dev/null +++ b/types/operations/binary_operations/AsciiStringBinaryFunctors.hpp @@ -0,0 +1,130 @@ +/** + * 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_TYPES_OPERATIONS_UNARY_OPERATIONS_ASCII_STRING_BINARY_FUNCTORS_HPP_ +#define QUICKSTEP_TYPES_OPERATIONS_UNARY_OPERATIONS_ASCII_STRING_BINARY_FUNCTORS_HPP_ + +#include <cctype> +#include <cstring> +#include <string> + +#include "types/CharType.hpp" +#include "types/IntType.hpp" +#include "types/Type.hpp" +#include "types/TypeFactory.hpp" +#include "types/TypeID.hpp" +#include "types/VarCharType.hpp" +#include "types/operations/unary_operations/UnaryOperationWrapper.hpp" +#include "types/operations/utility/OperationSynthesizeUtil.hpp" +#include "types/port/strnlen.hpp" + +namespace quickstep { + +/** \addtogroup Types + * @{ + */ + +template <typename LeftT, typename RightT, typename ResultT> +struct AsciiStringConcatFunctor : public BinaryFunctor<LeftT, RightT, ResultT> { + explicit AsciiStringConcatFunctor(const LeftT &left, const RightT &right) + : left_max_(left.getStringLength()), + right_max_(right.getStringLength()), + result_max_(left_max_ + right_max_) {} + inline void concat(const void *left, const std::size_t l_len, + const void *right, const std::size_t r_len, + void *result) const { + char *result_str = static_cast<char*>(result); + std::memcpy(result_str, left, l_len); + std::memcpy(result_str + l_len, right, r_len); + + const std::size_t result_len = l_len + r_len; + if (ResultT::kStaticTypeID == kVarChar || result_len < result_max_) { + result_str[result_len] = 0; + } + } + inline void apply(const void *left, const void *right, void *result) const { + concat(left, strnlen(static_cast<const char*>(left), left_max_), + right, strnlen(static_cast<const char*>(right), right_max_), + result); + } + inline TypedValue apply(const void *left, const TypedValue &right) const { + const std::size_t l_len = + strnlen(static_cast<const char*>(left), left_max_); + const std::size_t r_len = + std::strlen(static_cast<const char*>(right.getOutOfLineData())); + const std::size_t buf_len = l_len + r_len + 1; + char *buf = static_cast<char*>(std::malloc(buf_len)); + concat(left, l_len, right.getOutOfLineData(), r_len, buf); + return TypedValue::CreateWithOwnedData(kVarChar, buf, buf_len); + } + inline TypedValue apply(const TypedValue &left, const void *right) const { + const std::size_t l_len = + std::strlen(static_cast<const char*>(left.getOutOfLineData())); + const std::size_t r_len = + strnlen(static_cast<const char*>(right), right_max_);; + const std::size_t buf_len = l_len + r_len + 1; + char *buf = static_cast<char*>(std::malloc(buf_len)); + concat(left.getOutOfLineData(), l_len, right, r_len, buf); + return TypedValue::CreateWithOwnedData(kVarChar, buf, buf_len); + } + inline TypedValue apply(const TypedValue &left, const TypedValue &right) const { + const std::size_t l_len = + std::strlen(static_cast<const char*>(left.getOutOfLineData())); + const std::size_t r_len = + std::strlen(static_cast<const char*>(right.getOutOfLineData())); + const std::size_t buf_len = l_len + r_len + 1; + char *buf = static_cast<char*>(std::malloc(buf_len)); + concat(left.getOutOfLineData(), l_len, right.getOutOfLineData(), r_len, buf); + return TypedValue::CreateWithOwnedData(kVarChar, buf, buf_len); + } + inline static std::string GetName() { + return "+"; + } + inline static const Type* GetResultType(const Type &left, const Type &right) { + DCHECK(left.getTypeID() == LeftT::kStaticTypeID); + DCHECK(right.getTypeID() == RightT::kStaticTypeID); + const std::size_t result_len = + static_cast<const LeftT&>(left).getStringLength() + + static_cast<const RightT&>(right).getStringLength(); + const bool is_nullable = left.isNullable() || right.isNullable(); + if (LeftT::kStaticTypeID == kChar && RightT::kStaticTypeID == kChar) { + return &TypeFactory::GetType(kChar, result_len, is_nullable); + } else { + return &TypeFactory::GetType(kVarChar, result_len, is_nullable); + } + } + const std::size_t left_max_; + const std::size_t right_max_; + const std::size_t result_max_; +}; + + +using AsciiStringBinaryFunctorPack = FunctorPack< +// concat + AsciiStringConcatFunctor<CharType, CharType, CharType>, + AsciiStringConcatFunctor<CharType, VarCharType, VarCharType>, + AsciiStringConcatFunctor<VarCharType, CharType, VarCharType>, + AsciiStringConcatFunctor<VarCharType, VarCharType, VarCharType> +>; + +/** @} */ + +} // namespace quickstep + +#endif // QUICKSTEP_TYPES_OPERATIONS_UNARY_OPERATIONS_ASCII_STRING_BINARY_FUNCTORS_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/binary_operations/AsciiStringBinaryOperations.hpp ---------------------------------------------------------------------- diff --git a/types/operations/binary_operations/AsciiStringBinaryOperations.hpp b/types/operations/binary_operations/AsciiStringBinaryOperations.hpp deleted file mode 100644 index 7181bc6..0000000 --- a/types/operations/binary_operations/AsciiStringBinaryOperations.hpp +++ /dev/null @@ -1,130 +0,0 @@ -/** - * 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_TYPES_OPERATIONS_UNARY_OPERATIONS_ASCII_STRING_BINARY_OPERATIONS_HPP_ -#define QUICKSTEP_TYPES_OPERATIONS_UNARY_OPERATIONS_ASCII_STRING_BINARY_OPERATIONS_HPP_ - -#include <cctype> -#include <cstring> -#include <string> - -#include "types/CharType.hpp" -#include "types/IntType.hpp" -#include "types/Type.hpp" -#include "types/TypeFactory.hpp" -#include "types/TypeID.hpp" -#include "types/VarCharType.hpp" -#include "types/operations/OperationUtil.hpp" -#include "types/operations/unary_operations/UnaryOperationWrapper.hpp" -#include "types/port/strnlen.hpp" - -namespace quickstep { - -/** \addtogroup Types - * @{ - */ - -template <typename LeftT, typename RightT, typename ResultT> -struct AsciiStringConcatFunctor : public BinaryFunctor<LeftT, RightT, ResultT> { - explicit AsciiStringConcatFunctor(const LeftT &left, const RightT &right) - : left_max_(left.getStringLength()), - right_max_(right.getStringLength()), - result_max_(left_max_ + right_max_) {} - inline void concat(const void *left, const std::size_t l_len, - const void *right, const std::size_t r_len, - void *result) const { - char *result_str = static_cast<char*>(result); - std::memcpy(result_str, left, l_len); - std::memcpy(result_str + l_len, right, r_len); - - const std::size_t result_len = l_len + r_len; - if (ResultT::kStaticTypeID == kVarChar || result_len < result_max_) { - result_str[result_len] = 0; - } - } - inline void apply(const void *left, const void *right, void *result) const { - concat(left, strnlen(static_cast<const char*>(left), left_max_), - right, strnlen(static_cast<const char*>(right), right_max_), - result); - } - inline TypedValue apply(const void *left, const TypedValue &right) const { - const std::size_t l_len = - strnlen(static_cast<const char*>(left), left_max_); - const std::size_t r_len = - std::strlen(static_cast<const char*>(right.getOutOfLineData())); - const std::size_t buf_len = l_len + r_len + 1; - char *buf = static_cast<char*>(std::malloc(buf_len)); - concat(left, l_len, right.getOutOfLineData(), r_len, buf); - return TypedValue::CreateWithOwnedData(kVarChar, buf, buf_len); - } - inline TypedValue apply(const TypedValue &left, const void *right) const { - const std::size_t l_len = - std::strlen(static_cast<const char*>(left.getOutOfLineData())); - const std::size_t r_len = - strnlen(static_cast<const char*>(right), right_max_);; - const std::size_t buf_len = l_len + r_len + 1; - char *buf = static_cast<char*>(std::malloc(buf_len)); - concat(left.getOutOfLineData(), l_len, right, r_len, buf); - return TypedValue::CreateWithOwnedData(kVarChar, buf, buf_len); - } - inline TypedValue apply(const TypedValue &left, const TypedValue &right) const { - const std::size_t l_len = - std::strlen(static_cast<const char*>(left.getOutOfLineData())); - const std::size_t r_len = - std::strlen(static_cast<const char*>(right.getOutOfLineData())); - const std::size_t buf_len = l_len + r_len + 1; - char *buf = static_cast<char*>(std::malloc(buf_len)); - concat(left.getOutOfLineData(), l_len, right.getOutOfLineData(), r_len, buf); - return TypedValue::CreateWithOwnedData(kVarChar, buf, buf_len); - } - inline static std::string GetName() { - return "+"; - } - inline static const Type* GetResultType(const Type &left, const Type &right) { - DCHECK(left.getTypeID() == LeftT::kStaticTypeID); - DCHECK(right.getTypeID() == RightT::kStaticTypeID); - const std::size_t result_len = - static_cast<const LeftT&>(left).getStringLength() + - static_cast<const RightT&>(right).getStringLength(); - const bool is_nullable = left.isNullable() || right.isNullable(); - if (LeftT::kStaticTypeID == kChar && RightT::kStaticTypeID == kChar) { - return &TypeFactory::GetType(kChar, result_len, is_nullable); - } else { - return &TypeFactory::GetType(kVarChar, result_len, is_nullable); - } - } - const std::size_t left_max_; - const std::size_t right_max_; - const std::size_t result_max_; -}; - - -using AsciiStringBinaryFunctorPack = FunctorPack< -// concat - AsciiStringConcatFunctor<CharType, CharType, CharType>, - AsciiStringConcatFunctor<CharType, VarCharType, VarCharType>, - AsciiStringConcatFunctor<VarCharType, CharType, VarCharType>, - AsciiStringConcatFunctor<VarCharType, VarCharType, VarCharType> ->; - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_TYPES_OPERATIONS_UNARY_OPERATIONS_ASCII_STRING_BINARY_OPERATIONS_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/1cb97e35/types/operations/binary_operations/BinaryOperationWrapper.hpp ---------------------------------------------------------------------- diff --git a/types/operations/binary_operations/BinaryOperationWrapper.hpp b/types/operations/binary_operations/BinaryOperationWrapper.hpp index f5edf52..3a336ee 100644 --- a/types/operations/binary_operations/BinaryOperationWrapper.hpp +++ b/types/operations/binary_operations/BinaryOperationWrapper.hpp @@ -35,8 +35,8 @@ #include "types/TypedValue.hpp" #include "types/containers/ColumnVector.hpp" #include "types/operations/OperationSignature.hpp" -#include "types/operations/OperationUtil.hpp" #include "types/operations/binary_operations/BinaryOperation.hpp" +#include "types/operations/utility/OperationSynthesizeUtil.hpp" #include "utility/Macros.hpp" #include "utility/meta/Common.hpp" @@ -237,9 +237,9 @@ class UncheckedBinaryOperatorWrapperCodegen : public UncheckedBinaryOperator { using ResultType = typename FunctorT::ResultType; using FuncSpec = typename FunctorSpecializer<FunctorT, SpecArgs...>::type; - using LeftGen = Codegen<FuncSpec, LeftType>; - using RightGen = Codegen<FuncSpec, RightType>; - using ResultGen = Codegen<FuncSpec, ResultType>; + using LeftGen = OperationCodegen<FuncSpec, LeftType>; + using RightGen = OperationCodegen<FuncSpec, RightType>; + using ResultGen = OperationCodegen<FuncSpec, ResultType>; template <bool left_nullable, bool right_nullable> struct Implementation;
