#include <Analyzer.h>

Inheritance diagram for Analyzer::Constant:

Collaboration diagram for Analyzer::Constant:

Public Member Functions
	Constant (SQLTypes t, bool n)

	Constant (SQLTypes t, bool n, Datum v)

	Constant (const SQLTypeInfo &ti, bool n, Datum v)

	Constant (const SQLTypeInfo &ti, bool n, const std::list< std::shared_ptr< Analyzer::Expr >> &l)

	~Constant () override

bool	get_is_null () const

Datum	get_constval () const

void	set_constval (Datum d)

const std::list < std::shared_ptr < Analyzer::Expr > > &	get_value_list () const

std::shared_ptr< Analyzer::Expr >	deep_copy () const override

std::shared_ptr< Analyzer::Expr >	add_cast (const SQLTypeInfo &new_type_info) override

bool	operator== (const Expr &rhs) const override

std::string	toString () const override

Public Member Functions inherited from Analyzer::Expr
	Expr (SQLTypes t, bool notnull)

	Expr (SQLTypes t, int d, bool notnull)

	Expr (SQLTypes t, int d, int s, bool notnull)

	Expr (const SQLTypeInfo &ti, bool has_agg=false)

virtual	~Expr ()

std::shared_ptr< Analyzer::Expr >	get_shared_ptr ()

const SQLTypeInfo &	get_type_info () const

void	set_type_info (const SQLTypeInfo &ti)

bool	get_contains_agg () const

void	set_contains_agg (bool a)

