| /** |
| * 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 "types/operations/binary_operations/SubtractBinaryOperation.hpp" |
| |
| #include <string> |
| #include <utility> |
| |
| #include "types/DateOperatorOverloads.hpp" |
| #include "types/DateType.hpp" |
| #include "types/DatetimeIntervalType.hpp" |
| #include "types/DatetimeLit.hpp" |
| #include "types/DatetimeType.hpp" |
| #include "types/IntervalLit.hpp" |
| #include "types/Type.hpp" |
| #include "types/TypeErrors.hpp" |
| #include "types/TypeFactory.hpp" |
| #include "types/TypeID.hpp" |
| #include "types/YearMonthIntervalType.hpp" |
| #include "types/operations/binary_operations/ArithmeticBinaryOperators.hpp" |
| #include "utility/EqualsAnyConstant.hpp" |
| |
| #include "glog/logging.h" |
| |
| namespace quickstep { |
| |
| bool SubtractBinaryOperation::canApplyToTypes(const Type &left, const Type &right) const { |
| switch (left.getTypeID()) { |
| case kInt: |
| case kLong: |
| case kFloat: |
| case kDouble: { |
| return (right.getSuperTypeID() == Type::kNumeric); |
| } |
| case kDate: { |
| return (right.getTypeID() == kYearMonthInterval); |
| } |
| case kDatetime: { |
| return (right.getTypeID() == kDatetime || |
| right.getTypeID() == kDatetimeInterval || |
| right.getTypeID() == kYearMonthInterval); |
| } |
| case kDatetimeInterval: { |
| return (right.getTypeID() == kDatetimeInterval); |
| } |
| case kYearMonthInterval: { |
| return (right.getTypeID() == kYearMonthInterval || |
| right.getTypeID() == kDate); |
| } |
| default: |
| return false; |
| } |
| } |
| |
| const Type* SubtractBinaryOperation::resultTypeForArgumentTypes(const Type &left, const Type &right) const { |
| if (left.getSuperTypeID() == Type::kNumeric && right.getSuperTypeID() == Type::kNumeric) { |
| return TypeFactory::GetUnifyingType(left, right); |
| } else if ((left.getTypeID() == kDate && right.getTypeID() == kYearMonthInterval)) { |
| // For DATE type, only one possibility: DATE - YEAR-MONTH-INTERVAL. |
| return &(DateType::Instance(left.isNullable() || right.isNullable())); |
| } else if ((left.getTypeID() == kDatetime && right.getTypeID() == kDatetime) || |
| (left.getTypeID() == kDatetimeInterval && right.getTypeID() == kDatetimeInterval)) { |
| // NOTE(zuyu): we set the result type of the Subtract |
| // between two Datetimes as DatetimeInterval, instead of YearMonthInterval. |
| return &(DatetimeIntervalType::Instance(left.isNullable() || right.isNullable())); |
| } else if (left.getTypeID() == kDatetime && right.getTypeID() == kDatetimeInterval) { |
| return &(DatetimeType::Instance(left.isNullable() || right.isNullable())); |
| } else if (left.getTypeID() == kDatetime && right.getTypeID() == kYearMonthInterval) { |
| return &(DatetimeType::Instance(left.isNullable() || right.isNullable())); |
| } else if (left.getTypeID() == kYearMonthInterval && right.getTypeID() == kYearMonthInterval) { |
| return &(YearMonthIntervalType::Instance(left.isNullable() || right.isNullable())); |
| } else { |
| return nullptr; |
| } |
| } |
| |
| const Type* SubtractBinaryOperation::resultTypeForPartialArgumentTypes( |
| const Type *left, |
| const Type *right) const { |
| if (left == nullptr) { |
| if (right == nullptr) { |
| return nullptr; |
| } else { |
| switch (right->getTypeID()) { |
| case kDouble: |
| // Double has highest precedence of numeric types. |
| return &TypeFactory::GetType(kDouble, true); |
| case kDatetime: |
| // If the subtrahend is Datetime, then the only allowed minuend is |
| // another Datetime, and the result is an interval. |
| return &TypeFactory::GetType(kDatetimeInterval, true); |
| default: |
| // Ambiguous or inapplicable. |
| return nullptr; |
| } |
| } |
| } else { |
| if (right == nullptr) { |
| switch (left->getTypeID()) { |
| case kDouble: |
| // Double has highest precedence of numeric types. |
| return &TypeFactory::GetType(kDouble, true); |
| case kDate: |
| // If left is a Date, right must be a YearMonthInterval and the result |
| // must be a Date. |
| return &TypeFactory::GetType(kDate, true); |
| case kDatetimeInterval: |
| // If minuend is a DatetimeInterval, the subtrahend and result must |
| // also be DatetimeInterval. |
| return &TypeFactory::GetType(kDatetimeInterval, true); |
| case kYearMonthInterval: |
| // Similarly, if minuend is a YearMonthInterval, the subtrahend and |
| // result must also be YearMonthInterval. |
| return &TypeFactory::GetType(kYearMonthInterval, true); |
| default: |
| // Ambiguous or inapplicable. |
| return nullptr; |
| } |
| } else { |
| return resultTypeForArgumentTypes(*left, *right); |
| } |
| } |
| } |
| |
| bool SubtractBinaryOperation::partialTypeSignatureIsPlausible( |
| const Type *result_type, |
| const Type *left_argument_type, |
| const Type *right_argument_type) const { |
| // Early check: if either argument type is nullable or unknown, result type |
| // must also be nullable. |
| if ((left_argument_type == nullptr) |
| || left_argument_type->isNullable() |
| || (right_argument_type == nullptr) |
| || right_argument_type->isNullable()) { |
| if ((result_type != nullptr) && (!result_type->isNullable())) { |
| return false; |
| } |
| } |
| |
| if (left_argument_type == nullptr) { |
| if (right_argument_type == nullptr) { |
| if (result_type == nullptr) { |
| // All types unknown. |
| return true; |
| } else { |
| // Only result type is known, just check that it is one of the types |
| // that can possibly be returned. |
| return QUICKSTEP_EQUALS_ANY_CONSTANT(result_type->getTypeID(), |
| kInt, |
| kLong, |
| kFloat, |
| kDouble, |
| kDate, |
| kDatetime, |
| kDatetimeInterval, |
| kYearMonthInterval); |
| } |
| } |
| |
| if (result_type == nullptr) { |
| // Right (minuend) argument type is known, left (subtrahend) argument and |
| // result types are unknown. Just check that right (minuend) type can be |
| // subtracted. |
| return QUICKSTEP_EQUALS_ANY_CONSTANT(right_argument_type->getTypeID(), |
| kInt, |
| kLong, |
| kFloat, |
| kDouble, |
| kDatetime, |
| kDatetimeInterval, |
| kYearMonthInterval); |
| } |
| |
| // Return type and right (minuend) argument type are known, left |
| // (subtrahend) argument type is unknown. Check that result and subtrahend |
| // are compatible. |
| switch (right_argument_type->getTypeID()) { |
| case kInt: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kInt, kLong, kFloat, kDouble); |
| case kLong: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kLong, kDouble); |
| case kFloat: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kFloat, kDouble); |
| case kDouble: |
| return (result_type->getTypeID() == kDouble); |
| case kDate: |
| return (result_type->getTypeID() == kDate); |
| case kDatetime: |
| return (result_type->getTypeID() == kDatetimeInterval); |
| case kDatetimeInterval: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kDatetime, kDatetimeInterval); |
| case kYearMonthInterval: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kDate, kDatetime, kYearMonthInterval); |
| default: |
| return false; |
| } |
| } else { // left_argument_type != nullptr |
| if (right_argument_type == nullptr) { |
| if (result_type == nullptr) { |
| // Left (subtrahend) argument type is known, right (minuend) argument |
| // type and result type are unknown. Just check that the left |
| // (subtrahend) type can be subtracted from. |
| return QUICKSTEP_EQUALS_ANY_CONSTANT(left_argument_type->getTypeID(), |
| kInt, |
| kLong, |
| kFloat, |
| kDouble, |
| kDate, |
| kDatetime, |
| kDatetimeInterval, |
| kYearMonthInterval); |
| } |
| |
| // Result type and left (subtrahend) argument type are known, but right |
| // (minuend) argument type is unknown. Check that result and minuend are |
| // compatible. |
| switch (left_argument_type->getTypeID()) { |
| case kInt: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kInt, kLong, kFloat, kDouble); |
| case kLong: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kLong, kDouble); |
| case kFloat: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kFloat, kDouble); |
| case kDouble: |
| return (result_type->getTypeID() == kDouble); |
| case kDate: |
| return (result_type->getTypeID() == kDate); |
| case kDatetime: |
| return QUICKSTEP_EQUALS_ANY_CONSTANT( |
| result_type->getTypeID(), |
| kDatetime, kDatetimeInterval); |
| case kDatetimeInterval: |
| return (result_type->getTypeID() == kDatetimeInterval); |
| case kYearMonthInterval: |
| return (result_type->getTypeID() == kYearMonthInterval); |
| default: |
| return false; |
| } |
| } |
| |
| // Left and right (subtrahend and minuend) argument types are both known. |
| const Type *actual_result_type = resultTypeForArgumentTypes(*left_argument_type, |
| *right_argument_type); |
| if (actual_result_type == nullptr) { |
| // Both argument Types are known, but this operation is NOT applicable to |
| // them. No matter what the result_type is, the signature is not |
| // plausible. |
| return false; |
| } else if (result_type == nullptr) { |
| return true; |
| } else { |
| // Check if result type matches. |
| return result_type->equals(*actual_result_type); |
| } |
| } |
| } |
| |
| std::pair<const Type*, const Type*> SubtractBinaryOperation::pushDownTypeHint( |
| const Type *result_type_hint) const { |
| if (result_type_hint == nullptr) { |
| return std::pair<const Type*, const Type*>(nullptr, nullptr); |
| } |
| |
| switch (result_type_hint->getTypeID()) { |
| case kInt: |
| case kLong: |
| case kFloat: |
| case kDouble: |
| case kYearMonthInterval: |
| return std::pair<const Type*, const Type*>(result_type_hint, result_type_hint); |
| case kDate: |
| // Left should be a Date, right should be YearMonthInterval. |
| return std::pair<const Type *, const Type *>( |
| result_type_hint, &TypeFactory::GetType(kYearMonthInterval, true)); |
| case kDatetime: |
| // Left should be a Datetime, right may be either interval type. |
| return std::pair<const Type*, const Type*>(result_type_hint, nullptr); |
| case kDatetimeInterval: |
| // Ambiguous: could be subtracting two Datetimes or two DatetimeIntervals. |
| return std::pair<const Type*, const Type*>(nullptr, nullptr); |
| default: |
| // Inapplicable. |
| return std::pair<const Type*, const Type*>(nullptr, nullptr); |
| } |
| } |
| |
| TypedValue SubtractBinaryOperation::applyToChecked(const TypedValue &left, |
| const Type &left_type, |
| const TypedValue &right, |
| const Type &right_type) const { |
| switch (left_type.getTypeID()) { |
| case kInt: |
| case kLong: |
| case kFloat: |
| case kDouble: { |
| if (right_type.getSuperTypeID() == Type::kNumeric) { |
| return applyToCheckedNumericHelper<SubtractFunctor>(left, left_type, |
| right, right_type); |
| } |
| break; |
| } |
| case kDate: { |
| if (right_type.getTypeID() == kYearMonthInterval) { |
| if (left.isNull() || right.isNull()) { |
| return TypedValue(kDate); |
| } |
| |
| return TypedValue(left.getLiteral<DateLit>() - right.getLiteral<YearMonthIntervalLit>()); |
| } |
| break; |
| } |
| case kDatetime: { |
| if (right_type.getTypeID() == kDatetime) { |
| // NOTE(zuyu): The result type of the Subtract between two Datetimes is DatetimeInterval, |
| // instead of YearMonthInterval. |
| if (left.isNull() || right.isNull()) { |
| return TypedValue(kDatetimeInterval); |
| } |
| |
| return TypedValue(left.getLiteral<DatetimeLit>() - right.getLiteral<DatetimeLit>()); |
| } else if (right_type.getTypeID() == kDatetimeInterval) { |
| if (left.isNull() || right.isNull()) { |
| return TypedValue(kDatetime); |
| } |
| |
| return TypedValue(left.getLiteral<DatetimeLit>() - right.getLiteral<DatetimeIntervalLit>()); |
| } else if (right_type.getTypeID() == kYearMonthInterval) { |
| if (left.isNull() || right.isNull()) { |
| return TypedValue(kDatetime); |
| } |
| |
| return TypedValue(left.getLiteral<DatetimeLit>() - right.getLiteral<YearMonthIntervalLit>()); |
| } |
| break; |
| } |
| case kDatetimeInterval: { |
| if (right_type.getTypeID() == kDatetimeInterval) { |
| if (left.isNull() || right.isNull()) { |
| return TypedValue(kDatetimeInterval); |
| } |
| |
| return TypedValue(left.getLiteral<DatetimeIntervalLit>() - right.getLiteral<DatetimeIntervalLit>()); |
| } |
| break; |
| } |
| case kYearMonthInterval: { |
| if (right_type.getTypeID() == kYearMonthInterval) { |
| if (left.isNull() || right.isNull()) { |
| return TypedValue(kYearMonthInterval); |
| } |
| |
| return TypedValue(left.getLiteral<YearMonthIntervalLit>() - right.getLiteral<YearMonthIntervalLit>()); |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| |
| LOG(FATAL) << "Can not apply " << getName() << " to arguments of types " |
| << left_type.getName() << " and " << right_type.getName(); |
| } |
| |
| UncheckedBinaryOperator* SubtractBinaryOperation::makeUncheckedBinaryOperatorForTypes(const Type &left, |
| const Type &right) const { |
| switch (left.getTypeID()) { |
| case kInt: |
| case kLong: |
| case kFloat: |
| case kDouble: { |
| if (right.getSuperTypeID() == Type::kNumeric) { |
| return makeNumericBinaryOperatorOuterHelper<SubtractArithmeticUncheckedBinaryOperator>(left, right); |
| } |
| break; |
| } |
| case kDate: { |
| if (right.getTypeID() == kYearMonthInterval) { |
| return makeDateBinaryOperatorOuterHelper< |
| SubtractArithmeticUncheckedBinaryOperator, |
| DateType, |
| DateLit, |
| YearMonthIntervalLit>(left, right); |
| } |
| break; |
| } |
| case kDatetime: { |
| if (right.getTypeID() == kDatetime) { |
| // NOTE(zuyu): The result type of the Subtract between two Datetimes is DatetimeInterval, |
| // instead of YearMonthInterval. |
| return makeDateBinaryOperatorOuterHelper<SubtractArithmeticUncheckedBinaryOperator, |
| DatetimeIntervalType, |
| DatetimeLit, DatetimeLit>(left, right); |
| } else if (right.getTypeID() == kDatetimeInterval) { |
| return makeDateBinaryOperatorOuterHelper<SubtractArithmeticUncheckedBinaryOperator, |
| DatetimeType, |
| DatetimeLit, DatetimeIntervalLit>(left, right); |
| } else if (right.getTypeID() == kYearMonthInterval) { |
| return makeDateBinaryOperatorOuterHelper<SubtractArithmeticUncheckedBinaryOperator, |
| DatetimeType, |
| DatetimeLit, YearMonthIntervalLit>(left, right); |
| } |
| break; |
| } |
| case kDatetimeInterval: { |
| if (right.getTypeID() == kDatetimeInterval) { |
| return makeDateBinaryOperatorOuterHelper<SubtractArithmeticUncheckedBinaryOperator, |
| DatetimeIntervalType, |
| DatetimeIntervalLit, DatetimeIntervalLit>(left, right); |
| } |
| break; |
| } |
| case kYearMonthInterval: { |
| if (right.getTypeID() == kYearMonthInterval) { |
| return makeDateBinaryOperatorOuterHelper<SubtractArithmeticUncheckedBinaryOperator, |
| YearMonthIntervalType, |
| YearMonthIntervalLit, YearMonthIntervalLit>(left, right); |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| |
| throw OperationInapplicableToType(getName(), 2, left.getName().c_str(), right.getName().c_str()); |
| } |
| |
| } // namespace quickstep |
