ExpressionRange.h File Reference

#include "../Analyzer/Analyzer.h"
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/optional.hpp>

Include dependency graph for ExpressionRange.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	ExpressionRange

Typedefs
using	checked_int64_t = boost::multiprecision::number< boost::multiprecision::cpp_int_backend< 64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void >>
using	checked_int16_t = boost::multiprecision::number< boost::multiprecision::cpp_int_backend< 15, 15, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void >>

Enumerations
enum	ExpressionRangeType {   ExpressionRangeType::Invalid, ExpressionRangeType::Integer, ExpressionRangeType::Float, ExpressionRangeType::Double,   ExpressionRangeType::Null }

Functions
template<typename T >
T	getMin (const ExpressionRange &other)
template<typename T >
T	getMax (const ExpressionRange &other)
template<typename T >
T	get_value_from_datum (const Datum datum, const SQLTypes type_info) noexcept
template<>
int64_t	getMin< int64_t > (const ExpressionRange &e)
template<>
float	getMin< float > (const ExpressionRange &e)
template<>
double	getMin< double > (const ExpressionRange &e)
template<>
int64_t	getMax< int64_t > (const ExpressionRange &e)
template<>
float	getMax< float > (const ExpressionRange &e)
template<>
double	getMax< double > (const ExpressionRange &e)
template<>
int64_t	get_value_from_datum (const Datum datum, const SQLTypes type_info) noexcept
template<>
double	get_value_from_datum (const Datum datum, const SQLTypes type_info) noexcept
void	apply_int_qual (const Datum const_datum, const SQLTypes const_type, const SQLOps sql_op, ExpressionRange &qual_range)
void	apply_fp_qual (const Datum const_datum, const SQLTypes const_type, const SQLOps sql_op, ExpressionRange &qual_range)
void	apply_hpt_qual (const Datum const_datum, const SQLTypes const_type, const int32_t const_dimen, const int32_t col_dimen, const SQLOps sql_op, ExpressionRange &qual_range)
ExpressionRange	apply_simple_quals (const Analyzer::ColumnVar *, const ExpressionRange &, const boost::optional< std::list< std::shared_ptr< Analyzer::Expr >>>=boost::none)
ExpressionRange	getLeafColumnRange (const Analyzer::ColumnVar *, const std::vector< InputTableInfo > &, const Executor *, const bool is_outer_join_proj)
ExpressionRange	getExpressionRange (const Analyzer::Expr *, const std::vector< InputTableInfo > &, const Executor *, boost::optional< std::list< std::shared_ptr< Analyzer::Expr >>>=boost::none)

Typedef Documentation

using checked_int16_t = boost::multiprecision::number< boost::multiprecision::cpp_int_backend<15, 15, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void>>

Definition at line 40 of file ExpressionRange.h.

using checked_int64_t = boost::multiprecision::number< boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void>>

Definition at line 30 of file ExpressionRange.h.

Enumeration Type Documentation

enum ExpressionRangeType

strong

Enumerator
Invalid
Integer
Float
Double
Null

Definition at line 42 of file ExpressionRange.h.

{ Invalid, Integer, Float, Double, Null };

Function Documentation

void apply_fp_qual	(	const Datum	const_datum,
		const SQLTypes	const_type,
		const SQLOps	sql_op,
		ExpressionRange &	qual_range
	)

Definition at line 74 of file ExpressionRange.cpp.

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

Referenced by apply_simple_quals().

                                                {
  double const_val = get_value_from_datum<double>(const_datum, const_type);
  switch (sql_op) {
    case kGT:
    case kGE:
      qual_range.setFpMin(std::max(qual_range.getFpMin(), const_val));
      break;
    case kLT:
    case kLE:
      qual_range.setFpMax(std::min(qual_range.getFpMax(), const_val));
      break;
    case kEQ:
      qual_range.setFpMin(std::max(qual_range.getFpMin(), const_val));
      qual_range.setFpMax(std::min(qual_range.getFpMax(), const_val));
      break;
    default:  // there may be other operators, but don't do anything with them
      break;
  }
}

Here is the caller graph for this function:

void apply_hpt_qual	(	const Datum	const_datum,
		const SQLTypes	const_type,
		const int32_t	const_dimen,
		const int32_t	col_dimen,
		const SQLOps	sql_op,
		ExpressionRange &	qual_range
	)

Definition at line 124 of file ExpressionRange.cpp.

References apply_int_qual(), Datum::bigintval, CHECK, and DateTimeUtils::get_timestamp_precision_scale().

Referenced by apply_simple_quals().

                                                 {
  CHECK(const_dimen != col_dimen);
  Datum datum{0};
  if (const_dimen > col_dimen) {
    datum.bigintval =
        get_value_from_datum<int64_t>(const_datum, const_type) /
        DateTimeUtils::get_timestamp_precision_scale(const_dimen - col_dimen);
  } else {
    datum.bigintval =
        get_value_from_datum<int64_t>(const_datum, const_type) *
        DateTimeUtils::get_timestamp_precision_scale(col_dimen - const_dimen);
  }
  apply_int_qual(datum, const_type, sql_op, qual_range);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void apply_int_qual	(	const Datum	const_datum,
		const SQLTypes	const_type,
		const SQLOps	sql_op,
		ExpressionRange &	qual_range
	)

Definition at line 97 of file ExpressionRange.cpp.

References ExpressionRange::getIntMax(), ExpressionRange::getIntMin(), kEQ, kGE, kGT, kLE, kLT, ExpressionRange::setIntMax(), and ExpressionRange::setIntMin().

Referenced by apply_hpt_qual(), and apply_simple_quals().

                                                 {
  int64_t const_val = get_value_from_datum<int64_t>(const_datum, const_type);
  switch (sql_op) {
    case kGT:
      qual_range.setIntMin(std::max(qual_range.getIntMin(), const_val + 1));
      break;
    case kGE:
      qual_range.setIntMin(std::max(qual_range.getIntMin(), const_val));
      break;
    case kLT:
      qual_range.setIntMax(std::min(qual_range.getIntMax(), const_val - 1));
      break;
    case kLE:
      qual_range.setIntMax(std::min(qual_range.getIntMax(), const_val));
      break;
    case kEQ:
      qual_range.setIntMin(std::max(qual_range.getIntMin(), const_val));
      qual_range.setIntMax(std::min(qual_range.getIntMax(), const_val));
      break;
    default:  // there may be other operators, but don't do anything with them
      break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ExpressionRange apply_simple_quals	(	const Analyzer::ColumnVar *	,
		const ExpressionRange &	,
		const boost::optional< std::list< std::shared_ptr< Analyzer::Expr >>>	= boost::none
	)

Definition at line 144 of file ExpressionRange.cpp.

References apply_fp_qual(), apply_hpt_qual(), apply_int_qual(), Double, Float, Analyzer::ColumnVar::getColumnKey(), and ExpressionRange::getType().

Referenced by getExpressionRange().

                                                                            {
  if (!simple_quals) {
    return col_range;
  }
  ExpressionRange qual_range(col_range);
  for (auto const& itr : simple_quals.get()) {
    auto qual_bin_oper = dynamic_cast<Analyzer::BinOper*>(itr.get());
    if (!qual_bin_oper) {
      continue;
    }
    const Analyzer::Expr* left_operand = qual_bin_oper->get_left_operand();
    auto qual_col = dynamic_cast<const Analyzer::ColumnVar*>(left_operand);
    if (!qual_col) {
      // Check for possibility that column is wrapped in a cast
      // Presumes that only simple casts (i.e. timestamp to timestamp or int to int) have
      // been passed through by BinOper::normalize_simple_predicate
      auto u_expr = dynamic_cast<const Analyzer::UOper*>(left_operand);
      if (!u_expr) {
        continue;
      }
      qual_col = dynamic_cast<const Analyzer::ColumnVar*>(u_expr->get_operand());
      if (!qual_col) {
        continue;
      }
    }
    if (qual_col->getColumnKey() != col_expr->getColumnKey()) {
      continue;
    }
    const Analyzer::Expr* right_operand = qual_bin_oper->get_right_operand();
    auto qual_const = dynamic_cast<const Analyzer::Constant*>(right_operand);
    if (!qual_const) {
      continue;
    }
    if (qual_range.getType() == ExpressionRangeType::Float ||
        qual_range.getType() == ExpressionRangeType::Double) {
      apply_fp_qual(qual_const->get_constval(),
                    qual_const->get_type_info().get_type(),
                    qual_bin_oper->get_optype(),
                    qual_range);
    } else if ((qual_col->get_type_info().is_timestamp() ||
                qual_const->get_type_info().is_timestamp()) &&
               (qual_col->get_type_info().get_dimension() !=
                qual_const->get_type_info().get_dimension())) {
      apply_hpt_qual(qual_const->get_constval(),
                     qual_const->get_type_info().get_type(),
                     qual_const->get_type_info().get_dimension(),
                     qual_col->get_type_info().get_dimension(),
                     qual_bin_oper->get_optype(),
                     qual_range);
    } else {
      apply_int_qual(qual_const->get_constval(),
                     qual_const->get_type_info().get_type(),
                     qual_bin_oper->get_optype(),
                     qual_range);
    }
  }
  return qual_range;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

T get_value_from_datum ( const Datum  datum, const SQLTypes  type_info  )

inlinenoexcept

Definition at line 283 of file ExpressionRange.h.

References kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, and UNREACHABLE.

                                                                       {
  switch (type_info) {
    case kBOOLEAN:
      return datum.boolval;
    case kTINYINT:
      return datum.tinyintval;
    case kSMALLINT:
      return datum.smallintval;
    case kINT:
      return datum.intval;
    case kBIGINT:
      return datum.bigintval;
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
      return datum.bigintval;
    case kNUMERIC:
    case kDECIMAL: {
      return datum.bigintval;
      break;
    }
    default:
      UNREACHABLE();
  }
  return (int64_t)0;
}

template<>

int64_t get_value_from_datum ( const Datum  datum, const SQLTypes  type_info  )

inlinenoexcept

Definition at line 283 of file ExpressionRange.h.

References kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kINT, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, and UNREACHABLE.

                                                                       {
  switch (type_info) {
    case kBOOLEAN:
      return datum.boolval;
    case kTINYINT:
      return datum.tinyintval;
    case kSMALLINT:
      return datum.smallintval;
    case kINT:
      return datum.intval;
    case kBIGINT:
      return datum.bigintval;
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
      return datum.bigintval;
    case kNUMERIC:
    case kDECIMAL: {
      return datum.bigintval;
      break;
    }
    default:
      UNREACHABLE();
  }
  return (int64_t)0;
}

template<>

double get_value_from_datum ( const Datum  datum, const SQLTypes  type_info  )

inlinenoexcept

Definition at line 312 of file ExpressionRange.h.

References kDOUBLE, kFLOAT, and UNREACHABLE.

                                                                                         {
  switch (type_info) {
    case kFLOAT:
      return datum.floatval;
    case kDOUBLE:
      return datum.doubleval;
    default:
      UNREACHABLE();
  }
  return 0.0;
}

ExpressionRange getExpressionRange	(	const Analyzer::Expr *	,
		const std::vector< InputTableInfo > &	,
		const Executor *	,
		boost::optional< std::list< std::shared_ptr< Analyzer::Expr >>>	= boost::none
	)

Definition at line 334 of file ExpressionRange.cpp.

References Analyzer::Expr::get_type_info(), getExpressionRange(), ExpressionRange::makeInvalidRange(), and ExpressionRange::typeSupportsRange().

                                                                      {
  if (!ExpressionRange::typeSupportsRange(expr->get_type_info())) {
    return ExpressionRange::makeInvalidRange();
  } else if (auto bin_oper_expr = dynamic_cast<const Analyzer::BinOper*>(expr)) {
    return getExpressionRange(bin_oper_expr, query_infos, executor, simple_quals);
  } else if (auto constant_expr = dynamic_cast<const Analyzer::Constant*>(expr)) {
    return getExpressionRange(constant_expr);
  } else if (auto column_var_expr = dynamic_cast<const Analyzer::ColumnVar*>(expr)) {
    return getExpressionRange(column_var_expr, query_infos, executor, simple_quals);
  } else if (auto string_oper_expr = dynamic_cast<const Analyzer::StringOper*>(expr)) {
    return getExpressionRange(string_oper_expr, executor);
  } else if (auto like_expr = dynamic_cast<const Analyzer::LikeExpr*>(expr)) {
    return getExpressionRange(like_expr);
  } else if (auto case_expr = dynamic_cast<const Analyzer::CaseExpr*>(expr)) {
    return getExpressionRange(case_expr, query_infos, executor);
  } else if (auto u_expr = dynamic_cast<const Analyzer::UOper*>(expr)) {
    return getExpressionRange(u_expr, query_infos, executor, simple_quals);
  } else if (auto extract_expr = dynamic_cast<const Analyzer::ExtractExpr*>(expr)) {
    return getExpressionRange(extract_expr, query_infos, executor, simple_quals);
  } else if (auto datetrunc_expr = dynamic_cast<const Analyzer::DatetruncExpr*>(expr)) {
    return getExpressionRange(datetrunc_expr, query_infos, executor, simple_quals);
  } else if (auto width_expr = dynamic_cast<const Analyzer::WidthBucketExpr*>(expr)) {
    return getExpressionRange(width_expr, query_infos, executor, simple_quals);
  }
  return ExpressionRange::makeInvalidRange();
}

Here is the call graph for this function:

ExpressionRange getLeafColumnRange	(	const Analyzer::ColumnVar *	,
		const std::vector< InputTableInfo > &	,
		const Executor *	,
		const bool	is_outer_join_proj
	)

Definition at line 521 of file ExpressionRange.cpp.

References CHECK, CHECK_EQ, CHECK_GT, shared::ColumnKey::column_id, dtDAY, extract_max_stat_fp_type(), extract_max_stat_int_type(), extract_min_stat_fp_type(), extract_min_stat_int_type(), FIND_STAT_FRAG, anonymous_namespace{ExpressionRange.cpp}::get_conservative_datetrunc_bucket(), SQLTypeInfo::get_elem_type(), get_logical_type_info(), Analyzer::Expr::get_type_info(), Analyzer::ColumnVar::getColumnKey(), Analyzer::ColumnVar::getTableKey(), SQLTypeInfo::is_array(), kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kENCODING_DICT, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, ExpressionRange::makeDoubleRange(), ExpressionRange::makeFloatRange(), ExpressionRange::makeIntRange(), and ExpressionRange::makeInvalidRange().

Referenced by Executor::computeColRangesCache(), and getExpressionRange().

                                                                  {
  bool has_nulls = is_outer_join_proj;
  int col_id = col_expr->getColumnKey().column_id;
  const auto& col_phys_ti = col_expr->get_type_info().is_array()
                                ? col_expr->get_type_info().get_elem_type()
                                : col_expr->get_type_info();
  const auto col_ti = get_logical_type_info(col_phys_ti);
  switch (col_ti.get_type()) {
    case kTEXT:
    case kCHAR:
    case kVARCHAR:
      CHECK_EQ(kENCODING_DICT, col_ti.get_compression());
    case kBOOLEAN:
    case kTINYINT:
    case kSMALLINT:
    case kINT:
    case kBIGINT:
    case kDECIMAL:
    case kNUMERIC:
    case kDATE:
    case kTIMESTAMP:
    case kTIME:
    case kFLOAT:
    case kDOUBLE: {
      std::optional<size_t> ti_idx;
      for (size_t i = 0; i < query_infos.size(); ++i) {
        if (col_expr->getTableKey() == query_infos[i].table_key) {
          ti_idx = i;
          break;
        }
      }
      CHECK(ti_idx);
      const auto& query_info = query_infos[*ti_idx].info;
      const auto& fragments = query_info.fragments;
      const auto cd = executor->getColumnDescriptor(col_expr);
      if (cd && cd->isVirtualCol) {
        CHECK(cd->columnName == "rowid");
        CHECK_EQ(kBIGINT, col_ti.get_type());
        const int64_t num_tuples = query_info.getNumTuples();
        return ExpressionRange::makeIntRange(
            0, std::max(num_tuples - 1, int64_t(0)), 0, has_nulls);
      }
      if (query_info.getNumTuples() == 0) {
        // The column doesn't contain any values, synthesize an empty range.
        if (col_ti.is_fp()) {
          return col_ti.get_type() == kFLOAT
                     ? ExpressionRange::makeFloatRange(0, -1, false)
                     : ExpressionRange::makeDoubleRange(0, -1, false);
        }
        return ExpressionRange::makeIntRange(0, -1, 0, false);
      }
      std::vector<size_t> nonempty_fragment_indices;
      for (size_t i = 0; i < fragments.size(); ++i) {
        const auto& fragment = fragments[i];
        if (!fragment.isEmptyPhysicalFragment()) {
          nonempty_fragment_indices.push_back(i);
        }
      }
      FIND_STAT_FRAG(min);
      FIND_STAT_FRAG(max);
      const auto& min_frag = fragments[*min_frag_index];
      const auto min_it = min_frag.getChunkMetadataMap().find(col_id);
      if (min_it == min_frag.getChunkMetadataMap().end()) {
        return ExpressionRange::makeInvalidRange();
      }
      const auto& max_frag = fragments[*max_frag_index];
      const auto max_it = max_frag.getChunkMetadataMap().find(col_id);
      CHECK(max_it != max_frag.getChunkMetadataMap().end());
      for (const auto& fragment : fragments) {
        const auto it = fragment.getChunkMetadataMap().find(col_id);
        if (it != fragment.getChunkMetadataMap().end()) {
          if (it->second->chunkStats.has_nulls) {
            has_nulls = true;
            break;
          }
        }
      }

      // Detect FSI placeholder metadata.  If we let this through it will be treated as an
      // empty range, when it really implies an unknown range.
      if (min_it->second->isPlaceholder() || max_it->second->isPlaceholder()) {
        return ExpressionRange::makeInvalidRange();
      }

      if (col_ti.is_fp()) {
        const auto min_val = extract_min_stat_fp_type(min_it->second->chunkStats, col_ti);
        const auto max_val = extract_max_stat_fp_type(max_it->second->chunkStats, col_ti);
        return col_ti.get_type() == kFLOAT
                   ? ExpressionRange::makeFloatRange(min_val, max_val, has_nulls)
                   : ExpressionRange::makeDoubleRange(min_val, max_val, has_nulls);
      }
      const auto min_val = extract_min_stat_int_type(min_it->second->chunkStats, col_ti);
      const auto max_val = extract_max_stat_int_type(max_it->second->chunkStats, col_ti);
      if (max_val < min_val) {
        // The column doesn't contain any non-null values, synthesize an empty range.
        CHECK_GT(min_val, 0);
        return ExpressionRange::makeIntRange(0, -1, 0, has_nulls);
      }
      const int64_t bucket =
          col_ti.get_type() == kDATE ? get_conservative_datetrunc_bucket(dtDAY) : 0;
      return ExpressionRange::makeIntRange(min_val, max_val, bucket, has_nulls);
    }
    default:
      break;
  }
  return ExpressionRange::makeInvalidRange();
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

T getMax

(

const ExpressionRange &

other

)

template<>

double getMax< double > ( const ExpressionRange &  e )

inline

Definition at line 278 of file ExpressionRange.h.

                                                       {
  return e.getFpMax();
}

template<>

float getMax< float > ( const ExpressionRange &  e )

inline

Definition at line 273 of file ExpressionRange.h.

                                                     {
  return e.getFpMax();
}

template<>

int64_t getMax< int64_t > ( const ExpressionRange &  e )

inline

Definition at line 268 of file ExpressionRange.h.

                                                         {
  return e.getIntMax();
}

template<typename T >

T getMin

(

const ExpressionRange &

other

)

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl::handleUnresolvedFunction().

Here is the caller graph for this function:

template<>

double getMin< double > ( const ExpressionRange &  e )

inline

Definition at line 263 of file ExpressionRange.h.

                                                       {
  return e.getFpMin();
}

template<>

float getMin< float > ( const ExpressionRange &  e )

inline

Definition at line 258 of file ExpressionRange.h.

                                                     {
  return e.getFpMin();
}

template<>

int64_t getMin< int64_t > ( const ExpressionRange &  e )

inline

Definition at line 253 of file ExpressionRange.h.

                                                         {
  return e.getIntMin();
}