virtual void	check_group_by (const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const

virtual std::shared_ptr < Analyzer::Expr >	normalize_simple_predicate (int &rte_idx) const

virtual void	group_predicates (std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const

virtual void	collect_rte_idx (std::set< int > &rte_idx_set) const

virtual void	collect_column_var (std::set< const ColumnVar , bool()(const ColumnVar , const ColumnVar )> &colvar_set, bool include_agg) const

virtual std::shared_ptr < Analyzer::Expr >	rewrite_with_targetlist (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const

virtual std::shared_ptr < Analyzer::Expr >	rewrite_with_child_targetlist (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const

virtual std::shared_ptr < Analyzer::Expr >	rewrite_agg_to_var (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const

virtual void	print () const

virtual void	add_unique (std::list< const Expr * > &expr_list) const

virtual void	find_expr (bool(f)(const Expr ), std::list< const Expr * > &expr_list) const

std::shared_ptr< Analyzer::Expr >	decompress ()

virtual void	get_domain (DomainSet &domain_set) const

Private Member Functions
void	cast_number (const SQLTypeInfo &new_type_info)

void	cast_string (const SQLTypeInfo &new_type_info)

void	cast_from_string (const SQLTypeInfo &new_type_info)

void	cast_to_string (const SQLTypeInfo &new_type_info)

void	do_cast (const SQLTypeInfo &new_type_info)

void	set_null_value ()

Private Attributes
bool	is_null

Datum	constval

const std::list < std::shared_ptr < Analyzer::Expr > >	value_list

Additional Inherited Members
Protected Attributes inherited from Analyzer::Expr
SQLTypeInfo	type_info

bool	contains_agg

Detailed Description

Definition at line 307 of file Analyzer.h.

Constructor & Destructor Documentation

Analyzer::Constant::Constant	(	SQLTypes	t,
		bool	n
	)

inline

Definition at line 309 of file Analyzer.h.

References SQLTypeInfo::set_notnull(), set_null_value(), and Analyzer::Expr::type_info.

                                : Expr(t, !n), is_null(n) {
     if (n) {
       set_null_value();
     } else {
       type_info.set_notnull(true);
     }
   }

Here is the call graph for this function:

Analyzer::Constant::Constant	(	SQLTypes	t,
		bool	n,
		Datum	v
	)

inline

Definition at line 316 of file Analyzer.h.

References SQLTypeInfo::set_notnull(), set_null_value(), and Analyzer::Expr::type_info.

                                         : Expr(t, !n), is_null(n), constval(v) {
     if (n) {
       set_null_value();
     } else {
       type_info.set_notnull(true);
     }
   }

Here is the call graph for this function:

Analyzer::Constant::Constant	(	const SQLTypeInfo &	ti,
		bool	n,
		Datum	v
	)

inline

Definition at line 323 of file Analyzer.h.

References SQLTypeInfo::set_notnull(), set_null_value(), and Analyzer::Expr::type_info.

                                                    : Expr(ti), is_null(n), constval(v) {
     if (n) {
       set_null_value();
     } else {
       type_info.set_notnull(true);
     }
   }

Here is the call graph for this function:

Analyzer::Constant::Constant	(	const SQLTypeInfo &	ti,
		bool	n,
		const std::list< std::shared_ptr< Analyzer::Expr >> &	l
	)

inline

Definition at line 330 of file Analyzer.h.

333 : Expr(ti), is_null(n), constval(Datum{0}), value_list(l) {}

Analyzer::Expr::Expr

Expr(SQLTypes t, bool notnull)

Definition: Analyzer.h:70

Analyzer::Constant::constval

Datum constval

Definition: Analyzer.h:348

Analyzer::Constant::value_list

const std::list< std::shared_ptr< Analyzer::Expr > > value_list

Definition: Analyzer.h:349

Analyzer::Constant::is_null

bool is_null

Definition: Analyzer.h:347

Datum

Definition: sqltypes.h:132

Constant::~Constant ( )

override

Definition at line 41 of file Analyzer.cpp.

References constval, SQLTypeInfo::is_geometry(), is_null, SQLTypeInfo::is_string(), Datum::stringval, and Analyzer::Expr::type_info.

                     {
   if ((type_info.is_string() || type_info.is_geometry()) && !is_null) {
     delete constval.stringval;
   }
 }

Here is the call graph for this function:

Member Function Documentation

std::shared_ptr< Analyzer::Expr > Constant::add_cast ( const SQLTypeInfo & new_type_info )

overridevirtual

Reimplemented from Analyzer::Expr.

Definition at line 1261 of file Analyzer.cpp.

References Analyzer::Expr::add_cast(), Analyzer::Expr::contains_agg, do_cast(), SQLTypeInfo::get_compression(), SQLTypeInfo::is_date(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_integer(), is_null, SQLTypeInfo::is_time(), kCAST, kENCODING_DATE_IN_DAYS, kENCODING_NONE, SQLTypeInfo::set_compression(), set_null_value(), and Analyzer::Expr::type_info.

                                                                                {
   if (is_null) {
     type_info = new_type_info;
     set_null_value();
     return shared_from_this();
   }
   if (new_type_info.get_compression() != type_info.get_compression()) {
     if (new_type_info.get_compression() != kENCODING_NONE) {
       SQLTypeInfo new_ti = new_type_info;
       if (new_ti.get_compression() != kENCODING_DATE_IN_DAYS) {
         new_ti.set_compression(kENCODING_NONE);
       }
       do_cast(new_ti);
     }
     return Expr::add_cast(new_type_info);
   }
   const auto is_integral_type =
       new_type_info.is_integer() || new_type_info.is_decimal() || new_type_info.is_fp();
   if (is_integral_type && (type_info.is_time() || type_info.is_date())) {
     // Let the codegen phase deal with casts from date/time to a number.
     return makeExpr<UOper>(new_type_info, contains_agg, kCAST, shared_from_this());
   }
   do_cast(new_type_info);
   return shared_from_this();
 }

Here is the call graph for this function:

void Constant::cast_from_string ( const SQLTypeInfo & new_type_info )

private

Definition at line 1063 of file Analyzer.cpp.

References constval, StringToDatum(), Datum::stringval, and Analyzer::Expr::type_info.

Referenced by do_cast().

                                                                 {
   std::string* s = constval.stringval;
   SQLTypeInfo ti = new_type_info;
   constval = StringToDatum(*s, ti);
   delete s;
   type_info = new_type_info;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Constant::cast_number ( const SQLTypeInfo & new_type_info )

private

Definition at line 757 of file Analyzer.cpp.

References Datum::bigintval, Datum::boolval, CHECK(), constval, convert_decimal_value_to_scale(), Analyzer::anonymous_namespace{Analyzer.cpp}::decimal_to_int_frac(), Datum::doubleval, Datum::floatval, SQLTypeInfo::get_scale(), SQLTypeInfo::get_type(), Datum::intval, kBIGINT, kBOOLEAN, kDECIMAL, kDOUBLE, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTIMESTAMP, kTINYINT, Datum::smallintval, Datum::tinyintval, and Analyzer::Expr::type_info.

Referenced by do_cast().

                                                            {
   switch (type_info.get_type()) {
     case kTINYINT:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           break;
         case kINT:
           constval.intval = (int32_t)constval.tinyintval;
           break;
         case kSMALLINT:
           constval.smallintval = (int16_t)constval.tinyintval;
           break;
         case kBIGINT:
           constval.bigintval = (int64_t)constval.tinyintval;
           break;
         case kDOUBLE:
           constval.doubleval = (double)constval.tinyintval;
           break;
         case kFLOAT:
           constval.floatval = (float)constval.tinyintval;
           break;
         case kNUMERIC:
         case kDECIMAL:
           constval.bigintval = (int64_t)constval.tinyintval;
           for (int i = 0; i < new_type_info.get_scale(); i++) {
             constval.bigintval *= 10;
           }
           break;
         default:
           CHECK(false);
       }
       break;
     case kINT:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           constval.tinyintval = safe_narrow<int8_t>(constval.intval);
           break;
         case kINT:
           break;
         case kSMALLINT:
           constval.smallintval = safe_narrow<int16_t>(constval.intval);
           break;
         case kBIGINT:
           constval.bigintval = (int64_t)constval.intval;
           break;
         case kDOUBLE:
           constval.doubleval = (double)constval.intval;
           break;
         case kFLOAT:
           constval.floatval = (float)constval.intval;
           break;
         case kNUMERIC:
         case kDECIMAL:
           constval.bigintval = (int64_t)constval.intval;
           for (int i = 0; i < new_type_info.get_scale(); i++) {
             constval.bigintval *= 10;
           }
           break;
         default:
           CHECK(false);
       }
       break;
     case kSMALLINT:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           constval.tinyintval = safe_narrow<int8_t>(constval.smallintval);
           break;
         case kINT:
           constval.intval = (int32_t)constval.smallintval;
           break;
         case kSMALLINT:
           break;
         case kBIGINT:
           constval.bigintval = (int64_t)constval.smallintval;
           break;
         case kDOUBLE:
           constval.doubleval = (double)constval.smallintval;
           break;
         case kFLOAT:
           constval.floatval = (float)constval.smallintval;
           break;
         case kNUMERIC:
         case kDECIMAL:
           constval.bigintval = (int64_t)constval.smallintval;
           for (int i = 0; i < new_type_info.get_scale(); i++) {
             constval.bigintval *= 10;
           }
           break;
         default:
           CHECK(false);
       }
       break;
     case kBIGINT:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           constval.tinyintval = safe_narrow<int8_t>(constval.bigintval);
           break;
         case kINT:
           constval.intval = safe_narrow<int32_t>(constval.bigintval);
           break;
         case kSMALLINT:
           constval.smallintval = safe_narrow<int16_t>(constval.bigintval);
           break;
         case kBIGINT:
           break;
         case kDOUBLE:
           constval.doubleval = (double)constval.bigintval;
           break;
         case kFLOAT:
           constval.floatval = (float)constval.bigintval;
           break;
         case kNUMERIC:
         case kDECIMAL:
           for (int i = 0; i < new_type_info.get_scale(); i++) {
             constval.bigintval *= 10;
           }
           break;
         default:
           CHECK(false);
       }
       break;
     case kDOUBLE:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           constval.tinyintval = (int8_t)constval.doubleval;
           break;
         case kINT:
           constval.intval = (int32_t)constval.doubleval;
           break;
         case kSMALLINT:
           constval.smallintval = (int16_t)constval.doubleval;
           break;
         case kBIGINT:
           constval.bigintval = (int64_t)constval.doubleval;
           break;
         case kDOUBLE:
           break;
         case kFLOAT:
           constval.floatval = (float)constval.doubleval;
           break;
         case kNUMERIC:
         case kDECIMAL:
           for (int i = 0; i < new_type_info.get_scale(); i++) {
             constval.doubleval *= 10;
           }
           constval.bigintval = (int64_t)constval.doubleval;
           break;
         default:
           CHECK(false);
       }
       break;
     case kFLOAT:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           constval.tinyintval = (int8_t)constval.floatval;
           break;
         case kINT:
           constval.intval = (int32_t)constval.floatval;
           break;
         case kSMALLINT:
           constval.smallintval = (int16_t)constval.floatval;
           break;
         case kBIGINT:
           constval.bigintval = (int64_t)constval.floatval;
           break;
         case kDOUBLE:
           constval.doubleval = (double)constval.floatval;
           break;
         case kFLOAT:
           break;
         case kNUMERIC:
         case kDECIMAL:
           for (int i = 0; i < new_type_info.get_scale(); i++) {
             constval.floatval *= 10;
           }
           constval.bigintval = (int64_t)constval.floatval;
           break;
         default:
           CHECK(false);
       }
       break;
     case kNUMERIC:
     case kDECIMAL:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           for (int i = 0; i < type_info.get_scale(); i++) {
             constval.bigintval /= 10;
           }
           constval.tinyintval = safe_narrow<int8_t>(constval.bigintval);
           break;
         case kINT:
           for (int i = 0; i < type_info.get_scale(); i++) {
             constval.bigintval /= 10;
           }
           constval.intval = safe_narrow<int32_t>(constval.bigintval);
           break;
         case kSMALLINT:
           for (int i = 0; i < type_info.get_scale(); i++) {
             constval.bigintval /= 10;
           }
           constval.smallintval = (int16_t)constval.bigintval;
           break;
         case kBIGINT:
           for (int i = 0; i < type_info.get_scale(); i++) {
             constval.bigintval /= 10;
           }
           break;
         case kDOUBLE: {
           const auto int_frac = decimal_to_int_frac(constval.bigintval, type_info);
           constval.doubleval = int_frac.integral +
                                static_cast<double>(int_frac.fractional) / int_frac.scale;
           break;
         }
         case kFLOAT: {
           const auto int_frac = decimal_to_int_frac(constval.bigintval, type_info);
           constval.floatval = int_frac.integral +
                               static_cast<double>(int_frac.fractional) / int_frac.scale;
           break;
         }
         case kNUMERIC:
         case kDECIMAL:
           constval.bigintval = convert_decimal_value_to_scale(
               constval.bigintval, type_info, new_type_info);
           break;
         default:
           CHECK(false);
       }
       break;
     case kTIMESTAMP:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           constval.tinyintval = static_cast<int8_t>(constval.bigintval);
           break;
         case kINT:
           constval.intval = static_cast<int32_t>(constval.bigintval);
           break;
         case kSMALLINT:
           constval.smallintval = static_cast<int16_t>(constval.bigintval);
           break;
         case kBIGINT:
           constval.bigintval = static_cast<int64_t>(constval.bigintval);
           break;
         case kDOUBLE:
           constval.doubleval = static_cast<double>(constval.bigintval);
           break;
         case kFLOAT:
           constval.floatval = static_cast<float>(constval.bigintval);
           break;
         case kNUMERIC:
         case kDECIMAL:
           for (int i = 0; i < new_type_info.get_scale(); i++) {
             constval.bigintval *= 10;
           }
           break;
         default:
           CHECK(false);
       }
       break;
     case kBOOLEAN:
       switch (new_type_info.get_type()) {
         case kTINYINT:
           constval.tinyintval = constval.boolval ? 1 : 0;
           break;
         case kINT:
           constval.intval = constval.boolval ? 1 : 0;
           break;
         case kSMALLINT:
           constval.smallintval = constval.boolval ? 1 : 0;
           break;
         case kBIGINT:
           constval.bigintval = constval.boolval ? 1 : 0;
           break;
         case kDOUBLE:
           constval.doubleval = constval.boolval ? 1 : 0;
           break;
         case kFLOAT:
           constval.floatval = constval.boolval ? 1 : 0;
           break;
         case kNUMERIC:
         case kDECIMAL:
           constval.bigintval = constval.boolval ? 1 : 0;
           for (int i = 0; i < new_type_info.get_scale(); i++) {
             constval.bigintval *= 10;
           }
           break;
         default:
           CHECK(false);
       }
       break;
     default:
       CHECK(false);
   }
   type_info = new_type_info;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Constant::cast_string ( const SQLTypeInfo & new_type_info )

