Classes
struct	ByTypeIndex

Typedefs
using	Handler = std::shared_ptr< Analyzer::Expr >(RelAlgTranslator::)(RexScalar const ) const

using	IndexedHandler = std::pair< std::type_index, Handler >

Functions
SQLTypeInfo	build_type_info (const SQLTypes sql_type, const int scale, const int precision)

std::pair< Datum, bool >	datum_from_scalar_tv (const ScalarTargetValue *scalar_tv, const SQLTypeInfo &ti) noexcept

template<typename... Ts>
std::array< IndexedHandler, sizeof...(Ts)>	makeHandlers ()

bool	is_agg_supported_for_type (const SQLAgg &agg_kind, const SQLTypeInfo &arg_ti)

std::shared_ptr< Analyzer::Expr >	get_in_values_expr (std::shared_ptr< Analyzer::Expr > arg, const ResultSet &val_set)

void	fill_dictionary_encoded_in_vals (std::vector< int64_t > &in_vals, std::atomic< size_t > &total_in_vals_count, const ResultSet values_rowset, const std::pair< int64_t, int64_t > values_rowset_slice, const StringDictionaryProxy source_dict, const StringDictionaryProxy *dest_dict, const int64_t needle_null_val)

void	fill_integer_in_vals (std::vector< int64_t > &in_vals, std::atomic< size_t > &total_in_vals_count, const ResultSet *values_rowset, const std::pair< int64_t, int64_t > values_rowset_slice)

void	fill_dictionary_encoded_in_vals (std::vector< int64_t > &in_vals, std::atomic< size_t > &total_in_vals_count, const ResultSet *values_rowset, const std::pair< int64_t, int64_t > values_rowset_slice, const std::vector< LeafHostInfo > &leaf_hosts, const DictRef source_dict_ref, const DictRef dest_dict_ref, const int32_t dest_generation, const int64_t needle_null_val)

void	validate_datetime_datepart_argument (const std::shared_ptr< Analyzer::Constant > literal_expr)

std::shared_ptr < Analyzer::Constant >	makeNumericConstant (const SQLTypeInfo &ti, const long val)

std::string	get_datetimeplus_rewrite_funcname (const SQLOps &op)

std::vector< Analyzer::OrderEntry >	translate_collation (const std::vector< SortField > &sort_fields)

size_t	determineTimeValMultiplierForTimeType (const SQLTypes &window_frame_bound_type, const Analyzer::Constant *const_expr)

ExtractField	determineTimeUnit (const SQLTypes &window_frame_bound_type, const Analyzer::Constant *const_expr)

Variables
const size_t	g_max_integer_set_size {1 << 25}

Typedef Documentation

using anonymous_namespace{RelAlgTranslator.cpp}::Handler = typedef std::shared_ptr<Analyzer::Expr> (RelAlgTranslator::*)(RexScalar const*) const

Definition at line 181 of file RelAlgTranslator.cpp.

using anonymous_namespace{RelAlgTranslator.cpp}::IndexedHandler = typedef std::pair<std::type_index, Handler>

Definition at line 182 of file RelAlgTranslator.cpp.

Function Documentation

SQLTypeInfo anonymous_namespace{RelAlgTranslator.cpp}::build_type_info	(	const SQLTypes	sql_type,
		const int	scale,
		const int	precision
	)

Definition at line 44 of file RelAlgTranslator.cpp.

References SQLTypeInfo::is_decimal(), SQLTypeInfo::set_precision(), and SQLTypeInfo::set_scale().

Referenced by RelAlgTranslator::translateLiteral().

                                                  {
   SQLTypeInfo ti(sql_type, 0, 0, true);
   if (ti.is_decimal()) {
     ti.set_scale(scale);
     ti.set_precision(precision);
   }
   return ti;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair<Datum, bool> anonymous_namespace{RelAlgTranslator.cpp}::datum_from_scalar_tv	(	const ScalarTargetValue *	scalar_tv,
		const SQLTypeInfo &	ti
	)

noexcept

Definition at line 81 of file RelAlgTranslator.cpp.

References CHECK, inline_fp_null_val(), inline_int_null_val(), kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, and kVARCHAR.

Referenced by get_in_values_expr(), RelAlgTranslator::translateInOper(), and RelAlgTranslator::translateScalarSubquery().

                                                                             {
   Datum d{0};
   bool is_null_const{false};
   switch (ti.get_type()) {
     case kBOOLEAN: {
       const auto ival = boost::get<int64_t>(scalar_tv);
       CHECK(ival);
       if (*ival == inline_int_null_val(ti)) {
         is_null_const = true;
       } else {
         d.boolval = *ival;
       }
       break;
     }
     case kTINYINT: {
       const auto ival = boost::get<int64_t>(scalar_tv);
       CHECK(ival);
       if (*ival == inline_int_null_val(ti)) {
         is_null_const = true;
       } else {
         d.tinyintval = *ival;
       }
       break;
     }
     case kSMALLINT: {
       const auto ival = boost::get<int64_t>(scalar_tv);
       CHECK(ival);
       if (*ival == inline_int_null_val(ti)) {
         is_null_const = true;
       } else {
         d.smallintval = *ival;
       }
       break;
     }
     case kINT: {
       const auto ival = boost::get<int64_t>(scalar_tv);
       CHECK(ival);
       if (*ival == inline_int_null_val(ti)) {
         is_null_const = true;
       } else {
         d.intval = *ival;
       }
       break;
     }
     case kDECIMAL:
     case kNUMERIC:
     case kBIGINT:
     case kDATE:
     case kTIME:
     case kTIMESTAMP: {
       const auto ival = boost::get<int64_t>(scalar_tv);
       CHECK(ival);
       if (*ival == inline_int_null_val(ti)) {
         is_null_const = true;
       } else {
         d.bigintval = *ival;
       }
       break;
     }
     case kDOUBLE: {
       const auto dval = boost::get<double>(scalar_tv);
       CHECK(dval);
       if (*dval == inline_fp_null_val(ti)) {
         is_null_const = true;
       } else {
         d.doubleval = *dval;
       }
       break;
     }
     case kFLOAT: {
       const auto fval = boost::get<float>(scalar_tv);
       CHECK(fval);
       if (*fval == inline_fp_null_val(ti)) {
         is_null_const = true;
       } else {
         d.floatval = *fval;
       }
       break;
     }
     case kTEXT:
     case kVARCHAR:
     case kCHAR: {
       auto nullable_sptr = boost::get<NullableString>(scalar_tv);
       CHECK(nullable_sptr);
       if (boost::get<void*>(nullable_sptr)) {
         is_null_const = true;
       } else {
         auto sptr = boost::get<std::string>(nullable_sptr);
         d.stringval = new std::string(*sptr);
       }
       break;
     }
     default:
       CHECK(false) << "Unhandled type: " << ti.get_type_name();
   }
   return {d, is_null_const};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ExtractField anonymous_namespace{RelAlgTranslator.cpp}::determineTimeUnit	(	const SQLTypes &	window_frame_bound_type,
		const Analyzer::Constant *	const_expr
	)

Definition at line 2015 of file RelAlgTranslator.cpp.

References Datum::bigintval, CHECK, Analyzer::Constant::get_constval(), kDAY, kHOUR, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kMilliSecsPerDay, kMilliSecsPerHour, kMilliSecsPerMin, kMilliSecsPerSec, kMINUTE, kMONTH, kSECOND, kUNKNOWN_FIELD, and kYEAR.

Referenced by RelAlgTranslator::translateIntervalExprForWindowFraming().

                                                                    {
   const auto time_unit_val = const_expr->get_constval().bigintval;
   if (window_frame_bound_type == kINTERVAL_DAY_TIME) {
     if (time_unit_val == kMilliSecsPerSec) {
       return kSECOND;
     } else if (time_unit_val == kMilliSecsPerMin) {
       return kMINUTE;
     } else if (time_unit_val == kMilliSecsPerHour) {
       return kHOUR;
     } else if (time_unit_val == kMilliSecsPerDay) {
       return kDAY;
     }
   } else {
     CHECK(window_frame_bound_type == kINTERVAL_YEAR_MONTH);
     if (time_unit_val == 1) {
       return kMONTH;
     } else if (time_unit_val == 12) {
       return kYEAR;
     }
   }
   CHECK(false);
   return kUNKNOWN_FIELD;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t anonymous_namespace{RelAlgTranslator.cpp}::determineTimeValMultiplierForTimeType	(	const SQLTypes &	window_frame_bound_type,
		const Analyzer::Constant *	const_expr
	)

Definition at line 1999 of file RelAlgTranslator.cpp.

References Datum::bigintval, CHECK, Analyzer::Constant::get_constval(), kINTERVAL_DAY_TIME, kMilliSecsPerHour, kMilliSecsPerMin, kMilliSecsPerSec, kSecsPerHour, kSecsPerMin, and kUNKNOWN_FIELD.

Referenced by RelAlgTranslator::translateIntervalExprForWindowFraming().

                                                                                  {
   const auto time_unit_val = const_expr->get_constval().bigintval;
   if (window_frame_bound_type == kINTERVAL_DAY_TIME) {
     if (time_unit_val == kMilliSecsPerSec) {
       return 1;
     } else if (time_unit_val == kMilliSecsPerMin) {
       return kSecsPerMin;
     } else if (time_unit_val == kMilliSecsPerHour) {
       return kSecsPerHour;
     }
   }
   CHECK(false);
   return kUNKNOWN_FIELD;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgTranslator.cpp}::fill_dictionary_encoded_in_vals	(	std::vector< int64_t > &	in_vals,
		std::atomic< size_t > &	total_in_vals_count,
		const ResultSet *	values_rowset,
		const std::pair< int64_t, int64_t >	values_rowset_slice,
		const StringDictionaryProxy *	source_dict,
		const StringDictionaryProxy *	dest_dict,
		const int64_t	needle_null_val
	)

Definition at line 754 of file RelAlgTranslator.cpp.

References CHECK, g_enable_watchdog, g_max_integer_set_size, StringDictionaryProxy::getIdOfString(), StringDictionaryProxy::getString(), StringDictionary::INVALID_STR_ID, and UNLIKELY.

Referenced by RelAlgTranslator::getInIntegerSetExpr().

                                    {
   CHECK(in_vals.empty());
   bool dicts_are_equal = source_dict == dest_dict;
   for (auto index = values_rowset_slice.first; index < values_rowset_slice.second;
        ++index) {
     const auto row = values_rowset->getOneColRow(index);
     if (UNLIKELY(!row.valid)) {
       continue;
     }
     if (dicts_are_equal) {
       in_vals.push_back(row.value);
     } else {
       const int string_id =
           row.value == needle_null_val
               ? needle_null_val
               : dest_dict->getIdOfString(source_dict->getString(row.value));
       if (string_id != StringDictionary::INVALID_STR_ID) {
         in_vals.push_back(string_id);
       }
     }
     if (UNLIKELY(g_enable_watchdog && (in_vals.size() & 1023) == 0 &&
                  total_in_vals_count.fetch_add(1024) >= g_max_integer_set_size)) {
       throw std::runtime_error(
           "Unable to handle 'expr IN (subquery)', subquery returned 30M+ rows.");
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgTranslator.cpp}::fill_dictionary_encoded_in_vals	(	std::vector< int64_t > &	in_vals,
		std::atomic< size_t > &	total_in_vals_count,
		const ResultSet *	values_rowset,
		const std::pair< int64_t, int64_t >	values_rowset_slice,
		const std::vector< LeafHostInfo > &	leaf_hosts,
		const DictRef	source_dict_ref,
		const DictRef	dest_dict_ref,
		const int32_t	dest_generation,
		const int64_t	needle_null_val
	)

Definition at line 815 of file RelAlgTranslator.cpp.

References CHECK, CHECK_EQ, g_enable_watchdog, g_max_integer_set_size, StringDictionary::INVALID_STR_ID, translate_string_ids(), and UNLIKELY.

                                    {
   CHECK(in_vals.empty());
   std::vector<int32_t> source_ids;
   source_ids.reserve(values_rowset->entryCount());
   bool has_nulls = false;
   if (source_dict_ref == dest_dict_ref) {
     in_vals.reserve(values_rowset_slice.second - values_rowset_slice.first +
                     1);  // Add 1 to cover interval
     for (auto index = values_rowset_slice.first; index < values_rowset_slice.second;
          ++index) {
       const auto row = values_rowset->getOneColRow(index);
       if (!row.valid) {
         continue;
       }
       if (row.value != needle_null_val) {
         in_vals.push_back(row.value);
         if (UNLIKELY(g_enable_watchdog && (in_vals.size() & 1023) == 0 &&
                      total_in_vals_count.fetch_add(1024) >= g_max_integer_set_size)) {
           throw std::runtime_error(
               "Unable to handle 'expr IN (subquery)', subquery returned 30M+ rows.");
         }
       } else {
         has_nulls = true;
       }
     }
     if (has_nulls) {
       in_vals.push_back(
           needle_null_val);  // we've deduped null values as an optimization, although
                              // this is not required by consumer
     }
     return;
   }
   // Code path below is for when dictionaries are not shared
   for (auto index = values_rowset_slice.first; index < values_rowset_slice.second;
        ++index) {
     const auto row = values_rowset->getOneColRow(index);
     if (row.valid) {
       if (row.value != needle_null_val) {
         source_ids.push_back(row.value);
       } else {
         has_nulls = true;
       }
     }
   }
   std::vector<int32_t> dest_ids;
   translate_string_ids(dest_ids,
                        leaf_hosts.front(),
                        dest_dict_ref,
                        source_ids,
                        source_dict_ref,
                        dest_generation);
   CHECK_EQ(dest_ids.size(), source_ids.size());
   in_vals.reserve(dest_ids.size() + (has_nulls ? 1 : 0));
   if (has_nulls) {
     in_vals.push_back(needle_null_val);
   }
   for (const int32_t dest_id : dest_ids) {
     if (dest_id != StringDictionary::INVALID_STR_ID) {
       in_vals.push_back(dest_id);
       if (UNLIKELY(g_enable_watchdog && (in_vals.size() & 1023) == 0 &&
                    total_in_vals_count.fetch_add(1024) >= g_max_integer_set_size)) {
         throw std::runtime_error(
             "Unable to handle 'expr IN (subquery)', subquery returned 30M+ rows.");
       }
     }
   }
 }

Here is the call graph for this function:

void anonymous_namespace{RelAlgTranslator.cpp}::fill_integer_in_vals	(	std::vector< int64_t > &	in_vals,
		std::atomic< size_t > &	total_in_vals_count,
		const ResultSet *	values_rowset,
		const std::pair< int64_t, int64_t >	values_rowset_slice
	)

Definition at line 789 of file RelAlgTranslator.cpp.

References CHECK, g_enable_watchdog, g_max_integer_set_size, and UNLIKELY.

Referenced by RelAlgTranslator::getInIntegerSetExpr().

                                                                                {
   CHECK(in_vals.empty());
   for (auto index = values_rowset_slice.first; index < values_rowset_slice.second;
        ++index) {
     const auto row = values_rowset->getOneColRow(index);
     if (row.valid) {
       in_vals.push_back(row.value);
       if (UNLIKELY(g_enable_watchdog && (in_vals.size() & 1023) == 0 &&
                    total_in_vals_count.fetch_add(1024) >= g_max_integer_set_size)) {
         throw std::runtime_error(
             "Unable to handle 'expr IN (subquery)', subquery returned 30M+ rows.");
       }
     }
   }
 }

Here is the caller graph for this function:

std::string anonymous_namespace{RelAlgTranslator.cpp}::get_datetimeplus_rewrite_funcname ( const SQLOps & op )

Definition at line 1261 of file RelAlgTranslator.cpp.

References CHECK, and kPLUS.

Referenced by RelAlgTranslator::translateDatePlusMinus().

                                                               {
   CHECK(op == kPLUS);
   return "DATETIME_PLUS"s;
 }

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{RelAlgTranslator.cpp}::get_in_values_expr	(	std::shared_ptr< Analyzer::Expr >	arg,
		const ResultSet &	val_set
	)

Definition at line 609 of file RelAlgTranslator.cpp.

References threading_serial::async(), result_set::can_use_parallel_algorithms(), cpu_threads(), datum_from_scalar_tv(), g_enable_watchdog, kCAST, and kENCODING_NONE.

Referenced by RelAlgTranslator::translateInOper().

                                                                              {
   if (!result_set::can_use_parallel_algorithms(val_set)) {
     return nullptr;
   }
   if (val_set.rowCount() > 5000000 && g_enable_watchdog) {
     throw std::runtime_error(
         "Unable to handle 'expr IN (subquery)', subquery returned 5M+ rows.");
   }
   std::list<std::shared_ptr<Analyzer::Expr>> value_exprs;
   const size_t fetcher_count = cpu_threads();
   std::vector<std::list<std::shared_ptr<Analyzer::Expr>>> expr_set(
       fetcher_count, std::list<std::shared_ptr<Analyzer::Expr>>());
   std::vector<std::future<void>> fetcher_threads;
   const auto& ti = arg->get_type_info();
   const auto entry_count = val_set.entryCount();
   for (size_t i = 0,
               start_entry = 0,
               stride = (entry_count + fetcher_count - 1) / fetcher_count;
        i < fetcher_count && start_entry < entry_count;
        ++i, start_entry += stride) {
     const auto end_entry = std::min(start_entry + stride, entry_count);
     fetcher_threads.push_back(std::async(
         std::launch::async,
         [&](std::list<std::shared_ptr<Analyzer::Expr>>& in_vals,
             const size_t start,
             const size_t end) {
           for (auto index = start; index < end; ++index) {
             auto row = val_set.getRowAt(index);
             if (row.empty()) {
               continue;
             }
             auto scalar_tv = boost::get<ScalarTargetValue>(&row[0]);
             Datum d{0};
             bool is_null_const{false};
             std::tie(d, is_null_const) = datum_from_scalar_tv(scalar_tv, ti);
             if (ti.is_string() && ti.get_compression() != kENCODING_NONE) {
               auto ti_none_encoded = ti;
               ti_none_encoded.set_compression(kENCODING_NONE);
               auto none_encoded_string =
                   makeExpr<Analyzer::Constant>(ti, is_null_const, d);
               auto dict_encoded_string = std::make_shared<Analyzer::UOper>(
                   ti, false, kCAST, none_encoded_string);
               in_vals.push_back(dict_encoded_string);
             } else {
               in_vals.push_back(makeExpr<Analyzer::Constant>(ti, is_null_const, d));
             }
           }
         },
         std::ref(expr_set[i]),
         start_entry,
         end_entry));
   }
   for (auto& child : fetcher_threads) {
     child.get();
   }
 
   val_set.moveToBegin();
   for (auto& exprs : expr_set) {
     value_exprs.splice(value_exprs.end(), exprs);
   }
   return makeExpr<Analyzer::InValues>(arg, value_exprs);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgTranslator.cpp}::is_agg_supported_for_type	(	const SQLAgg &	agg_kind,
		const SQLTypeInfo &	arg_ti
	)

Definition at line 266 of file RelAlgTranslator.cpp.

References SQLTypeInfo::is_boolean(), SQLTypeInfo::is_number(), SQLTypeInfo::is_time(), kAVG, kMAX, kMIN, and kSUM.

Referenced by RelAlgTranslator::translateAggregateRex().

                                                                                   {
   if ((agg_kind == kMIN || agg_kind == kMAX || agg_kind == kSUM || agg_kind == kAVG) &&
       !(arg_ti.is_number() || arg_ti.is_boolean() || arg_ti.is_time())) {
     return false;
   }
 
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename... Ts>

std::array<IndexedHandler, sizeof...(Ts)> anonymous_namespace{RelAlgTranslator.cpp}::makeHandlers ( )

Definition at line 185 of file RelAlgTranslator.cpp.

Referenced by RelAlgTranslator::translateScalarRex().

                                                        {
   return {IndexedHandler{std::type_index(typeid(Ts)),
                          &RelAlgTranslator::translateRexScalar<Ts>}...};
 }

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Constant> anonymous_namespace{RelAlgTranslator.cpp}::makeNumericConstant	(	const SQLTypeInfo &	ti,
		const long	val
	)

Definition at line 1193 of file RelAlgTranslator.cpp.

References CHECK, exp_to_scale(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_type(), SQLTypeInfo::is_number(), kBIGINT, kDECIMAL, kDOUBLE, kFLOAT, kINT, kNUMERIC, kSMALLINT, and kTINYINT.

Referenced by RelAlgTranslator::translateAbs(), RelAlgTranslator::translateCardinality(), RelAlgTranslator::translateDatePlusMinus(), and RelAlgTranslator::translateSign().

                                                                         {
   CHECK(ti.is_number());
   Datum datum{0};
   switch (ti.get_type()) {
     case kTINYINT: {
       datum.tinyintval = val;
       break;
     }
     case kSMALLINT: {
       datum.smallintval = val;
       break;
     }
     case kINT: {
       datum.intval = val;
       break;
     }
     case kBIGINT: {
       datum.bigintval = val;
       break;
     }
     case kDECIMAL:
     case kNUMERIC: {
       datum.bigintval = val * exp_to_scale(ti.get_scale());
       break;
     }
     case kFLOAT: {
       datum.floatval = val;
       break;
     }
     case kDOUBLE: {
       datum.doubleval = val;
       break;
     }
     default:
       CHECK(false);
   }
   return makeExpr<Analyzer::Constant>(ti, false, datum);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<Analyzer::OrderEntry> anonymous_namespace{RelAlgTranslator.cpp}::translate_collation ( const std::vector< SortField > & sort_fields )

Definition at line 1987 of file RelAlgTranslator.cpp.

References Descending, and First.

Referenced by RelAlgTranslator::translateWindowFunction().

                                              {
   std::vector<Analyzer::OrderEntry> collation;
   for (size_t i = 0; i < sort_fields.size(); ++i) {
     const auto& sort_field = sort_fields[i];
     collation.emplace_back(i,
                            sort_field.getSortDir() == SortDirection::Descending,
                            sort_field.getNullsPosition() == NullSortedPosition::First);
   }
   return collation;
 }

Here is the caller graph for this function:

void anonymous_namespace{RelAlgTranslator.cpp}::validate_datetime_datepart_argument ( const std::shared_ptr< Analyzer::Constant > literal_expr )

inline

Definition at line 1167 of file RelAlgTranslator.cpp.

Referenced by RelAlgTranslator::translateDateadd(), RelAlgTranslator::translateDatediff(), RelAlgTranslator::translateDatepart(), and RelAlgTranslator::translateExtract().

                                                         {
   if (!literal_expr || literal_expr->get_is_null()) {
     throw std::runtime_error("The 'DatePart' argument must be a not 'null' literal.");
   }
 }

Here is the caller graph for this function:

Variable Documentation

const size_t anonymous_namespace{RelAlgTranslator.cpp}::g_max_integer_set_size {1 << 25}

Definition at line 752 of file RelAlgTranslator.cpp.

Referenced by fill_dictionary_encoded_in_vals(), and fill_integer_in_vals().

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation