anonymous_namespace{GroupByAndAggregate.cpp} Namespace Reference

Functions
int32_t	get_agg_count (const std::vector< Analyzer::Expr * > &target_exprs)
bool	expr_is_rowid (const Analyzer::Expr *expr)
bool	has_count_distinct (const RelAlgExecutionUnit &ra_exe_unit)
bool	is_column_range_too_big_for_perfect_hash (const ColRangeInfo &col_range_info, const int64_t max_entry_count)
bool	cardinality_estimate_less_than_column_range (const int64_t cardinality_estimate, const ColRangeInfo &col_range_info)
ColRangeInfo	get_expr_range_info (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const Analyzer::Expr *expr, Executor *executor)
int64_t	get_bucketed_cardinality_without_nulls (const ColRangeInfo &col_range_info)
KeylessInfo	get_keyless_info (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const bool is_group_by, Executor *executor)
CountDistinctDescriptors	init_count_distinct_descriptors (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const ColRangeInfo &group_by_range_info, const ExecutorDeviceType device_type, Executor *executor)

Function Documentation

bool anonymous_namespace{GroupByAndAggregate.cpp}::cardinality_estimate_less_than_column_range	(	const int64_t	cardinality_estimate,
		const ColRangeInfo &	col_range_info
	)

Definition at line 161 of file GroupByAndAggregate.cpp.

References ColRangeInfo::max, and ColRangeInfo::min.

Referenced by GroupByAndAggregate::getColRangeInfo().

                                                                                     {
  try {
    // the cardinality estimate is the size of the baseline hash table. further penalize
    // the baseline hash table by a factor of 2x due to overhead in computing baseline
    // hash. This has the overall effect of penalizing baseline hash over perfect hash by
    // 4x; i.e. if the cardinality of the filtered data is less than 25% of the entry
    // count of the column, we use baseline hash on the filtered set
    return checked_int64_t(cardinality_estimate) * 2 <
           static_cast<int64_t>(checked_int64_t(col_range_info.max) -
                                checked_int64_t(col_range_info.min));
  } catch (...) {
    return false;
  }
}

Here is the caller graph for this function:

bool anonymous_namespace{GroupByAndAggregate.cpp}::expr_is_rowid

(

const Analyzer::Expr *

expr

)

Definition at line 128 of file GroupByAndAggregate.cpp.

References CHECK_EQ, and get_column_descriptor_maybe().

Referenced by GroupByAndAggregate::getColRangeInfo().

                                             {
  const auto col = dynamic_cast<const Analyzer::ColumnVar*>(expr);
  if (!col) {
    return false;
  }
  const auto cd = get_column_descriptor_maybe(col->getColumnKey());
  if (!cd || !cd->isVirtualCol) {
    return false;
  }
  CHECK_EQ("rowid", cd->columnName);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t anonymous_namespace{GroupByAndAggregate.cpp}::get_agg_count

(

const std::vector< Analyzer::Expr * > &

target_exprs

)

Definition at line 103 of file GroupByAndAggregate.cpp.

References agg_count(), CHECK, Analyzer::Expr::get_type_info(), kAVG, and kSAMPLE.

Referenced by GroupByAndAggregate::codegen().

                                                                    {
  int32_t agg_count{0};
  for (auto target_expr : target_exprs) {
    CHECK(target_expr);
    const auto agg_expr = dynamic_cast<Analyzer::AggExpr*>(target_expr);
    if (!agg_expr || agg_expr->get_aggtype() == kSAMPLE) {
      const auto& ti = target_expr->get_type_info();
      if (ti.is_buffer()) {
        agg_count += 2;
      } else if (ti.is_geometry()) {
        agg_count += ti.get_physical_coord_cols() * 2;
      } else {
        ++agg_count;
      }
      continue;
    }
    if (agg_expr && agg_expr->get_aggtype() == kAVG) {
      agg_count += 2;
    } else {
      ++agg_count;
    }
  }
  return agg_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t anonymous_namespace{GroupByAndAggregate.cpp}::get_bucketed_cardinality_without_nulls

(

const ColRangeInfo &

col_range_info

)

Definition at line 368 of file GroupByAndAggregate.cpp.

References ColRangeInfo::bucket, ColRangeInfo::max, and ColRangeInfo::min.

Referenced by init_count_distinct_descriptors().

                                                                                   {
  if (col_range_info.min <= col_range_info.max) {
    size_t size = col_range_info.max - col_range_info.min;
    if (col_range_info.bucket) {
      size /= col_range_info.bucket;
    }
    if (size >= static_cast<size_t>(std::numeric_limits<int64_t>::max())) {
      // try to use unordered_set instead of crashing due to CHECK failure
      // i.e., CHECK_LT(size, std::numeric_limits<int64_t>::max());
      return 0;
    }
    return static_cast<int64_t>(size + 1);
  } else {
    return 0;
  }
}

Here is the caller graph for this function:

ColRangeInfo anonymous_namespace{GroupByAndAggregate.cpp}::get_expr_range_info	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const std::vector< InputTableInfo > &	query_infos,
		const Analyzer::Expr *	expr,
		Executor *	executor
	)

Definition at line 177 of file GroupByAndAggregate.cpp.

References CHECK, Double, Float, getExpressionRange(), heavyai::GroupByBaselineHash, heavyai::GroupByPerfectHash, Integer, Invalid, heavyai::NonGroupedAggregate, heavyai::Projection, and RelAlgExecutionUnit::simple_quals.

Referenced by GroupByAndAggregate::codegenGroupBy(), GroupByAndAggregate::codegenPerfectHashFunction(), GroupByAndAggregate::getColRangeInfo(), GroupByAndAggregate::gpuCanHandleOrderEntries(), and init_count_distinct_descriptors().

                                                     {
  if (!expr) {
    return {QueryDescriptionType::Projection, 0, 0, 0, false};
  }

  const auto expr_range = getExpressionRange(
      expr, query_infos, executor, boost::make_optional(ra_exe_unit.simple_quals));
  switch (expr_range.getType()) {
    case ExpressionRangeType::Integer: {
      if (expr_range.getIntMin() > expr_range.getIntMax()) {
        return {
            QueryDescriptionType::GroupByBaselineHash, 0, -1, 0, expr_range.hasNulls()};
      }
      return {QueryDescriptionType::GroupByPerfectHash,
              expr_range.getIntMin(),
              expr_range.getIntMax(),
              expr_range.getBucket(),
              expr_range.hasNulls()};
    }
    case ExpressionRangeType::Float:
    case ExpressionRangeType::Double: {
      if (expr_range.getFpMin() > expr_range.getFpMax()) {
        return {
            QueryDescriptionType::GroupByBaselineHash, 0, -1, 0, expr_range.hasNulls()};
      }
      return {QueryDescriptionType::GroupByBaselineHash, 0, 0, 0, false};
    }
    case ExpressionRangeType::Invalid:
      return {QueryDescriptionType::GroupByBaselineHash, 0, 0, 0, false};
    default:
      CHECK(false);
  }
  CHECK(false);
  return {QueryDescriptionType::NonGroupedAggregate, 0, 0, 0, false};
}

Here is the call graph for this function:

Here is the caller graph for this function:

KeylessInfo anonymous_namespace{GroupByAndAggregate.cpp}::get_keyless_info	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const std::vector< InputTableInfo > &	query_infos,
		const bool	is_group_by,
		Executor *	executor
	)

This function goes through all target expressions and answers two questions:

1. Is it possible to have keyless hash?
2. If yes to 1, then what aggregate expression should be considered to represent the key's presence, if needed (e.g., in detecting empty entries in the result set).

NOTE: Keyless hash is only valid with single-column group by at the moment.

Definition at line 478 of file GroupByAndAggregate.cpp.

References agg_arg(), CHECK, constrained_not_null(), Double, Float, g_bigint_count, get_agg_initial_val(), get_compact_type(), get_target_info(), getExpressionRange(), Integer, Invalid, is_distinct_target(), kAVG, kCOUNT, kMAX, kMIN, kSUM, RelAlgExecutionUnit::quals, takes_float_argument(), and RelAlgExecutionUnit::target_exprs.

Referenced by GroupByAndAggregate::initQueryMemoryDescriptorImpl().

                                                 {
  bool keyless{true}, found{false};
  int32_t num_agg_expr{0};
  int32_t index{0};
  for (const auto target_expr : ra_exe_unit.target_exprs) {
    const auto agg_info = get_target_info(target_expr, g_bigint_count);
    const auto chosen_type = get_compact_type(agg_info);
    if (agg_info.is_agg) {
      num_agg_expr++;
    }
    if (!found && agg_info.is_agg && !is_distinct_target(agg_info)) {
      auto agg_expr = dynamic_cast<const Analyzer::AggExpr*>(target_expr);
      CHECK(agg_expr);
      const auto arg_expr = agg_arg(target_expr);
      const bool float_argument_input = takes_float_argument(agg_info);
      switch (agg_info.agg_kind) {
        case kAVG:
          ++index;
          if (arg_expr && !arg_expr->get_type_info().get_notnull()) {
            auto expr_range_info = getExpressionRange(arg_expr, query_infos, executor);
            if (expr_range_info.getType() == ExpressionRangeType::Invalid ||
                expr_range_info.hasNulls()) {
              break;
            }
          }
          found = true;
          break;
        case kCOUNT:
          if (arg_expr && !arg_expr->get_type_info().get_notnull()) {
            auto expr_range_info = getExpressionRange(arg_expr, query_infos, executor);
            if (expr_range_info.getType() == ExpressionRangeType::Invalid ||
                expr_range_info.hasNulls()) {
              break;
            }
          }
          found = true;
          break;
        case kSUM: {
          auto arg_ti = arg_expr->get_type_info();
          if (constrained_not_null(arg_expr, ra_exe_unit.quals)) {
            arg_ti.set_notnull(true);
          }
          if (!arg_ti.get_notnull()) {
            auto expr_range_info = getExpressionRange(arg_expr, query_infos, executor);
            if (expr_range_info.getType() != ExpressionRangeType::Invalid &&
                !expr_range_info.hasNulls()) {
              found = true;
            }
          } else {
            auto expr_range_info = getExpressionRange(arg_expr, query_infos, executor);
            switch (expr_range_info.getType()) {
              case ExpressionRangeType::Float:
              case ExpressionRangeType::Double:
                if (expr_range_info.getFpMax() < 0 || expr_range_info.getFpMin() > 0) {
                  found = true;
                }
                break;
              case ExpressionRangeType::Integer:
                if (expr_range_info.getIntMax() < 0 || expr_range_info.getIntMin() > 0) {
                  found = true;
                }
                break;
              default:
                break;
            }
          }
          break;
        }
        case kMIN: {
          CHECK(agg_expr && agg_expr->get_arg());
          const auto& arg_ti = agg_expr->get_arg()->get_type_info();
          if (arg_ti.is_string() || arg_ti.is_buffer()) {
            break;
          }
          auto expr_range_info =
              getExpressionRange(agg_expr->get_arg(), query_infos, executor);
          auto init_max = get_agg_initial_val(agg_info.agg_kind,
                                              chosen_type,
                                              is_group_by || float_argument_input,
                                              float_argument_input ? sizeof(float) : 8);
          switch (expr_range_info.getType()) {
            case ExpressionRangeType::Float:
            case ExpressionRangeType::Double: {
              auto double_max =
                  *reinterpret_cast<const double*>(may_alias_ptr(&init_max));
              if (expr_range_info.getFpMax() < double_max) {
                found = true;
              }
              break;
            }
            case ExpressionRangeType::Integer:
              if (expr_range_info.getIntMax() < init_max) {
                found = true;
              }
              break;
            default:
              break;
          }
          break;
        }
        case kMAX: {
          CHECK(agg_expr && agg_expr->get_arg());
          const auto& arg_ti = agg_expr->get_arg()->get_type_info();
          if (arg_ti.is_string() || arg_ti.is_buffer()) {
            break;
          }
          auto expr_range_info =
              getExpressionRange(agg_expr->get_arg(), query_infos, executor);
          // NULL sentinel and init value for kMAX are identical, which results in
          // ambiguity in detecting empty keys in presence of nulls.
          if (expr_range_info.getType() == ExpressionRangeType::Invalid ||
              expr_range_info.hasNulls()) {
            break;
          }
          auto init_min = get_agg_initial_val(agg_info.agg_kind,
                                              chosen_type,
                                              is_group_by || float_argument_input,
                                              float_argument_input ? sizeof(float) : 8);
          switch (expr_range_info.getType()) {
            case ExpressionRangeType::Float:
            case ExpressionRangeType::Double: {
              auto double_min =
                  *reinterpret_cast<const double*>(may_alias_ptr(&init_min));
              if (expr_range_info.getFpMin() > double_min) {
                found = true;
              }
              break;
            }
            case ExpressionRangeType::Integer:
              if (expr_range_info.getIntMin() > init_min) {
                found = true;
              }
              break;
            default:
              break;
          }
          break;
        }
        default:
          keyless = false;
          break;
      }
    }
    if (!keyless) {
      break;
    }
    if (!found) {
      ++index;
    }
  }

  // shouldn't use keyless for projection only
  return {
      keyless && found,
      index,
  };
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{GroupByAndAggregate.cpp}::has_count_distinct

(

const RelAlgExecutionUnit &

ra_exe_unit

)

Definition at line 141 of file GroupByAndAggregate.cpp.

References g_bigint_count, get_target_info(), is_distinct_target(), and RelAlgExecutionUnit::target_exprs.

Referenced by GroupByAndAggregate::getColRangeInfo().

                                                                {
  for (const auto& target_expr : ra_exe_unit.target_exprs) {
    const auto agg_info = get_target_info(target_expr, g_bigint_count);
    if (agg_info.is_agg && is_distinct_target(agg_info)) {
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CountDistinctDescriptors anonymous_namespace{GroupByAndAggregate.cpp}::init_count_distinct_descriptors	(	const RelAlgExecutionUnit &	ra_exe_unit,
		const std::vector< InputTableInfo > &	query_infos,
		const ColRangeInfo &	group_by_range_info,
		const ExecutorDeviceType	device_type,
		Executor *	executor
	)

Definition at line 639 of file GroupByAndAggregate.cpp.

References align_to_int64(), Bitmap, ColRangeInfo::bucket, CHECK, CHECK_GE, Analyzer::ColumnVar::collect_column_var(), Analyzer::ColumnVar::colvar_comp(), g_bigint_count, g_bitmap_memory_limit, g_enable_watchdog, g_hll_precision_bits, Analyzer::AggExpr::get_arg(), get_bucketed_cardinality_without_nulls(), get_count_distinct_sub_bitmap_count(), DateConverters::get_epoch_days_from_seconds(), get_expr_range_info(), get_target_info(), Analyzer::Expr::get_type_info(), GPU, heavyai::GroupByPerfectHash, hll_size_for_rate(), Invalid, is_distinct_target(), kAPPROX_COUNT_DISTINCT, kCOUNT, kDATE, kENCODING_DATE_IN_DAYS, kINT, ColRangeInfo::max, ColRangeInfo::min, heavyai::Projection, RelAlgExecutionUnit::target_exprs, RelAlgExecutionUnit::target_exprs_original_type_infos, and UnorderedSet.

Referenced by GroupByAndAggregate::initQueryMemoryDescriptorImpl().

                        {
  CountDistinctDescriptors count_distinct_descriptors;
  auto compute_bytes_per_group =
      [](size_t bitmap_sz, size_t sub_bitmap_count, ExecutorDeviceType device_type) {
        size_t effective_size_bytes = (bitmap_sz + 7) / 8;
        const auto padded_size =
            (device_type == ExecutorDeviceType::GPU || sub_bitmap_count > 1)
                ? align_to_int64(effective_size_bytes)
                : effective_size_bytes;
        return padded_size * sub_bitmap_count;
      };
  for (size_t i = 0; i < ra_exe_unit.target_exprs.size(); i++) {
    const auto target_expr = ra_exe_unit.target_exprs[i];
    auto agg_info = get_target_info(target_expr, g_bigint_count);
    if (is_distinct_target(agg_info)) {
      CHECK(agg_info.is_agg);
      CHECK(agg_info.agg_kind == kCOUNT || agg_info.agg_kind == kAPPROX_COUNT_DISTINCT);
      const auto agg_expr = static_cast<const Analyzer::AggExpr*>(target_expr);
      const auto& arg_ti = agg_expr->get_arg()->get_type_info();
      if (arg_ti.is_text_encoding_none()) {
        throw std::runtime_error(
            "Strings must be dictionary-encoded for COUNT(DISTINCT).");
      }
      if (agg_info.agg_kind == kAPPROX_COUNT_DISTINCT && arg_ti.is_buffer()) {
        throw std::runtime_error("APPROX_COUNT_DISTINCT on arrays not supported yet");
      }
      if (agg_info.agg_kind == kAPPROX_COUNT_DISTINCT && arg_ti.is_geometry()) {
        throw std::runtime_error(
            "APPROX_COUNT_DISTINCT on geometry columns not supported");
      }
      if (agg_info.is_distinct && arg_ti.is_geometry()) {
        throw std::runtime_error("COUNT DISTINCT on geometry columns not supported");
      }
      ColRangeInfo no_range_info{QueryDescriptionType::Projection, 0, 0, 0, false};
      auto arg_range_info =
          arg_ti.is_fp() ? no_range_info
                         : get_expr_range_info(
                               ra_exe_unit, query_infos, agg_expr->get_arg(), executor);
      const auto it = ra_exe_unit.target_exprs_original_type_infos.find(i);
      if (it != ra_exe_unit.target_exprs_original_type_infos.end()) {
        const auto& original_target_expr_ti = it->second;
        if (arg_ti.is_integer() && original_target_expr_ti.get_type() == kDATE &&
            original_target_expr_ti.get_compression() == kENCODING_DATE_IN_DAYS) {
          // manually encode the col range of date col if necessary
          // (see conditionally_change_arg_to_int_type function in RelAlgExecutor.cpp)
          auto is_date_value_not_encoded = [&original_target_expr_ti](int64_t date_val) {
            if (original_target_expr_ti.get_comp_param() == 16) {
              return date_val < INT16_MIN || date_val > INT16_MAX;
            } else {
              return date_val < INT32_MIN || date_val > INT32_MIN;
            }
          };
          if (is_date_value_not_encoded(arg_range_info.min)) {
            // chunk metadata of the date column contains decoded value
            // so we manually encode it again here to represent its column range correctly
            arg_range_info.min =
                DateConverters::get_epoch_days_from_seconds(arg_range_info.min);
          }
          if (is_date_value_not_encoded(arg_range_info.max)) {
            arg_range_info.max =
                DateConverters::get_epoch_days_from_seconds(arg_range_info.max);
          }
          // now we manually encode the value, so we need to invalidate bucket value
          // i.e., 86000 -> 0, to correctly calculate the size of bitmap
          arg_range_info.bucket = 0;
        }
      }

      CountDistinctImplType count_distinct_impl_type{CountDistinctImplType::UnorderedSet};
      int64_t bitmap_sz_bits{0};
      if (agg_info.agg_kind == kAPPROX_COUNT_DISTINCT) {
        const auto error_rate_expr = agg_expr->get_arg1();
        if (error_rate_expr) {
          CHECK(error_rate_expr->get_type_info().get_type() == kINT);
          auto const error_rate =
              dynamic_cast<Analyzer::Constant const*>(error_rate_expr.get());
          CHECK(error_rate);
          CHECK_GE(error_rate->get_constval().intval, 1);
          bitmap_sz_bits = hll_size_for_rate(error_rate->get_constval().smallintval);
        } else {
          bitmap_sz_bits = g_hll_precision_bits;
        }
      }
      if (arg_range_info.isEmpty()) {
        count_distinct_descriptors.emplace_back(
            CountDistinctDescriptor{CountDistinctImplType::Bitmap,
                                    0,
                                    arg_range_info.bucket,
                                    64,
                                    agg_info.agg_kind == kAPPROX_COUNT_DISTINCT,
                                    device_type,
                                    1});
        continue;
      }
      const auto sub_bitmap_count =
          get_count_distinct_sub_bitmap_count(bitmap_sz_bits, ra_exe_unit, device_type);
      size_t worst_case_num_groups{1};
      if (arg_range_info.hash_type_ == QueryDescriptionType::GroupByPerfectHash &&
          !(arg_ti.is_buffer() || arg_ti.is_geometry())) {  // TODO(alex): allow bitmap
                                                            // implementation for arrays
        count_distinct_impl_type = CountDistinctImplType::Bitmap;
        if (shared::is_any<kCOUNT, kCOUNT_IF>(agg_info.agg_kind)) {
          bitmap_sz_bits = get_bucketed_cardinality_without_nulls(arg_range_info);
          if (bitmap_sz_bits <= 0 || g_bitmap_memory_limit <= bitmap_sz_bits) {
            count_distinct_impl_type = CountDistinctImplType::UnorderedSet;
          }
          // check a potential OOM when using bitmap-based approach
          const auto total_bytes_per_entry =
              compute_bytes_per_group(bitmap_sz_bits, sub_bitmap_count, device_type);
          const auto range_bucket = std::max(group_by_range_info.bucket, (int64_t)1);
          const auto maximum_num_groups =
              (group_by_range_info.max - group_by_range_info.min + 1) / range_bucket;
          const auto total_bitmap_bytes_for_groups =
              total_bytes_per_entry * maximum_num_groups;
          // we can estimate a potential OOM of bitmap-based count-distinct operator
          // by using the logic "check_total_bitmap_memory"
          if (total_bitmap_bytes_for_groups >=
              static_cast<size_t>(g_bitmap_memory_limit)) {
            const auto agg_expr_max_entry_count =
                arg_range_info.max - arg_range_info.min + 1;
            int64_t max_agg_expr_table_cardinality{1};
            std::set<const Analyzer::ColumnVar*,
                     bool (*)(const Analyzer::ColumnVar*, const Analyzer::ColumnVar*)>
                colvar_set(Analyzer::ColumnVar::colvar_comp);
            agg_expr->collect_column_var(colvar_set, true);
            for (const auto cv : colvar_set) {
              auto it =
                  std::find_if(query_infos.begin(),
                               query_infos.end(),
                               [&](const auto& input_table_info) {
                                 return input_table_info.table_key == cv->getTableKey();
                               });
              int64_t cur_table_cardinality =
                  it != query_infos.end()
                      ? static_cast<int64_t>(it->info.getNumTuplesUpperBound())
                      : -1;
              max_agg_expr_table_cardinality =
                  std::max(max_agg_expr_table_cardinality, cur_table_cardinality);
              worst_case_num_groups *= cur_table_cardinality;
            }
            auto has_valid_stat = [agg_expr_max_entry_count, maximum_num_groups]() {
              return agg_expr_max_entry_count > 0 && maximum_num_groups > 0;
            };
            // if we have valid stats regarding input expr, we can try to relax the OOM
            if (has_valid_stat()) {
              // a threshold related to a ratio of a range of agg expr (let's say R)
              // and table cardinality (C), i.e., use unordered_set if the # bits to build
              // a bitmap based on R is four times larger than that of C
              const size_t unordered_set_threshold{2};
              // When we detect OOM of bitmap-based approach we selectively switch it to
              // hash set-based processing logic if one of the followings is satisfied:
              // 1) the column range is too wide compared with the table cardinality, or
              // 2) the column range is too wide compared with the avg of # unique values
              // per group by entry
              const auto bits_for_agg_entry = std::ceil(log(agg_expr_max_entry_count));
              const auto bits_for_agg_table =
                  std::ceil(log(max_agg_expr_table_cardinality));
              const auto avg_num_unique_entries_per_group =
                  std::ceil(max_agg_expr_table_cardinality / maximum_num_groups);
              // case a) given a range of entry count of agg_expr and the maximum
              // cardinality among source tables of the agg_expr , we try to detect the
              // misleading case of too sparse column range , i.e., agg_expr has 1M column
              // range but only has two tuples {1 and 1M} / case b) check whether
              // using bitmap is really beneficial when considering uniform distribution
              // of (unique) keys.
              if ((bits_for_agg_entry - bits_for_agg_table) >= unordered_set_threshold ||
                  agg_expr_max_entry_count >= avg_num_unique_entries_per_group) {
                count_distinct_impl_type = CountDistinctImplType::UnorderedSet;
              } else {
                throw std::runtime_error(
                    "Consider using approx_count_distinct operator instead of "
                    "count_distinct operator to lower the memory "
                    "requirements");
              }
            }
          }
        }
      }
      if (agg_info.agg_kind == kAPPROX_COUNT_DISTINCT &&
          count_distinct_impl_type == CountDistinctImplType::UnorderedSet &&
          !(arg_ti.is_array() || arg_ti.is_geometry())) {
        count_distinct_impl_type = CountDistinctImplType::Bitmap;
      }
      const size_t too_many_entries{100000000};
      if (g_enable_watchdog && !(arg_range_info.isEmpty()) &&
          worst_case_num_groups > too_many_entries &&
          count_distinct_impl_type == CountDistinctImplType::UnorderedSet) {
        throw WatchdogException(
            "Detect too many input entries for set-based count distinct operator under "
            "the watchdog");
      }
      count_distinct_descriptors.emplace_back(
          CountDistinctDescriptor{count_distinct_impl_type,
                                  arg_range_info.min,
                                  arg_range_info.bucket,
                                  bitmap_sz_bits,
                                  agg_info.agg_kind == kAPPROX_COUNT_DISTINCT,
                                  device_type,
                                  sub_bitmap_count});
    } else {
      count_distinct_descriptors.emplace_back(CountDistinctDescriptor{
          CountDistinctImplType::Invalid, 0, 0, 0, false, device_type, 0});
    }
  }
  return count_distinct_descriptors;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{GroupByAndAggregate.cpp}::is_column_range_too_big_for_perfect_hash	(	const ColRangeInfo &	col_range_info,
		const int64_t	max_entry_count
	)

Definition at line 151 of file GroupByAndAggregate.cpp.

References ColRangeInfo::max, and ColRangeInfo::min.

Referenced by GroupByAndAggregate::getColRangeInfo().

                                                                             {
  try {
    return static_cast<int64_t>(checked_int64_t(col_range_info.max) -
                                checked_int64_t(col_range_info.min)) >= max_entry_count;
  } catch (...) {
    return true;
  }
}

Here is the caller graph for this function: