blob: 59dcb3e5525cb9ecd20cbf755bc88b675f81f2a4 [file] [log] [blame]
/**
* 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/DivideBinaryOperation.hpp"
#include <string>
#include <utility>
#include "types/DateOperatorOverloads.hpp"
#include "types/DatetimeIntervalType.hpp"
#include "types/DoubleType.hpp"
#include "types/FloatType.hpp"
#include "types/IntType.hpp"
#include "types/IntervalLit.hpp"
#include "types/LongType.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 DivideBinaryOperation::canApplyToTypes(const Type &left, const Type &right) const {
switch (left.getTypeID()) {
case kInt:
case kLong:
case kFloat:
case kDouble:
case kDatetimeInterval:
case kYearMonthInterval: {
return (right.getSuperTypeID() == Type::kNumeric);
}
default:
return false;
}
}
const Type* DivideBinaryOperation::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() == kDatetimeInterval && right.getSuperTypeID() == Type::kNumeric) {
return &(DatetimeIntervalType::Instance(left.isNullable() || right.isNullable()));
} else if (left.getTypeID() == kYearMonthInterval && right.getSuperTypeID() == Type::kNumeric) {
return &(YearMonthIntervalType::Instance(left.isNullable() || right.isNullable()));
} else {
return nullptr;
}
}
const Type* DivideBinaryOperation::resultTypeForPartialArgumentTypes(
const Type *left,
const Type *right) const {
if (left == nullptr) {
// Can't determine result type just based on right (divisor) type.
return nullptr;
} else if (right == nullptr) {
switch (left->getTypeID()) {
case kDouble:
// Double has highest precedence of numeric types.
return &TypeFactory::GetType(kDouble, true);
case kDatetimeInterval:
return &TypeFactory::GetType(kDatetimeInterval, true);
case kYearMonthInterval:
return &TypeFactory::GetType(kYearMonthInterval, true);
default:
// Ambiguous or inapplicable.
return nullptr;
}
} else {
return resultTypeForArgumentTypes(*left, *right);
}
}
bool DivideBinaryOperation::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, kDatetimeInterval, kYearMonthInterval);
}
}
if (result_type == nullptr) {
// Right (divisor) argument type is known, left (dividend) argument and
// result types are unknown. Just check that it is possible to divide by
// the right (divisor) type.
return QUICKSTEP_EQUALS_ANY_CONSTANT(
right_argument_type->getTypeID(),
kInt, kLong, kFloat, kDouble);
}
// Return type and right (divisor) argument type are known, left (dividend)
// argument type is unknown. Check that result and divisor are compatible.
switch (right_argument_type->getTypeID()) {
case kInt:
return QUICKSTEP_EQUALS_ANY_CONSTANT(
result_type->getTypeID(),
kInt, kLong, kFloat, kDouble, kDatetimeInterval, kYearMonthInterval);
case kLong:
return QUICKSTEP_EQUALS_ANY_CONSTANT(
result_type->getTypeID(),
kLong, kDouble, kDatetimeInterval, kYearMonthInterval);
case kFloat:
return QUICKSTEP_EQUALS_ANY_CONSTANT(
result_type->getTypeID(),
kFloat, kDouble, kDatetimeInterval, kYearMonthInterval);
case kDouble:
return QUICKSTEP_EQUALS_ANY_CONSTANT(
result_type->getTypeID(),
kDouble, kDatetimeInterval, kYearMonthInterval);
default:
return false;
}
} else { // left_argument_type != nullptr
if (right_argument_type == nullptr) {
if (result_type == nullptr) {
// Left (dividend) argument type is known, right (divisor) argument
// type and result type are unknown. Just check that the left
// (dividend) type can be divided.
return QUICKSTEP_EQUALS_ANY_CONSTANT(
left_argument_type->getTypeID(),
kInt, kLong, kFloat, kDouble, kDatetimeInterval, kYearMonthInterval);
}
// Result type and left (dividend) argument type are known, but right
// (divisor) argument type is unknown. Check that result and dividend 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 kDatetimeInterval:
return (result_type->getTypeID() == kDatetimeInterval);
case kYearMonthInterval:
return (result_type->getTypeID() == kYearMonthInterval);
default:
return false;
}
}
// Left and right (dividend and divisor) 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*> DivideBinaryOperation::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:
return std::pair<const Type*, const Type*>(result_type_hint, result_type_hint);
case kDatetimeInterval:
case kYearMonthInterval:
// Left (dividend) should be the same kind of interval as '*type_hint',
// right (divisor) can be any numeric type.
return std::pair<const Type*, const Type*>(result_type_hint, nullptr);
default:
// Inapplicable.
return std::pair<const Type*, const Type*>(nullptr, nullptr);
}
}
TypedValue DivideBinaryOperation::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<DivideFunctor>(left, left_type,
right, right_type);
}
break;
}
case kDatetimeInterval: {
switch (right_type.getTypeID()) {
case kInt:
if (left.isNull() || right.isNull()) {
return TypedValue(kDatetimeInterval);
}
return TypedValue(left.getLiteral<DatetimeIntervalLit>() / right.getLiteral<IntType::cpptype>());
case kLong:
if (left.isNull() || right.isNull()) {
return TypedValue(kDatetimeInterval);
}
return TypedValue(left.getLiteral<DatetimeIntervalLit>() / right.getLiteral<LongType::cpptype>());
case kFloat:
if (left.isNull() || right.isNull()) {
return TypedValue(kDatetimeInterval);
}
return TypedValue(left.getLiteral<DatetimeIntervalLit>() / right.getLiteral<FloatType::cpptype>());
case kDouble:
if (left.isNull() || right.isNull()) {
return TypedValue(kDatetimeInterval);
}
return TypedValue(left.getLiteral<DatetimeIntervalLit>() / right.getLiteral<DoubleType::cpptype>());
default:
break;
}
break;
}
case kYearMonthInterval: {
switch (right_type.getTypeID()) {
case kInt:
if (left.isNull() || right.isNull()) {
return TypedValue(kYearMonthInterval);
}
return TypedValue(left.getLiteral<YearMonthIntervalLit>() / right.getLiteral<IntType::cpptype>());
case kLong:
if (left.isNull() || right.isNull()) {
return TypedValue(kYearMonthInterval);
}
return TypedValue(left.getLiteral<YearMonthIntervalLit>() / right.getLiteral<LongType::cpptype>());
case kFloat:
if (left.isNull() || right.isNull()) {
return TypedValue(kYearMonthInterval);
}
return TypedValue(left.getLiteral<YearMonthIntervalLit>() / right.getLiteral<FloatType::cpptype>());
case kDouble:
if (left.isNull() || right.isNull()) {
return TypedValue(kYearMonthInterval);
}
return TypedValue(left.getLiteral<YearMonthIntervalLit>() / right.getLiteral<DoubleType::cpptype>());
default:
break;
}
break;
}
default:
break;
}
LOG(FATAL) << "Can not apply " << getName() << " to arguments of types "
<< left_type.getName() << " and " << right_type.getName();
}
UncheckedBinaryOperator* DivideBinaryOperation::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<DivideArithmeticUncheckedBinaryOperator>(left, right);
}
break;
}
case kDatetimeInterval: {
switch (right.getTypeID()) {
case kInt: {
return makeDateBinaryOperatorOuterHelper<DivideArithmeticUncheckedBinaryOperator,
DatetimeIntervalType,
DatetimeIntervalLit, IntType::cpptype>(left, right);
}
case kLong: {
return makeDateBinaryOperatorOuterHelper<DivideArithmeticUncheckedBinaryOperator,
DatetimeIntervalType,
DatetimeIntervalLit, LongType::cpptype>(left, right);
}
case kFloat: {
return makeDateBinaryOperatorOuterHelper<DivideArithmeticUncheckedBinaryOperator,
DatetimeIntervalType,
DatetimeIntervalLit, FloatType::cpptype>(left, right);
}
case kDouble: {
return makeDateBinaryOperatorOuterHelper<DivideArithmeticUncheckedBinaryOperator,
DatetimeIntervalType,
DatetimeIntervalLit, DoubleType::cpptype>(left, right);
}
default:
break;
}
break;
}
case kYearMonthInterval: {
switch (right.getTypeID()) {
case kInt: {
return makeDateBinaryOperatorOuterHelper<DivideArithmeticUncheckedBinaryOperator,
YearMonthIntervalType,
YearMonthIntervalLit, IntType::cpptype>(left, right);
}
case kLong: {
return makeDateBinaryOperatorOuterHelper<DivideArithmeticUncheckedBinaryOperator,
YearMonthIntervalType,
YearMonthIntervalLit, LongType::cpptype>(left, right);
}
case kFloat: {
return makeDateBinaryOperatorOuterHelper<DivideArithmeticUncheckedBinaryOperator,
YearMonthIntervalType,
YearMonthIntervalLit, FloatType::cpptype>(left, right);
}
case kDouble: {
return makeDateBinaryOperatorOuterHelper<DivideArithmeticUncheckedBinaryOperator,
YearMonthIntervalType,
YearMonthIntervalLit, DoubleType::cpptype>(left, right);
}
default:
break;
}
break;
}
default:
break;
}
throw OperationInapplicableToType(getName(), 2, left.getName().c_str(), right.getName().c_str());
}
} // namespace quickstep