Analyzer::Constant Class Reference

#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 306 of file Analyzer.h.

Constructor & Destructor Documentation

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

inline

Definition at line 308 of file Analyzer.h.

References set_null_value().

                               : Expr(t, !n), is_null(n) {
    if (n) {
      set_null_value();
    }
  }

Here is the call graph for this function:

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

inline

Definition at line 313 of file Analyzer.h.

References set_null_value().

                                        : Expr(t, !n), is_null(n), constval(v) {
    if (n) {
      set_null_value();
    }
  }

Here is the call graph for this function:

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

inline

Definition at line 318 of file Analyzer.h.

References set_null_value().

                                                   : Expr(ti), is_null(n), constval(v) {
    if (n) {
      set_null_value();
    }
  }

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 323 of file Analyzer.h.

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

Constant::~Constant ( )

override

Definition at line 41 of file Analyzer.cpp.

References constval, SQLTypeInfoCore< TYPE_FACET_PACK >::is_geometry(), is_null, SQLTypeInfoCore< TYPE_FACET_PACK >::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 1187 of file Analyzer.cpp.

References Analyzer::Expr::add_cast(), Analyzer::Expr::contains_agg, do_cast(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_compression(), is_null, kCAST, kENCODING_DATE_IN_DAYS, kENCODING_NONE, SQLTypeInfoCore< TYPE_FACET_PACK >::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);
  }
  if (is_member_of_typeset<kINT, kDECIMAL, kFLOAT, kDOUBLE>(new_type_info) &&
      is_member_of_typeset<kTIME, kDATE>(type_info)) {
    // 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 1045 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 739 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, SQLTypeInfoCore< TYPE_FACET_PACK >::get_scale(), SQLTypeInfoCore< TYPE_FACET_PACK >::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 1034 of file Analyzer.cpp.

References constval, SQLTypeInfoCore< TYPE_FACET_PACK >::get_dimension(), SQLTypeInfoCore< TYPE_FACET_PACK >::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 1053 of file Analyzer.cpp.

References constval, DatumToString(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_dimension(), SQLTypeInfoCore< TYPE_FACET_PACK >::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, SQLTypeInfoCore< TYPE_FACET_PACK >::get_type(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_geometry(), is_null, SQLTypeInfoCore< TYPE_FACET_PACK >::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 1064 of file Analyzer.cpp.

References Datum::bigintval, cast_from_string(), cast_number(), cast_string(), cast_to_string(), constval, DateTruncate(), DateTruncateHighPrecisionToDate(), dtDAY, DateTimeUtils::get_datetime_scaled_epoch(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_dimension(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_elem_type(), get_is_null(), DateTimeUtils::get_timestamp_precision_scale(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_type(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_type_name(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_array(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_boolean(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_geometry(), is_null, SQLTypeInfoCore< TYPE_FACET_PACK >::is_number(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_string(), SQLTypeInfoCore< TYPE_FACET_PACK >::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) {
    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())) {
    type_info = new_type_info;
    set_null_value();
  } 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 329 of file Analyzer.h.

References constval.

Referenced by Parser::InsertValuesStmt::analyze(), 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{Execute.cpp}::insert_one_dict_str(), operator==(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitUOper().

{ return constval; }

Here is the caller graph for this function:

bool Analyzer::Constant::get_is_null ( ) const

inline

Definition at line 328 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{Execute.cpp}::insert_one_dict_str(), Analyzer::anonymous_namespace{Analyzer.cpp}::is_expr_nullable(), anonymous_namespace{WindowExpressionRewrite.cpp}::matches_else_null(), and operator==().

{ return is_null; }

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 331 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 2014 of file Analyzer.cpp.

References constval, Analyzer::Datum_equal(), get_constval(), get_is_null(), Analyzer::Expr::get_type_info(), SQLTypeInfoCore< TYPE_FACET_PACK >::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 330 of file Analyzer.h.

References constval.

{ constval = d; }

void Constant::set_null_value ( )

private

Definition at line 1135 of file Analyzer.cpp.

References Datum::arrayval, Datum::bigintval, Datum::boolval, CHECK(), constval, Datum::doubleval, Datum::floatval, SQLTypeInfoCore< TYPE_FACET_PACK >::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 2308 of file Analyzer.cpp.

References constval, DatumToString(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_elem_type(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_type(), SQLTypeInfoCore< TYPE_FACET_PACK >::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 341 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 340 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 342 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