private

Definition at line 1052 of file Analyzer.cpp.

References constval, SQLTypeInfo::get_dimension(), SQLTypeInfo::get_type(), kTEXT, Datum::stringval, and Analyzer::Expr::type_info.

Referenced by do_cast().

                                                            {
   std::string* s = constval.stringval;
   if (s != nullptr && new_type_info.get_type() != kTEXT &&
       static_cast<size_t>(new_type_info.get_dimension()) < s->length()) {
     // truncate string
     constval.stringval = new std::string(s->substr(0, new_type_info.get_dimension()));
     delete s;
   }
   type_info = new_type_info;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Constant::cast_to_string ( const SQLTypeInfo & new_type_info )

private

Definition at line 1071 of file Analyzer.cpp.

References constval, DatumToString(), SQLTypeInfo::get_dimension(), SQLTypeInfo::get_type(), kTEXT, Datum::stringval, and Analyzer::Expr::type_info.

Referenced by do_cast().

                                                               {
   const auto str_val = DatumToString(constval, type_info);
   constval.stringval = new std::string(str_val);
   if (str_type_info.get_type() != kTEXT &&
       constval.stringval->length() > static_cast<size_t>(str_type_info.get_dimension())) {
     // truncate the string
     *constval.stringval = constval.stringval->substr(0, str_type_info.get_dimension());
   }
   type_info = str_type_info;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Analyzer::Expr > Constant::deep_copy ( ) const

overridevirtual

Implements Analyzer::Expr.

Definition at line 84 of file Analyzer.cpp.

References constval, SQLTypeInfo::get_type(), SQLTypeInfo::is_geometry(), is_null, SQLTypeInfo::is_string(), kARRAY, Datum::stringval, Analyzer::Expr::type_info, and value_list.

Referenced by DeepCopyVisitor::visitConstant().

                                                       {
   Datum d = constval;
   if ((type_info.is_string() || type_info.is_geometry()) && !is_null) {
     d.stringval = new std::string(*constval.stringval);
   }
   if (type_info.get_type() == kARRAY) {
     return makeExpr<Constant>(type_info, is_null, value_list);
   }
   return makeExpr<Constant>(type_info, is_null, d);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Constant::do_cast ( const SQLTypeInfo & new_type_info )

private

Definition at line 1132 of file Analyzer.cpp.

References Datum::bigintval, cast_from_string(), cast_number(), cast_string(), cast_to_string(), CHECK(), constval, DateTruncate(), DateTruncateHighPrecisionToDate(), dtDAY, DateTimeUtils::get_datetime_scaled_epoch(), SQLTypeInfo::get_dimension(), SQLTypeInfo::get_elem_type(), get_is_null(), SQLTypeInfo::get_notnull(), get_nullable_type_info(), DateTimeUtils::get_timestamp_precision_scale(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), SQLTypeInfo::is_array(), SQLTypeInfo::is_boolean(), SQLTypeInfo::is_geometry(), SQLTypeInfo::is_high_precision_timestamp(), is_null, Analyzer::anonymous_namespace{Analyzer.cpp}::is_null_value(), SQLTypeInfo::is_number(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), kBOOLEAN, kDATE, kTIMESTAMP, kVARCHAR, DateTimeUtils::ScaleDown, DateTimeUtils::ScaleUp, set_null_value(), Analyzer::Expr::type_info, and value_list.

Referenced by add_cast().

                                                        {
   if (type_info == new_type_info) {
     return;
   }
   if (is_null && !new_type_info.get_notnull()) {
     type_info = new_type_info;
     set_null_value();
     return;
   }
   if (new_type_info.is_number() &&
       (type_info.is_number() || type_info.get_type() == kTIMESTAMP ||
        type_info.get_type() == kBOOLEAN)) {
     cast_number(new_type_info);
   } else if (new_type_info.is_geometry() && type_info.is_string()) {
     type_info = new_type_info;
   } else if (new_type_info.is_geometry() &&
              type_info.get_type() == new_type_info.get_type()) {
     type_info = new_type_info;
   } else if (new_type_info.is_boolean() && type_info.is_boolean()) {
     type_info = new_type_info;
   } else if (new_type_info.is_string() && type_info.is_string()) {
     cast_string(new_type_info);
   } else if (type_info.is_string() || type_info.get_type() == kVARCHAR) {
     cast_from_string(new_type_info);
   } else if (new_type_info.is_string()) {
     cast_to_string(new_type_info);
   } else if (new_type_info.get_type() == kDATE && type_info.get_type() == kDATE) {
     type_info = new_type_info;
   } else if (new_type_info.get_type() == kDATE && type_info.get_type() == kTIMESTAMP) {
     constval.bigintval =
         type_info.is_high_precision_timestamp()
             ? DateTruncateHighPrecisionToDate(
                   constval.bigintval,
                   DateTimeUtils::get_timestamp_precision_scale(type_info.get_dimension()))
             : DateTruncate(dtDAY, constval.bigintval);
     type_info = new_type_info;
   } else if ((type_info.get_type() == kTIMESTAMP || type_info.get_type() == kDATE) &&
              new_type_info.get_type() == kTIMESTAMP) {
     const auto dimen = (type_info.get_type() == kDATE) ? 0 : type_info.get_dimension();
     if (dimen != new_type_info.get_dimension()) {
       constval.bigintval = dimen < new_type_info.get_dimension()
                                ? DateTimeUtils::get_datetime_scaled_epoch(
                                      DateTimeUtils::ScalingType::ScaleUp,
                                      constval.bigintval,
                                      new_type_info.get_dimension() - dimen)
                                : DateTimeUtils::get_datetime_scaled_epoch(
                                      DateTimeUtils::ScalingType::ScaleDown,
                                      constval.bigintval,
                                      dimen - new_type_info.get_dimension());
     }
     type_info = new_type_info;
   } else if (new_type_info.is_array() && type_info.is_array()) {
     auto new_sub_ti = new_type_info.get_elem_type();
     for (auto& v : value_list) {
       auto c = std::dynamic_pointer_cast<Analyzer::Constant>(v);
       if (!c) {
         throw std::runtime_error("Invalid array cast.");
       }
       c->do_cast(new_sub_ti);
     }
     type_info = new_type_info;
   } else if (get_is_null() && (new_type_info.is_number() || new_type_info.is_time() ||
                                new_type_info.is_string() || new_type_info.is_boolean())) {
     type_info = new_type_info;
     set_null_value();
   } else if (!is_null_value(type_info, constval) &&
              get_nullable_type_info(type_info) == new_type_info) {
     CHECK(!is_null);
     // relax nullability
     type_info = new_type_info;
     return;
   } else {
     throw std::runtime_error("Cast from " + type_info.get_type_name() + " to " +
                              new_type_info.get_type_name() + " not supported");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Datum Analyzer::Constant::get_constval ( ) const

inline

Definition at line 336 of file Analyzer.h.

References constval.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenDictLike(), CodeGenerator::codegenDictRegexp(), CodeGenerator::codegenDictStrCmp(), CodeGenerator::codegenIntConst(), anonymous_namespace{LogicalIR.cpp}::contains_unsafe_division(), Parser::InsertValuesStmt::determineLeafIndex(), Parser::LikeExpr::get(), Parser::RegexpExpr::get(), getExpressionRange(), CgenState::getOrAddLiteral(), anonymous_namespace{RelAlgExecutor.cpp}::insert_one_dict_str(), operator==(), ScalarExprToSql::visitConstant(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitUOper().

336 { return constval; }

Analyzer::Constant::constval

Datum constval

Definition: Analyzer.h:348

Here is the caller graph for this function:

bool Analyzer::Constant::get_is_null ( ) const

inline

Definition at line 335 of file Analyzer.h.

References is_null.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenIntConst(), Parser::InsertValuesStmt::determineLeafIndex(), do_cast(), Parser::anonymous_namespace{ParserNode.cpp}::expr_is_null(), getExpressionRange(), CgenState::getOrAddLiteral(), anonymous_namespace{RelAlgExecutor.cpp}::insert_one_dict_str(), Analyzer::anonymous_namespace{Analyzer.cpp}::is_expr_nullable(), anonymous_namespace{WindowExpressionRewrite.cpp}::matches_else_null(), operator==(), and ScalarExprToSql::visitConstant().

335 { return is_null; }

Analyzer::Constant::is_null

bool is_null

Definition: Analyzer.h:347

Here is the caller graph for this function:

const std::list<std::shared_ptr<Analyzer::Expr> >& Analyzer::Constant::get_value_list ( ) const

inline

Definition at line 338 of file Analyzer.h.

References value_list.

Referenced by CgenState::getOrAddLiteral().

                                                                      {
     return value_list;
   }

Here is the caller graph for this function:

bool Constant::operator== ( const Expr & rhs ) const

overridevirtual

Implements Analyzer::Expr.

Definition at line 2103 of file Analyzer.cpp.

References constval, Analyzer::Datum_equal(), get_constval(), get_is_null(), Analyzer::Expr::get_type_info(), SQLTypeInfo::is_array(), is_null, and Analyzer::Expr::type_info.

                                                {
   if (typeid(rhs) != typeid(Constant)) {
     return false;
   }
   const Constant& rhs_c = dynamic_cast<const Constant&>(rhs);
   if (type_info != rhs_c.get_type_info() || is_null != rhs_c.get_is_null()) {
     return false;
   }
   if (is_null && rhs_c.get_is_null()) {
     return true;
   }
   if (type_info.is_array()) {
     return false;
   }
   return Datum_equal(type_info, constval, rhs_c.get_constval());
 }

Here is the call graph for this function:

void Analyzer::Constant::set_constval ( Datum d )

inline

Definition at line 337 of file Analyzer.h.

References constval.

337 { constval = d; }

Analyzer::Constant::constval

Datum constval

Definition: Analyzer.h:348

void Constant::set_null_value ( )

private

Definition at line 1209 of file Analyzer.cpp.

References Datum::arrayval, Datum::bigintval, Datum::boolval, CHECK(), constval, Datum::doubleval, Datum::floatval, SQLTypeInfo::get_type(), Datum::intval, kARRAY, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kNULLT, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, NULL_BIGINT, NULL_BOOLEAN, NULL_DOUBLE, NULL_FLOAT, NULL_INT, NULL_SMALLINT, NULL_TINYINT, Datum::smallintval, Datum::stringval, Datum::tinyintval, and Analyzer::Expr::type_info.

Referenced by add_cast(), Constant(), and do_cast().

                               {
   switch (type_info.get_type()) {
     case kBOOLEAN:
       constval.boolval = NULL_BOOLEAN;
       break;
     case kTINYINT:
       constval.tinyintval = NULL_TINYINT;
       break;
     case kINT:
       constval.intval = NULL_INT;
       break;
     case kSMALLINT:
       constval.smallintval = NULL_SMALLINT;
       break;
     case kBIGINT:
     case kNUMERIC:
     case kDECIMAL:
       constval.bigintval = NULL_BIGINT;
       break;
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
       constval.bigintval = NULL_BIGINT;
       break;
     case kVARCHAR:
     case kCHAR:
     case kTEXT:
       constval.stringval = nullptr;
       break;
     case kPOINT:
     case kLINESTRING:
     case kPOLYGON:
     case kMULTIPOLYGON:
       constval.stringval = nullptr;
       break;
     case kFLOAT:
       constval.floatval = NULL_FLOAT;
       break;
     case kDOUBLE:
       constval.doubleval = NULL_DOUBLE;
       break;
     case kNULLT:
       constval.bigintval = 0;
       break;
     case kARRAY:
       constval.arrayval = nullptr;
       break;
     default:
       CHECK(false);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Constant::toString ( ) const

overridevirtual

Implements Analyzer::Expr.

Definition at line 2425 of file Analyzer.cpp.

References constval, DatumToString(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_type(), SQLTypeInfo::is_array(), is_null, sql_type_to_str(), and Analyzer::Expr::type_info.

                                    {
   std::string str{"(Const "};
   if (is_null) {
     str += "NULL";
   } else if (type_info.is_array()) {
     const auto& elem_ti = type_info.get_elem_type();
     str += sql_type_to_str(type_info.get_type()) + ": " +
            sql_type_to_str(elem_ti.get_type());
   } else {
     str += DatumToString(constval, type_info);
   }
   str += ") ";
   return str;
 }

Here is the call graph for this function:

Member Data Documentation

Datum Analyzer::Constant::constval

private

Definition at line 348 of file Analyzer.h.

Referenced by cast_from_string(), cast_number(), cast_string(), cast_to_string(), deep_copy(), do_cast(), get_constval(), operator==(), set_constval(), set_null_value(), toString(), and ~Constant().

bool Analyzer::Constant::is_null

private

Definition at line 347 of file Analyzer.h.

Referenced by add_cast(), deep_copy(), do_cast(), get_is_null(), operator==(), toString(), and ~Constant().

const std::list<std::shared_ptr<Analyzer::Expr> > Analyzer::Constant::value_list

private

Definition at line 349 of file Analyzer.h.

Referenced by deep_copy(), do_cast(), and get_value_list().

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

/home/jenkins-slave/workspace/core-os-doxygen/Analyzer/Analyzer.h
/home/jenkins-slave/workspace/core-os-doxygen/Analyzer/Analyzer.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation