OmniSciDB  ca0c39ec8f
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 >
getMin (const ExpressionRange &other)
 
template<typename T >
getMax (const ExpressionRange &other)
 
template<typename 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

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().

77  {
78  double const_val = get_value_from_datum<double>(const_datum, const_type);
79  switch (sql_op) {
80  case kGT:
81  case kGE:
82  qual_range.setFpMin(std::max(qual_range.getFpMin(), const_val));
83  break;
84  case kLT:
85  case kLE:
86  qual_range.setFpMax(std::min(qual_range.getFpMax(), const_val));
87  break;
88  case kEQ:
89  qual_range.setFpMin(std::max(qual_range.getFpMin(), const_val));
90  qual_range.setFpMax(std::min(qual_range.getFpMax(), const_val));
91  break;
92  default: // there may be other operators, but don't do anything with them
93  break;
94  }
95 }
Definition: sqldefs.h:34
Definition: sqldefs.h:35
Definition: sqldefs.h:29
Definition: sqldefs.h:33
double getFpMax() const
double getFpMin() const
void setFpMax(const double fp_max)
Definition: sqldefs.h:32
void setFpMin(const double fp_min)

+ 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().

129  {
130  CHECK(const_dimen != col_dimen);
131  Datum datum{0};
132  if (const_dimen > col_dimen) {
133  datum.bigintval =
134  get_value_from_datum<int64_t>(const_datum, const_type) /
135  DateTimeUtils::get_timestamp_precision_scale(const_dimen - col_dimen);
136  } else {
137  datum.bigintval =
138  get_value_from_datum<int64_t>(const_datum, const_type) *
139  DateTimeUtils::get_timestamp_precision_scale(col_dimen - const_dimen);
140  }
141  apply_int_qual(datum, const_type, sql_op, qual_range);
142 }
void apply_int_qual(const Datum const_datum, const SQLTypes const_type, const SQLOps sql_op, ExpressionRange &qual_range)
int64_t bigintval
Definition: Datum.h:49
#define CHECK(condition)
Definition: Logger.h:222
constexpr int64_t get_timestamp_precision_scale(const int32_t dimen)
Definition: DateTimeUtils.h:51
Definition: Datum.h:44

+ 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().

100  {
101  int64_t const_val = get_value_from_datum<int64_t>(const_datum, const_type);
102  switch (sql_op) {
103  case kGT:
104  qual_range.setIntMin(std::max(qual_range.getIntMin(), const_val + 1));
105  break;
106  case kGE:
107  qual_range.setIntMin(std::max(qual_range.getIntMin(), const_val));
108  break;
109  case kLT:
110  qual_range.setIntMax(std::min(qual_range.getIntMax(), const_val - 1));
111  break;
112  case kLE:
113  qual_range.setIntMax(std::min(qual_range.getIntMax(), const_val));
114  break;
115  case kEQ:
116  qual_range.setIntMin(std::max(qual_range.getIntMin(), const_val));
117  qual_range.setIntMax(std::min(qual_range.getIntMax(), const_val));
118  break;
119  default: // there may be other operators, but don't do anything with them
120  break;
121  }
122 }
int64_t getIntMin() const
Definition: sqldefs.h:34
Definition: sqldefs.h:35
Definition: sqldefs.h:29
void setIntMin(const int64_t int_min)
Definition: sqldefs.h:33
void setIntMax(const int64_t int_max)
int64_t getIntMax() const
Definition: sqldefs.h:32

+ 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::get_column_id(), Analyzer::ColumnVar::get_table_id(), and ExpressionRange::getType().

Referenced by getExpressionRange().

147  {
148  if (!simple_quals) {
149  return col_range;
150  }
151  ExpressionRange qual_range(col_range);
152  for (auto const& itr : simple_quals.get()) {
153  auto qual_bin_oper = dynamic_cast<Analyzer::BinOper*>(itr.get());
154  if (!qual_bin_oper) {
155  continue;
156  }
157  const Analyzer::Expr* left_operand = qual_bin_oper->get_left_operand();
158  auto qual_col = dynamic_cast<const Analyzer::ColumnVar*>(left_operand);
159  if (!qual_col) {
160  // Check for possibility that column is wrapped in a cast
161  // Presumes that only simple casts (i.e. timestamp to timestamp or int to int) have
162  // been passed through by BinOper::normalize_simple_predicate
163  auto u_expr = dynamic_cast<const Analyzer::UOper*>(left_operand);
164  if (!u_expr) {
165  continue;
166  }
167  qual_col = dynamic_cast<const Analyzer::ColumnVar*>(u_expr->get_operand());
168  if (!qual_col) {
169  continue;
170  }
171  }
172  if (qual_col->get_table_id() != col_expr->get_table_id() ||
173  qual_col->get_column_id() != col_expr->get_column_id()) {
174  continue;
175  }
176  const Analyzer::Expr* right_operand = qual_bin_oper->get_right_operand();
177  auto qual_const = dynamic_cast<const Analyzer::Constant*>(right_operand);
178  if (!qual_const) {
179  continue;
180  }
181  if (qual_range.getType() == ExpressionRangeType::Float ||
182  qual_range.getType() == ExpressionRangeType::Double) {
183  apply_fp_qual(qual_const->get_constval(),
184  qual_const->get_type_info().get_type(),
185  qual_bin_oper->get_optype(),
186  qual_range);
187  } else if ((qual_col->get_type_info().is_timestamp() ||
188  qual_const->get_type_info().is_timestamp()) &&
189  (qual_col->get_type_info().get_dimension() !=
190  qual_const->get_type_info().get_dimension())) {
191  apply_hpt_qual(qual_const->get_constval(),
192  qual_const->get_type_info().get_type(),
193  qual_const->get_type_info().get_dimension(),
194  qual_col->get_type_info().get_dimension(),
195  qual_bin_oper->get_optype(),
196  qual_range);
197  } else {
198  apply_int_qual(qual_const->get_constval(),
199  qual_const->get_type_info().get_type(),
200  qual_bin_oper->get_optype(),
201  qual_range);
202  }
203  }
204  return qual_range;
205 }
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)
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)

+ 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.

284  {
285  switch (type_info) {
286  case kBOOLEAN:
287  return datum.boolval;
288  case kTINYINT:
289  return datum.tinyintval;
290  case kSMALLINT:
291  return datum.smallintval;
292  case kINT:
293  return datum.intval;
294  case kBIGINT:
295  return datum.bigintval;
296  case kTIME:
297  case kTIMESTAMP:
298  case kDATE:
299  return datum.bigintval;
300  case kNUMERIC:
301  case kDECIMAL: {
302  return datum.bigintval;
303  break;
304  }
305  default:
306  UNREACHABLE();
307  }
308  return (int64_t)0;
309 }
int8_t tinyintval
Definition: Datum.h:46
Definition: sqltypes.h:64
int8_t boolval
Definition: Datum.h:45
#define UNREACHABLE()
Definition: Logger.h:266
int32_t intval
Definition: Datum.h:48
int64_t bigintval
Definition: Datum.h:49
int16_t smallintval
Definition: Datum.h:47
Definition: sqltypes.h:68
Definition: sqltypes.h:60
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.

284  {
285  switch (type_info) {
286  case kBOOLEAN:
287  return datum.boolval;
288  case kTINYINT:
289  return datum.tinyintval;
290  case kSMALLINT:
291  return datum.smallintval;
292  case kINT:
293  return datum.intval;
294  case kBIGINT:
295  return datum.bigintval;
296  case kTIME:
297  case kTIMESTAMP:
298  case kDATE:
299  return datum.bigintval;
300  case kNUMERIC:
301  case kDECIMAL: {
302  return datum.bigintval;
303  break;
304  }
305  default:
306  UNREACHABLE();
307  }
308  return (int64_t)0;
309 }
int8_t tinyintval
Definition: Datum.h:46
Definition: sqltypes.h:64
int8_t boolval
Definition: Datum.h:45
#define UNREACHABLE()
Definition: Logger.h:266
int32_t intval
Definition: Datum.h:48
int64_t bigintval
Definition: Datum.h:49
int16_t smallintval
Definition: Datum.h:47
Definition: sqltypes.h:68
Definition: sqltypes.h:60
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.

312  {
313  switch (type_info) {
314  case kFLOAT:
315  return datum.floatval;
316  case kDOUBLE:
317  return datum.doubleval;
318  default:
319  UNREACHABLE();
320  }
321  return 0.0;
322 }
#define UNREACHABLE()
Definition: Logger.h:266
float floatval
Definition: Datum.h:50
double doubleval
Definition: Datum.h:51
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 335 of file ExpressionRange.cpp.

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

339  {
340  if (!ExpressionRange::typeSupportsRange(expr->get_type_info())) {
342  } else if (auto bin_oper_expr = dynamic_cast<const Analyzer::BinOper*>(expr)) {
343  return getExpressionRange(bin_oper_expr, query_infos, executor, simple_quals);
344  } else if (auto constant_expr = dynamic_cast<const Analyzer::Constant*>(expr)) {
345  return getExpressionRange(constant_expr);
346  } else if (auto column_var_expr = dynamic_cast<const Analyzer::ColumnVar*>(expr)) {
347  return getExpressionRange(column_var_expr, query_infos, executor, simple_quals);
348  } else if (auto string_oper_expr = dynamic_cast<const Analyzer::StringOper*>(expr)) {
349  return getExpressionRange(string_oper_expr, executor);
350  } else if (auto like_expr = dynamic_cast<const Analyzer::LikeExpr*>(expr)) {
351  return getExpressionRange(like_expr);
352  } else if (auto case_expr = dynamic_cast<const Analyzer::CaseExpr*>(expr)) {
353  return getExpressionRange(case_expr, query_infos, executor);
354  } else if (auto u_expr = dynamic_cast<const Analyzer::UOper*>(expr)) {
355  return getExpressionRange(u_expr, query_infos, executor, simple_quals);
356  } else if (auto extract_expr = dynamic_cast<const Analyzer::ExtractExpr*>(expr)) {
357  return getExpressionRange(extract_expr, query_infos, executor, simple_quals);
358  } else if (auto datetrunc_expr = dynamic_cast<const Analyzer::DatetruncExpr*>(expr)) {
359  return getExpressionRange(datetrunc_expr, query_infos, executor, simple_quals);
360  } else if (auto width_expr = dynamic_cast<const Analyzer::WidthBucketExpr*>(expr)) {
361  return getExpressionRange(width_expr, query_infos, executor, simple_quals);
362  }
364 }
ExpressionRange getExpressionRange(const Analyzer::BinOper *expr, const std::vector< InputTableInfo > &query_infos, const Executor *, boost::optional< std::list< std::shared_ptr< Analyzer::Expr >>> simple_quals)
static bool typeSupportsRange(const SQLTypeInfo &ti)
static 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 522 of file ExpressionRange.cpp.

References CHECK, CHECK_EQ, CHECK_GT, dtDAY, extract_max_stat_fp_type(), extract_max_stat_int_type(), extract_min_stat_fp_type(), extract_min_stat_int_type(), FIND_STAT_FRAG, Analyzer::ColumnVar::get_column_id(), anonymous_namespace{ExpressionRange.cpp}::get_conservative_datetrunc_bucket(), SQLTypeInfo::get_elem_type(), get_logical_type_info(), Analyzer::ColumnVar::get_table_id(), Analyzer::Expr::get_type_info(), 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().

525  {
526  bool has_nulls = is_outer_join_proj;
527  int col_id = col_expr->get_column_id();
528  const auto& col_phys_ti = col_expr->get_type_info().is_array()
529  ? col_expr->get_type_info().get_elem_type()
530  : col_expr->get_type_info();
531  const auto col_ti = get_logical_type_info(col_phys_ti);
532  switch (col_ti.get_type()) {
533  case kTEXT:
534  case kCHAR:
535  case kVARCHAR:
536  CHECK_EQ(kENCODING_DICT, col_ti.get_compression());
537  case kBOOLEAN:
538  case kTINYINT:
539  case kSMALLINT:
540  case kINT:
541  case kBIGINT:
542  case kDECIMAL:
543  case kNUMERIC:
544  case kDATE:
545  case kTIMESTAMP:
546  case kTIME:
547  case kFLOAT:
548  case kDOUBLE: {
549  std::optional<size_t> ti_idx;
550  for (size_t i = 0; i < query_infos.size(); ++i) {
551  if (col_expr->get_table_id() == query_infos[i].table_id) {
552  ti_idx = i;
553  break;
554  }
555  }
556  CHECK(ti_idx);
557  const auto& query_info = query_infos[*ti_idx].info;
558  const auto& fragments = query_info.fragments;
559  const auto cd = executor->getColumnDescriptor(col_expr);
560  if (cd && cd->isVirtualCol) {
561  CHECK(cd->columnName == "rowid");
562  CHECK_EQ(kBIGINT, col_ti.get_type());
563  const int64_t num_tuples = query_info.getNumTuples();
565  0, std::max(num_tuples - 1, int64_t(0)), 0, has_nulls);
566  }
567  if (query_info.getNumTuples() == 0) {
568  // The column doesn't contain any values, synthesize an empty range.
569  if (col_ti.is_fp()) {
570  return col_ti.get_type() == kFLOAT
571  ? ExpressionRange::makeFloatRange(0, -1, false)
572  : ExpressionRange::makeDoubleRange(0, -1, false);
573  }
574  return ExpressionRange::makeIntRange(0, -1, 0, false);
575  }
576  std::vector<size_t> nonempty_fragment_indices;
577  for (size_t i = 0; i < fragments.size(); ++i) {
578  const auto& fragment = fragments[i];
579  if (!fragment.isEmptyPhysicalFragment()) {
580  nonempty_fragment_indices.push_back(i);
581  }
582  }
583  FIND_STAT_FRAG(min);
584  FIND_STAT_FRAG(max);
585  const auto& min_frag = fragments[*min_frag_index];
586  const auto min_it = min_frag.getChunkMetadataMap().find(col_id);
587  if (min_it == min_frag.getChunkMetadataMap().end()) {
589  }
590  const auto& max_frag = fragments[*max_frag_index];
591  const auto max_it = max_frag.getChunkMetadataMap().find(col_id);
592  CHECK(max_it != max_frag.getChunkMetadataMap().end());
593  for (const auto& fragment : fragments) {
594  const auto it = fragment.getChunkMetadataMap().find(col_id);
595  if (it != fragment.getChunkMetadataMap().end()) {
596  if (it->second->chunkStats.has_nulls) {
597  has_nulls = true;
598  break;
599  }
600  }
601  }
602 
603  // Detect FSI placeholder metadata. If we let this through it will be treated as an
604  // empty range, when it really implies an unknown range.
605  if (min_it->second->isPlaceholder() || max_it->second->isPlaceholder()) {
607  }
608 
609  if (col_ti.is_fp()) {
610  const auto min_val = extract_min_stat_fp_type(min_it->second->chunkStats, col_ti);
611  const auto max_val = extract_max_stat_fp_type(max_it->second->chunkStats, col_ti);
612  return col_ti.get_type() == kFLOAT
613  ? ExpressionRange::makeFloatRange(min_val, max_val, has_nulls)
614  : ExpressionRange::makeDoubleRange(min_val, max_val, has_nulls);
615  }
616  const auto min_val = extract_min_stat_int_type(min_it->second->chunkStats, col_ti);
617  const auto max_val = extract_max_stat_int_type(max_it->second->chunkStats, col_ti);
618  if (max_val < min_val) {
619  // The column doesn't contain any non-null values, synthesize an empty range.
620  CHECK_GT(min_val, 0);
621  return ExpressionRange::makeIntRange(0, -1, 0, has_nulls);
622  }
623  const int64_t bucket =
624  col_ti.get_type() == kDATE ? get_conservative_datetrunc_bucket(dtDAY) : 0;
625  return ExpressionRange::makeIntRange(min_val, max_val, bucket, has_nulls);
626  }
627  default:
628  break;
629  }
631 }
#define CHECK_EQ(x, y)
Definition: Logger.h:230
#define FIND_STAT_FRAG(stat_name)
Definition: sqltypes.h:64
double extract_max_stat_fp_type(const ChunkStats &stats, const SQLTypeInfo &ti)
SQLTypeInfo get_logical_type_info(const SQLTypeInfo &type_info)
Definition: sqltypes.h:1198
#define CHECK_GT(x, y)
Definition: Logger.h:234
int64_t extract_max_stat_int_type(const ChunkStats &stats, const SQLTypeInfo &ti)
static ExpressionRange makeFloatRange(const float fp_min, const float fp_max, const bool has_nulls)
int64_t get_conservative_datetrunc_bucket(const DatetruncField datetrunc_field)
double extract_min_stat_fp_type(const ChunkStats &stats, const SQLTypeInfo &ti)
int64_t extract_min_stat_int_type(const ChunkStats &stats, const SQLTypeInfo &ti)
static ExpressionRange makeIntRange(const int64_t int_min, const int64_t int_max, const int64_t bucket, const bool has_nulls)
Definition: sqltypes.h:67
Definition: sqltypes.h:68
Definition: sqltypes.h:56
bool g_enable_watchdog false
Definition: Execute.cpp:79
#define CHECK(condition)
Definition: Logger.h:222
Definition: sqltypes.h:60
static 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.

278  {
279  return e.getFpMax();
280 }
double getFpMax() const
template<>
float getMax< float > ( const ExpressionRange e)
inline

Definition at line 273 of file ExpressionRange.h.

273  {
274  return e.getFpMax();
275 }
double getFpMax() const
template<>
int64_t getMax< int64_t > ( const ExpressionRange e)
inline

Definition at line 268 of file ExpressionRange.h.

268  {
269  return e.getIntMax();
270 }
int64_t getIntMax() const
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.

263  {
264  return e.getFpMin();
265 }
double getFpMin() const
template<>
float getMin< float > ( const ExpressionRange e)
inline

Definition at line 258 of file ExpressionRange.h.

258  {
259  return e.getFpMin();
260 }
double getFpMin() const
template<>
int64_t getMin< int64_t > ( const ExpressionRange e)
inline

Definition at line 253 of file ExpressionRange.h.

253  {
254  return e.getIntMin();
255 }
int64_t getIntMin() const