Inheritance diagram for anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor:

Collaboration diagram for anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor:

Public Member Functions
	ConstantFoldingVisitor ()

int32_t	get_num_overflows ()

void	reset_num_overflows ()

Public Member Functions inherited from ScalarExprVisitor< std::shared_ptr< Analyzer::Expr > >
std::shared_ptr< Analyzer::Expr >	visit (const Analyzer::Expr *expr) const

Protected Attributes
bool	in_string_op_chain_ {false}

std::vector< std::shared_ptr < Analyzer::Expr > >	chained_string_op_exprs_

std::unordered_map< const Analyzer::Expr *, const SQLTypeInfo >	casts_

int32_t	num_overflows_

Private Member Functions
template<typename T >
bool	foldComparison (SQLOps optype, T t1, T t2) const

template<typename T >
bool	foldLogic (SQLOps optype, T t1, T t2) const

template<typename T >
T	foldArithmetic (SQLOps optype, T t1, T t2) const

bool	foldOper (SQLOps optype, SQLTypes type, Datum lhs, Datum rhs, Datum &result, SQLTypes &result_type) const

std::shared_ptr< Analyzer::Expr >	visitUOper (const Analyzer::UOper *uoper) const override

std::shared_ptr< Analyzer::Expr >	visitBinOper (const Analyzer::BinOper *bin_oper) const override

std::shared_ptr< Analyzer::Expr >	visitStringOper (const Analyzer::StringOper *string_oper) const override

Additional Inherited Members
Protected Types inherited from DeepCopyVisitor
using	RetType = std::shared_ptr< Analyzer::Expr >

Protected Member Functions inherited from DeepCopyVisitor
RetType	visitColumnVar (const Analyzer::ColumnVar *col_var) const override

RetType	visitColumnVarTuple (const Analyzer::ExpressionTuple *col_var_tuple) const override

RetType	visitVar (const Analyzer::Var *var) const override

RetType	visitConstant (const Analyzer::Constant *constant) const override

RetType	visitGeoExpr (const Analyzer::GeoExpr *geo_expr) const override

RetType	visitInValues (const Analyzer::InValues *in_values) const override

RetType	visitInIntegerSet (const Analyzer::InIntegerSet *in_integer_set) const override

RetType	visitCharLength (const Analyzer::CharLengthExpr *char_length) const override

RetType	visitKeyForString (const Analyzer::KeyForStringExpr *expr) const override

RetType	visitSampleRatio (const Analyzer::SampleRatioExpr *expr) const override

RetType	visitMLPredict (const Analyzer::MLPredictExpr *expr) const override

RetType	visitPCAProject (const Analyzer::PCAProjectExpr *expr) const override

RetType	visitCardinality (const Analyzer::CardinalityExpr *cardinality) const override

RetType	visitLikeExpr (const Analyzer::LikeExpr *like) const override

RetType	visitRegexpExpr (const Analyzer::RegexpExpr *regexp) const override

RetType	visitWidthBucket (const Analyzer::WidthBucketExpr *width_bucket_expr) const override

RetType	visitCaseExpr (const Analyzer::CaseExpr *case_expr) const override

RetType	visitDatetruncExpr (const Analyzer::DatetruncExpr *datetrunc) const override

RetType	visitExtractExpr (const Analyzer::ExtractExpr *extract) const override

RetType	visitArrayOper (const Analyzer::ArrayExpr *array_expr) const override

RetType	visitGeoUOper (const Analyzer::GeoUOper *geo_expr) const override

RetType	visitGeoBinOper (const Analyzer::GeoBinOper *geo_expr) const override

RetType	visitWindowFunction (const Analyzer::WindowFunction *window_func) const override

RetType	visitFunctionOper (const Analyzer::FunctionOper *func_oper) const override

RetType	visitDatediffExpr (const Analyzer::DatediffExpr *datediff) const override

RetType	visitDateaddExpr (const Analyzer::DateaddExpr *dateadd) const override

RetType	visitFunctionOperWithCustomTypeHandling (const Analyzer::FunctionOperWithCustomTypeHandling *func_oper) const override

RetType	visitLikelihood (const Analyzer::LikelihoodExpr *likelihood) const override

RetType	visitAggExpr (const Analyzer::AggExpr *agg) const override

RetType	visitOffsetInFragment (const Analyzer::OffsetInFragment *) const override

Protected Member Functions inherited from ScalarExprVisitor< std::shared_ptr< Analyzer::Expr > >
virtual std::shared_ptr < Analyzer::Expr >	visitRangeJoinOper (const Analyzer::RangeOper *range_oper) const

virtual std::shared_ptr < Analyzer::Expr >	aggregateResult (const std::shared_ptr< Analyzer::Expr > &aggregate, const std::shared_ptr< Analyzer::Expr > &next_result) const

virtual void	visitBegin () const

virtual std::shared_ptr < Analyzer::Expr >	defaultResult () const

Detailed Description

Definition at line 224 of file ExpressionRewrite.cpp.

Constructor & Destructor Documentation

anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::ConstantFoldingVisitor ( )

inline

Definition at line 760 of file ExpressionRewrite.cpp.

760 : num_overflows_(0) {}

anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::num_overflows_

int32_t num_overflows_

Definition: ExpressionRewrite.cpp:757

Member Function Documentation

template<typename T >

T anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::foldArithmetic	(	SQLOps	optype,
		T	t1,
		T	t2
	)		const

inlineprivate

Definition at line 264 of file ExpressionRewrite.cpp.

References kDIVIDE, kMINUS, kMULTIPLY, and kPLUS.

                                                     {
     bool t2_is_zero = (t2 == (t2 - t2));
     bool t2_is_negative = (t2 < (t2 - t2));
     switch (optype) {
       case kPLUS:
         // The MIN limit for float and double is the smallest representable value,
         // not the lowest negative value! Switching to C++11 lowest.
         if ((t2_is_negative && t1 < std::numeric_limits<T>::lowest() - t2) ||
             (!t2_is_negative && t1 > std::numeric_limits<T>::max() - t2)) {
           num_overflows_++;
           throw std::runtime_error("Plus overflow");
         }
         return t1 + t2;
       case kMINUS:
         if ((t2_is_negative && t1 > std::numeric_limits<T>::max() + t2) ||
             (!t2_is_negative && t1 < std::numeric_limits<T>::lowest() + t2)) {
           num_overflows_++;
           throw std::runtime_error("Minus overflow");
         }
         return t1 - t2;
       case kMULTIPLY: {
         if (t2_is_zero) {
           return t2;
         }
         auto ct1 = t1;
         auto ct2 = t2;
         // Need to keep t2's sign on the left
         if (t2_is_negative) {
           if (t1 == std::numeric_limits<T>::lowest() ||
               t2 == std::numeric_limits<T>::lowest()) {
             // negation could overflow - bail
             num_overflows_++;
             throw std::runtime_error("Mul neg overflow");
           }
           ct1 = -t1;  // ct1 gets t2's negativity
           ct2 = -t2;  // ct2 is now positive
         }
         // Don't check overlow if we are folding FP mul by a fraction
         bool ct2_is_fraction = (ct2 < (ct2 / ct2));
         if (!ct2_is_fraction) {
           if (ct1 > std::numeric_limits<T>::max() / ct2 ||
               ct1 < std::numeric_limits<T>::lowest() / ct2) {
             num_overflows_++;
             throw std::runtime_error("Mul overflow");
           }
         }
         return t1 * t2;
       }
       case kDIVIDE:
         if (t2_is_zero) {
           throw std::runtime_error("Will not fold division by zero");
         }
         return t1 / t2;
       default:
         break;
     }
     throw std::runtime_error("Unable to fold");
   }

template<typename T >

bool anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::foldComparison	(	SQLOps	optype,
		T	t1,
		T	t2
	)		const

inlineprivate

Definition at line 226 of file ExpressionRewrite.cpp.

References kEQ, kGE, kGT, kLE, kLT, and kNE.

                                                        {
     switch (optype) {
       case kEQ:
         return t1 == t2;
       case kNE:
         return t1 != t2;
       case kLT:
         return t1 < t2;
       case kLE:
         return t1 <= t2;
       case kGT:
         return t1 > t2;
       case kGE:
         return t1 >= t2;
       default:
         break;
     }
     throw std::runtime_error("Unable to fold");
     return false;
   }

template<typename T >

bool anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::foldLogic	(	SQLOps	optype,
		T	t1,
		T	t2
	)		const

inlineprivate

Definition at line 248 of file ExpressionRewrite.cpp.

References kAND, kNOT, and kOR.

                                                   {
     switch (optype) {
       case kAND:
         return t1 && t2;
       case kOR:
         return t1 || t2;
       case kNOT:
         return !t1;
       default:
         break;
     }
     throw std::runtime_error("Unable to fold");
     return false;
   }

bool anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::foldOper	(	SQLOps	optype,
		SQLTypes	type,
		Datum	lhs,
		Datum	rhs,
		Datum &	result,
		SQLTypes &	result_type
	)		const

inlineprivate

Definition at line 323 of file ExpressionRewrite.cpp.

References Datum::bigintval, Datum::boolval, CHECK, Datum::doubleval, Datum::floatval, Datum::intval, IS_ARITHMETIC, IS_COMPARISON, IS_LOGIC, kBIGINT, kBOOLEAN, kDOUBLE, kFLOAT, kINT, kSMALLINT, kTINYINT, Datum::smallintval, Datum::tinyintval, and run_benchmark_import::type.

                                              {
     result_type = type;
 
     try {
       switch (type) {
         case kBOOLEAN:
           if (IS_COMPARISON(optype)) {
             result.boolval = foldComparison<bool>(optype, lhs.boolval, rhs.boolval);
             result_type = kBOOLEAN;
             return true;
           }
           if (IS_LOGIC(optype)) {
             result.boolval = foldLogic<bool>(optype, lhs.boolval, rhs.boolval);
             result_type = kBOOLEAN;
             return true;
           }
           CHECK(!IS_ARITHMETIC(optype));
           break;
         case kTINYINT:
           if (IS_COMPARISON(optype)) {
             result.boolval =
                 foldComparison<int8_t>(optype, lhs.tinyintval, rhs.tinyintval);
             result_type = kBOOLEAN;
             return true;
           }
           if (IS_ARITHMETIC(optype)) {
             result.tinyintval =
                 foldArithmetic<int8_t>(optype, lhs.tinyintval, rhs.tinyintval);
             result_type = kTINYINT;
             return true;
           }
           CHECK(!IS_LOGIC(optype));
           break;
         case kSMALLINT:
           if (IS_COMPARISON(optype)) {
             result.boolval =
                 foldComparison<int16_t>(optype, lhs.smallintval, rhs.smallintval);
             result_type = kBOOLEAN;
             return true;
           }
           if (IS_ARITHMETIC(optype)) {
             result.smallintval =
                 foldArithmetic<int16_t>(optype, lhs.smallintval, rhs.smallintval);
             result_type = kSMALLINT;
             return true;
           }
           CHECK(!IS_LOGIC(optype));
           break;
         case kINT:
           if (IS_COMPARISON(optype)) {
             result.boolval = foldComparison<int32_t>(optype, lhs.intval, rhs.intval);
             result_type = kBOOLEAN;
             return true;
           }
           if (IS_ARITHMETIC(optype)) {
             result.intval = foldArithmetic<int32_t>(optype, lhs.intval, rhs.intval);
             result_type = kINT;
             return true;
           }
           CHECK(!IS_LOGIC(optype));
           break;
         case kBIGINT:
           if (IS_COMPARISON(optype)) {
             result.boolval =
                 foldComparison<int64_t>(optype, lhs.bigintval, rhs.bigintval);
             result_type = kBOOLEAN;
             return true;
           }
           if (IS_ARITHMETIC(optype)) {
             result.bigintval =
                 foldArithmetic<int64_t>(optype, lhs.bigintval, rhs.bigintval);
             result_type = kBIGINT;
             return true;
           }
           CHECK(!IS_LOGIC(optype));
           break;
         case kFLOAT:
           if (IS_COMPARISON(optype)) {
             result.boolval = foldComparison<float>(optype, lhs.floatval, rhs.floatval);
             result_type = kBOOLEAN;
             return true;
           }
           if (IS_ARITHMETIC(optype)) {
             result.floatval = foldArithmetic<float>(optype, lhs.floatval, rhs.floatval);
             result_type = kFLOAT;
             return true;
           }
           CHECK(!IS_LOGIC(optype));
           break;
         case kDOUBLE:
           if (IS_COMPARISON(optype)) {
             result.boolval = foldComparison<double>(optype, lhs.doubleval, rhs.doubleval);
             result_type = kBOOLEAN;
             return true;
           }
           if (IS_ARITHMETIC(optype)) {
             result.doubleval =
                 foldArithmetic<double>(optype, lhs.doubleval, rhs.doubleval);
             result_type = kDOUBLE;
             return true;
           }
           CHECK(!IS_LOGIC(optype));
           break;
         default:
           break;
       }
     } catch (...) {
       return false;
     }
     return false;
   }

int32_t anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::get_num_overflows ( )

inline

Definition at line 761 of file ExpressionRewrite.cpp.

761 { return num_overflows_; }

anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::num_overflows_

int32_t num_overflows_

Definition: ExpressionRewrite.cpp:757

void anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::reset_num_overflows ( )

inline

Definition at line 762 of file ExpressionRewrite.cpp.

762 { num_overflows_ = 0; }

anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::num_overflows_

int32_t num_overflows_

Definition: ExpressionRewrite.cpp:757

std::shared_ptr<Analyzer::Expr> anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitBinOper ( const Analyzer::BinOper * bin_oper ) const

inlineoverrideprivatevirtual

Reimplemented from DeepCopyVisitor.

Definition at line 520 of file ExpressionRewrite.cpp.

References Datum::boolval, CHECK, decimal_to_int_type(), f(), Analyzer::Expr::get_contains_agg(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_own_left_operand(), Analyzer::BinOper::get_own_right_operand(), Analyzer::BinOper::get_qualifier(), Analyzer::Expr::get_type_info(), IS_COMPARISON, SQLTypeInfo::is_decimal(), kAND, kBOOLEAN, kDIVIDE, kDOUBLE, kEQ, kFLOAT, kGE, kGT, kLE, kLT, kMINUS, kMULTIPLY, kNE, kOR, and kPLUS.

                                                       {
     const auto optype = bin_oper->get_optype();
     auto ti = bin_oper->get_type_info();
     auto left_operand = bin_oper->get_own_left_operand();
     auto right_operand = bin_oper->get_own_right_operand();
 
     // Check if bin_oper result is cast to a larger int or fp type
     if (casts_.find(bin_oper) != casts_.end()) {
       const auto cast_ti = casts_[bin_oper];
       const auto& lhs_ti = bin_oper->get_left_operand()->get_type_info();
       // Propagate cast down to the operands for folding
       if ((cast_ti.is_integer() || cast_ti.is_fp()) && lhs_ti.is_integer() &&
           cast_ti.get_size() > lhs_ti.get_size() &&
           (optype == kMINUS || optype == kPLUS || optype == kMULTIPLY)) {
         // Before folding, cast the operands to the bigger type to avoid overflows.
         // Currently upcasting smaller integer types to larger integers or double.
         left_operand = left_operand->deep_copy()->add_cast(cast_ti);
         right_operand = right_operand->deep_copy()->add_cast(cast_ti);
         ti = cast_ti;
       }
     }
 
     const auto lhs = visit(left_operand.get());
     const auto rhs = visit(right_operand.get());
 
     auto const_lhs = std::dynamic_pointer_cast<Analyzer::Constant>(lhs);
     auto const_rhs = std::dynamic_pointer_cast<Analyzer::Constant>(rhs);
     const auto& lhs_ti = lhs->get_type_info();
     const auto& rhs_ti = rhs->get_type_info();
     auto lhs_type = lhs_ti.is_decimal() ? decimal_to_int_type(lhs_ti) : lhs_ti.get_type();
     auto rhs_type = rhs_ti.is_decimal() ? decimal_to_int_type(rhs_ti) : rhs_ti.get_type();
 
     if (const_lhs && const_rhs && lhs_type == rhs_type) {
       auto lhs_datum = const_lhs->get_constval();
       auto rhs_datum = const_rhs->get_constval();
       Datum result_datum = {};
       SQLTypes result_type;
       if (foldOper(optype, lhs_type, lhs_datum, rhs_datum, result_datum, result_type)) {
         // Fold all ops that don't take in decimal operands, and also decimal comparisons
         if (!lhs_ti.is_decimal() || IS_COMPARISON(optype)) {
           return makeExpr<Analyzer::Constant>(result_type, false, result_datum);
         }
         // Decimal arithmetic has been done as kBIGINT. Selectively fold some decimal ops,
         // using result_datum and BinOper expr typeinfo which was adjusted for these ops.
         if (optype == kMINUS || optype == kPLUS || optype == kMULTIPLY) {
           return makeExpr<Analyzer::Constant>(ti, false, result_datum);
         }
       }
     }
 
     if (optype == kAND && lhs_type == rhs_type && lhs_type == kBOOLEAN) {
       if (const_rhs && !const_rhs->get_is_null()) {
         auto rhs_datum = const_rhs->get_constval();
         if (rhs_datum.boolval == false) {
           Datum d;
           d.boolval = false;
           // lhs && false --> false
           return makeExpr<Analyzer::Constant>(kBOOLEAN, false, d);
         }
         // lhs && true --> lhs
         return lhs;
       }
       if (const_lhs && !const_lhs->get_is_null()) {
         auto lhs_datum = const_lhs->get_constval();
         if (lhs_datum.boolval == false) {
           Datum d;
           d.boolval = false;
           // false && rhs --> false
           return makeExpr<Analyzer::Constant>(kBOOLEAN, false, d);
         }
         // true && rhs --> rhs
         return rhs;
       }
     }
     if (optype == kOR && lhs_type == rhs_type && lhs_type == kBOOLEAN) {
       if (const_rhs && !const_rhs->get_is_null()) {
         auto rhs_datum = const_rhs->get_constval();
         if (rhs_datum.boolval == true) {
           Datum d;
           d.boolval = true;
           // lhs || true --> true
           return makeExpr<Analyzer::Constant>(kBOOLEAN, false, d);
         }
         // lhs || false --> lhs
         return lhs;
       }
       if (const_lhs && !const_lhs->get_is_null()) {
         auto lhs_datum = const_lhs->get_constval();
         if (lhs_datum.boolval == true) {
           Datum d;
           d.boolval = true;
           // true || rhs --> true
           return makeExpr<Analyzer::Constant>(kBOOLEAN, false, d);
         }
         // false || rhs --> rhs
         return rhs;
       }
     }
     if (*lhs == *rhs) {
       if (!lhs_ti.get_notnull()) {
         CHECK(!rhs_ti.get_notnull());
         // We can't fold the ostensible tautaulogy
         // for nullable lhs and rhs types, as
         // lhs <> rhs when they are null
 
         // We likely could turn this into a lhs is not null
         // operatation, but is it worth it?
         return makeExpr<Analyzer::BinOper>(ti,
                                            bin_oper->get_contains_agg(),
                                            bin_oper->get_optype(),
                                            bin_oper->get_qualifier(),
                                            lhs,
                                            rhs);
       }
       CHECK(rhs_ti.get_notnull());
       // Tautologies: v=v; v<=v; v>=v
       if (optype == kEQ || optype == kLE || optype == kGE) {
         Datum d;
         d.boolval = true;
         return makeExpr<Analyzer::Constant>(kBOOLEAN, false, d);
       }
       // Contradictions: v!=v; v<v; v>v
       if (optype == kNE || optype == kLT || optype == kGT) {
         Datum d;
         d.boolval = false;
         return makeExpr<Analyzer::Constant>(kBOOLEAN, false, d);
       }
       // v-v
       if (optype == kMINUS) {
         Datum d = {};
         return makeExpr<Analyzer::Constant>(lhs_type, false, d);
       }
     }
     // Convert fp division by a constant to multiplication by 1/constant
     if (optype == kDIVIDE && const_rhs && rhs_ti.is_fp()) {
       auto rhs_datum = const_rhs->get_constval();
       std::shared_ptr<Analyzer::Expr> recip_rhs = nullptr;
       if (rhs_ti.get_type() == kFLOAT) {
         if (rhs_datum.floatval == 1.0) {
           return lhs;
         }
         auto f = std::fabs(rhs_datum.floatval);
         if (f > 1.0 || (f != 0.0 && 1.0 < f * std::numeric_limits<float>::max())) {
           rhs_datum.floatval = 1.0 / rhs_datum.floatval;
           recip_rhs = makeExpr<Analyzer::Constant>(rhs_type, false, rhs_datum);
         }
       } else if (rhs_ti.get_type() == kDOUBLE) {
         if (rhs_datum.doubleval == 1.0) {
           return lhs;
         }
         auto d = std::fabs(rhs_datum.doubleval);
         if (d > 1.0 || (d != 0.0 && 1.0 < d * std::numeric_limits<double>::max())) {
           rhs_datum.doubleval = 1.0 / rhs_datum.doubleval;
           recip_rhs = makeExpr<Analyzer::Constant>(rhs_type, false, rhs_datum);
         }
       }
       if (recip_rhs) {
         return makeExpr<Analyzer::BinOper>(ti,
                                            bin_oper->get_contains_agg(),
                                            kMULTIPLY,
                                            bin_oper->get_qualifier(),
                                            lhs,
                                            recip_rhs);
       }
     }
 
     return makeExpr<Analyzer::BinOper>(ti,
                                        bin_oper->get_contains_agg(),
                                        bin_oper->get_optype(),
                                        bin_oper->get_qualifier(),
                                        lhs,
                                        rhs);
   }

Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitStringOper ( const Analyzer::StringOper * string_oper ) const

inlineoverrideprivatevirtual

Reimplemented from DeepCopyVisitor.

Definition at line 695 of file ExpressionRewrite.cpp.

References Parser::StringLiteral::analyzeValue(), StringOps_Namespace::apply_numeric_op_to_literals(), StringOps_Namespace::apply_string_op_to_literals(), CHECK, Analyzer::StringOper::get_kind(), Analyzer::Expr::get_type_info(), Analyzer::StringOper::getArity(), Analyzer::StringOper::getLiteralArgs(), Analyzer::StringOper::getNonLiteralsArity(), Analyzer::StringOper::getOwnArgs(), and IsNullDatum().

                                                             {
     // Todo(todd): For clarity and modularity we should move string
     // operator rewrites into their own visitor class.
     // String operation rewrites were originally put here as they only
     // handled string operators on rewrite, but now handle variable
     // inputs as well.
     const auto original_args = string_oper->getOwnArgs();
     std::vector<std::shared_ptr<Analyzer::Expr>> rewritten_args;
     const auto non_literal_arity = string_oper->getNonLiteralsArity();
     const auto parent_in_string_op_chain = in_string_op_chain_;
     const auto in_string_op_chain = non_literal_arity <= 1UL;
     in_string_op_chain_ = in_string_op_chain;
 
     size_t rewritten_arg_literal_arity = 0;
     for (auto original_arg : original_args) {
       rewritten_args.emplace_back(visit(original_arg.get()));
       if (dynamic_cast<const Analyzer::Constant*>(rewritten_args.back().get())) {
         rewritten_arg_literal_arity++;
       }
     }
     in_string_op_chain_ = parent_in_string_op_chain;
     const auto kind = string_oper->get_kind();
     const auto& return_ti = string_oper->get_type_info();
 
     if (string_oper->getArity() == rewritten_arg_literal_arity) {
       Analyzer::StringOper literal_string_oper(
           kind, string_oper->get_type_info(), rewritten_args);
       const auto literal_args = literal_string_oper.getLiteralArgs();
       const auto string_op_info =
           StringOps_Namespace::StringOpInfo(kind, return_ti, literal_args);
       if (return_ti.is_string()) {
         const auto literal_result =
             StringOps_Namespace::apply_string_op_to_literals(string_op_info);
         return Parser::StringLiteral::analyzeValue(literal_result.first,
                                                    literal_result.second);
       }
       const auto literal_datum =
           StringOps_Namespace::apply_numeric_op_to_literals(string_op_info);
       auto nullable_return_ti = return_ti;
       nullable_return_ti.set_notnull(false);
       return makeExpr<Analyzer::Constant>(nullable_return_ti,
                                           IsNullDatum(literal_datum, nullable_return_ti),
                                           literal_datum);
     }
     chained_string_op_exprs_.emplace_back(
         makeExpr<Analyzer::StringOper>(kind, return_ti, rewritten_args));
     if (parent_in_string_op_chain && in_string_op_chain) {
       CHECK(rewritten_args[0]->get_type_info().is_string());
       return rewritten_args[0]->deep_copy();
     } else {
       auto new_string_oper = makeExpr<Analyzer::StringOper>(
           kind, return_ti, rewritten_args, chained_string_op_exprs_);
       chained_string_op_exprs_.clear();
       return new_string_oper;
     }
   }

Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitUOper ( const Analyzer::UOper * uoper ) const

inlineoverrideprivatevirtual

Reimplemented from DeepCopyVisitor.

Definition at line 440 of file ExpressionRewrite.cpp.

References CHECK_EQ, decimal_to_int_type(), Analyzer::Constant::get_constval(), Analyzer::Expr::get_contains_agg(), Analyzer::UOper::get_operand(), Analyzer::UOper::get_optype(), Analyzer::Expr::get_type_info(), kBOOLEAN, kCAST, kEQ, kMINUS, kNOT, and kUMINUS.

                                                  {
     const auto unvisited_operand = uoper->get_operand();
     const auto optype = uoper->get_optype();
     const auto& ti = uoper->get_type_info();
     if (optype == kCAST) {
       // Cache the cast type so it could be used in operand rewriting/folding
       casts_.insert({unvisited_operand, ti});
     }
     const auto operand = visit(unvisited_operand);
 
     const auto& operand_ti = operand->get_type_info();
     const auto operand_type =
         operand_ti.is_decimal() ? decimal_to_int_type(operand_ti) : operand_ti.get_type();
     const auto const_operand =
         std::dynamic_pointer_cast<const Analyzer::Constant>(operand);
 
     if (const_operand) {
       const auto operand_datum = const_operand->get_constval();
       Datum zero_datum = {};
       Datum result_datum = {};
       SQLTypes result_type;
       switch (optype) {
         case kNOT: {
           if (foldOper(kEQ,
                        operand_type,
                        zero_datum,
                        operand_datum,
                        result_datum,
                        result_type)) {
             CHECK_EQ(result_type, kBOOLEAN);
             return makeExpr<Analyzer::Constant>(result_type, false, result_datum);
           }
           break;
         }
         case kUMINUS: {
           if (foldOper(kMINUS,
                        operand_type,
                        zero_datum,
                        operand_datum,
                        result_datum,
                        result_type)) {
             if (!operand_ti.is_decimal()) {
               return makeExpr<Analyzer::Constant>(result_type, false, result_datum);
             }
             return makeExpr<Analyzer::Constant>(ti, false, result_datum);
           }
           break;
         }
         case kCAST: {
           // Trying to fold number to number casts only
           if (!ti.is_number() || !operand_ti.is_number()) {
             break;
           }
           // Disallowing folding of FP to DECIMAL casts for now:
           // allowing them would make this test pass:
           //    update dectest set d=cast( 1234.0 as float );
           // which is expected to throw in Update.ImplicitCastToNumericTypes
           // due to cast codegen currently not supporting these casts
           if (ti.is_decimal() && operand_ti.is_fp()) {
             break;
           }
           auto operand_copy = const_operand->deep_copy();
           auto cast_operand = operand_copy->add_cast(ti);
           auto const_cast_operand =
               std::dynamic_pointer_cast<const Analyzer::Constant>(cast_operand);
           if (const_cast_operand) {
             auto const_cast_datum = const_cast_operand->get_constval();
             return makeExpr<Analyzer::Constant>(ti, false, const_cast_datum);
           }
         }
         default:
           break;
       }
     }
 
     return makeExpr<Analyzer::UOper>(
         uoper->get_type_info(), uoper->get_contains_agg(), optype, operand);
   }

Here is the call graph for this function:

Member Data Documentation

std::unordered_map<const Analyzer::Expr*, const SQLTypeInfo> anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::casts_

mutableprotected

Definition at line 756 of file ExpressionRewrite.cpp.

std::vector<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::chained_string_op_exprs_

mutableprotected

Definition at line 755 of file ExpressionRewrite.cpp.

bool anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::in_string_op_chain_ {false}

mutableprotected

Definition at line 754 of file ExpressionRewrite.cpp.

int32_t anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::num_overflows_

mutableprotected

Definition at line 757 of file ExpressionRewrite.cpp.

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ExpressionRewrite.cpp

Public Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation