anonymous_namespace{WindowContext.cpp} Namespace Reference

Classes
struct	FindNullRange

Functions
std::vector< int64_t >	index_to_row_number (const int64_t *index, const size_t index_size)
bool	advance_current_rank (const std::function< bool(const int64_t lhs, const int64_t rhs)> &comparator, const int64_t *index, const size_t i)
std::vector< int64_t >	index_to_rank (const int64_t *index, const size_t index_size, const std::function< bool(const int64_t lhs, const int64_t rhs)> &comparator)
std::vector< int64_t >	index_to_dense_rank (const int64_t *index, const size_t index_size, const std::function< bool(const int64_t lhs, const int64_t rhs)> &comparator)
std::vector< double >	index_to_percent_rank (const int64_t *index, const size_t index_size, const std::function< bool(const int64_t lhs, const int64_t rhs)> &comparator)
std::vector< double >	index_to_cume_dist (const int64_t *index, const size_t index_size, const std::function< bool(const int64_t lhs, const int64_t rhs)> &comparator)
std::vector< int64_t >	index_to_ntile (const int64_t *index, const size_t index_size, const size_t n)
size_t	window_function_buffer_element_size (const SqlWindowFunctionKind)
size_t	get_int_constant_from_expr (const Analyzer::Expr *expr)
int64_t	get_lag_or_lead_argument (const Analyzer::WindowFunction *window_func)
size_t	get_target_idx_for_first_or_last_value_func (const Analyzer::WindowFunction *window_func, const size_t partition_size)
void	apply_permutation_to_partition (int64_t *output_for_partition_buff, const int32_t *original_indices, const size_t partition_size)
void	apply_lag_to_partition (const int64_t lag, const int32_t *original_indices, int64_t *sorted_indices, const size_t partition_size)
void	apply_nth_value_to_partition (const int32_t *original_indices, int64_t *output_for_partition_buff, const size_t partition_size, const size_t target_pos)
void	apply_original_index_to_partition (const int32_t *original_indices, int64_t *output_for_partition_buff, const size_t partition_size)
void	index_to_partition_end (const int8_t *partition_end, const size_t off, const int64_t *index, const size_t index_size, const std::function< bool(const int64_t lhs, const int64_t rhs)> &comparator)
bool	pos_is_set (const int64_t bitset, const int64_t pos)
template<class T >
void	apply_window_pending_outputs_int (const int64_t handle, const int64_t value, const int64_t bitset, const int64_t pos)
template<class T >
WindowFunctionContext::WindowComparatorResult	integer_comparator_asc (const int8_t *order_column_buffer, const SQLTypeInfo &ti, const int32_t *partition_indices, const int64_t lhs, const int64_t rhs, const bool asc_ordering, const bool nulls_first)
template<class T >
WindowFunctionContext::WindowComparatorResult	integer_comparator_desc (const int8_t *order_column_buffer, const SQLTypeInfo &ti, const int32_t *partition_indices, const int64_t lhs, const int64_t rhs, const bool asc_ordering, const bool nulls_first)
template<class T , class NullPatternType >
WindowFunctionContext::WindowComparatorResult	fp_comparator_asc (const int8_t *order_column_buffer, const SQLTypeInfo &ti, const int32_t *partition_indices, const int64_t lhs, const int64_t rhs, const bool asc_ordering, const bool nulls_first)
template<class T , class NullPatternType >
WindowFunctionContext::WindowComparatorResult	fp_comparator_desc (const int8_t *order_column_buffer, const SQLTypeInfo &ti, const int32_t *partition_indices, const int64_t lhs, const int64_t rhs, const bool asc_ordering, const bool nulls_first)
bool	allow_framing_on_time_or_date (SqlWindowFunctionKind kind)

Function Documentation

bool anonymous_namespace{WindowContext.cpp}::advance_current_rank	(	const std::function< bool(const int64_t lhs, const int64_t rhs)> &	comparator,
		const int64_t *	index,
		const size_t	i
	)

Definition at line 205 of file WindowContext.cpp.

Referenced by index_to_cume_dist(), index_to_dense_rank(), index_to_partition_end(), index_to_percent_rank(), and index_to_rank().

                    {
  if (i == 0) {
    return false;
  }
  return comparator(index[i - 1], index[i]);
}

Here is the caller graph for this function:

bool anonymous_namespace{WindowContext.cpp}::allow_framing_on_time_or_date

(

SqlWindowFunctionKind

kind

)

Definition at line 1463 of file WindowContext.cpp.

References CONDITIONAL_CHANGE_EVENT.

Referenced by WindowFunctionContext::buildAggregationTreeForPartition().

                                                               {
  switch (kind) {
    case SqlWindowFunctionKind::CONDITIONAL_CHANGE_EVENT:
      return true;
    default:
      return false;
  }
}

Here is the caller graph for this function:

void anonymous_namespace{WindowContext.cpp}::apply_lag_to_partition	(	const int64_t	lag,
		const int32_t *	original_indices,
		int64_t *	sorted_indices,
		const size_t	partition_size
	)

Definition at line 373 of file WindowContext.cpp.

References gpu_enabled::copy().

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                         {
  std::vector<int64_t> lag_sorted_indices(partition_size, -1);
  for (int64_t idx = 0; idx < static_cast<int64_t>(partition_size); ++idx) {
    int64_t lag_idx = idx - lag;
    if (lag_idx < 0 || lag_idx >= static_cast<int64_t>(partition_size)) {
      continue;
    }
    lag_sorted_indices[idx] = sorted_indices[lag_idx];
  }
  std::vector<int64_t> lag_original_indices(partition_size);
  for (size_t k = 0; k < partition_size; ++k) {
    const auto lag_index = lag_sorted_indices[k];
    lag_original_indices[sorted_indices[k]] =
        lag_index != -1 ? original_indices[lag_index] : -1;
  }
  std::copy(lag_original_indices.begin(), lag_original_indices.end(), sorted_indices);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{WindowContext.cpp}::apply_nth_value_to_partition	(	const int32_t *	original_indices,
		int64_t *	output_for_partition_buff,
		const size_t	partition_size,
		const size_t	target_pos
	)

Definition at line 394 of file WindowContext.cpp.

References CHECK_LT, and gpu_enabled::fill().

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                           {
  CHECK_LT(target_pos, partition_size);
  const auto target_idx = original_indices[output_for_partition_buff[target_pos]];
  std::fill(
      output_for_partition_buff, output_for_partition_buff + partition_size, target_idx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{WindowContext.cpp}::apply_original_index_to_partition	(	const int32_t *	original_indices,
		int64_t *	output_for_partition_buff,
		const size_t	partition_size
	)

Definition at line 404 of file WindowContext.cpp.

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                    {
  for (size_t i = 0; i < partition_size; i++) {
    const auto target_idx = original_indices[output_for_partition_buff[i]];
    output_for_partition_buff[i] = target_idx;
  }
}

Here is the caller graph for this function:

void anonymous_namespace{WindowContext.cpp}::apply_permutation_to_partition	(	int64_t *	output_for_partition_buff,
		const int32_t *	original_indices,
		const size_t	partition_size
	)

Definition at line 360 of file WindowContext.cpp.

References gpu_enabled::copy().

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                 {
  std::vector<int64_t> new_output_for_partition_buff(partition_size);
  for (size_t i = 0; i < partition_size; ++i) {
    new_output_for_partition_buff[i] = original_indices[output_for_partition_buff[i]];
  }
  std::copy(new_output_for_partition_buff.begin(),
            new_output_for_partition_buff.end(),
            output_for_partition_buff);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

void anonymous_namespace{WindowContext.cpp}::apply_window_pending_outputs_int	(	const int64_t	handle,
		const int64_t	value,
		const int64_t	bitset,
		const int64_t	pos
	)

Definition at line 436 of file WindowContext.cpp.

References pos_is_set(), and heavydb.dtypes::T.

                                                         {
  if (!pos_is_set(bitset, pos)) {
    return;
  }
  auto& pending_output_slots = *reinterpret_cast<std::vector<void*>*>(handle);
  for (auto pending_output_slot : pending_output_slots) {
    *reinterpret_cast<T*>(pending_output_slot) = value;
  }
  pending_output_slots.clear();
}

Here is the call graph for this function:

template<class T , class NullPatternType >

WindowFunctionContext::WindowComparatorResult anonymous_namespace{WindowContext.cpp}::fp_comparator_asc	(	const int8_t *	order_column_buffer,
		const SQLTypeInfo &	ti,
		const int32_t *	partition_indices,
		const int64_t	lhs,
		const int64_t	rhs,
		const bool	asc_ordering,
		const bool	nulls_first
	)

Definition at line 1099 of file WindowContext.cpp.

References WindowFunctionContext::EQ, SQLTypeInfo::get_type(), WindowFunctionContext::GT, kFLOAT, WindowFunctionContext::LT, null_val_bit_pattern(), and heavydb.dtypes::T.

                            {
  const auto values = reinterpret_cast<const T*>(order_column_buffer);
  const auto lhs_val = values[partition_indices[lhs]];
  const auto rhs_val = values[partition_indices[rhs]];
  const auto null_bit_pattern = null_val_bit_pattern(ti, ti.get_type() == kFLOAT);
  const auto lhs_bit_pattern =
      *reinterpret_cast<const NullPatternType*>(may_alias_ptr(&lhs_val));
  const auto rhs_bit_pattern =
      *reinterpret_cast<const NullPatternType*>(may_alias_ptr(&rhs_val));
  if (lhs_bit_pattern == null_bit_pattern && rhs_bit_pattern == null_bit_pattern) {
    return WindowFunctionContext::WindowComparatorResult::EQ;
  }
  if (lhs_bit_pattern == null_bit_pattern && rhs_bit_pattern != null_bit_pattern) {
    return nulls_first ? WindowFunctionContext::WindowComparatorResult::LT
                       : WindowFunctionContext::WindowComparatorResult::GT;
  }
  if (rhs_bit_pattern == null_bit_pattern && lhs_bit_pattern != null_bit_pattern) {
    return !nulls_first ? WindowFunctionContext::WindowComparatorResult::LT
                        : WindowFunctionContext::WindowComparatorResult::GT;
  }
  if (lhs_val < rhs_val) {
    return WindowFunctionContext::WindowComparatorResult::LT;
  }
  if (lhs_val > rhs_val) {
    return WindowFunctionContext::WindowComparatorResult::GT;
  }
  return WindowFunctionContext::WindowComparatorResult::EQ;
}

Here is the call graph for this function:

template<class T , class NullPatternType >

WindowFunctionContext::WindowComparatorResult anonymous_namespace{WindowContext.cpp}::fp_comparator_desc	(	const int8_t *	order_column_buffer,
		const SQLTypeInfo &	ti,
		const int32_t *	partition_indices,
		const int64_t	lhs,
		const int64_t	rhs,
		const bool	asc_ordering,
		const bool	nulls_first
	)

Definition at line 1136 of file WindowContext.cpp.

References WindowFunctionContext::EQ, SQLTypeInfo::get_type(), WindowFunctionContext::GT, kFLOAT, WindowFunctionContext::LT, null_val_bit_pattern(), and heavydb.dtypes::T.

                            {
  const auto values = reinterpret_cast<const T*>(order_column_buffer);
  const auto lhs_val = values[partition_indices[lhs]];
  const auto rhs_val = values[partition_indices[rhs]];
  const auto null_bit_pattern = null_val_bit_pattern(ti, ti.get_type() == kFLOAT);
  const auto lhs_bit_pattern =
      *reinterpret_cast<const NullPatternType*>(may_alias_ptr(&lhs_val));
  const auto rhs_bit_pattern =
      *reinterpret_cast<const NullPatternType*>(may_alias_ptr(&rhs_val));
  if (lhs_bit_pattern == null_bit_pattern && rhs_bit_pattern == null_bit_pattern) {
    return WindowFunctionContext::WindowComparatorResult::EQ;
  }
  if (lhs_bit_pattern == null_bit_pattern && rhs_bit_pattern != null_bit_pattern) {
    return !nulls_first ? WindowFunctionContext::WindowComparatorResult::LT
                        : WindowFunctionContext::WindowComparatorResult::GT;
  }
  if (rhs_bit_pattern == null_bit_pattern && lhs_bit_pattern != null_bit_pattern) {
    return nulls_first ? WindowFunctionContext::WindowComparatorResult::LT
                       : WindowFunctionContext::WindowComparatorResult::GT;
  }
  if (lhs_val < rhs_val) {
    return WindowFunctionContext::WindowComparatorResult::LT;
  }
  if (lhs_val > rhs_val) {
    return WindowFunctionContext::WindowComparatorResult::GT;
  }
  return WindowFunctionContext::WindowComparatorResult::EQ;
}

Here is the call graph for this function:

size_t anonymous_namespace{WindowContext.cpp}::get_int_constant_from_expr

(

const Analyzer::Expr *

expr

)

Definition at line 307 of file WindowContext.cpp.

References logger::FATAL, kBIGINT, kINT, kSMALLINT, and LOG.

Referenced by WindowFunctionContext::computePartitionBuffer(), and get_lag_or_lead_argument().

                                                            {
  const auto lag_constant = dynamic_cast<const Analyzer::Constant*>(expr);
  if (!lag_constant) {
    throw std::runtime_error("LAG with non-constant lag argument not supported yet");
  }
  const auto& lag_ti = lag_constant->get_type_info();
  switch (lag_ti.get_type()) {
    case kSMALLINT: {
      return lag_constant->get_constval().smallintval;
    }
    case kINT: {
      return lag_constant->get_constval().intval;
    }
    case kBIGINT: {
      return lag_constant->get_constval().bigintval;
    }
    default: {
      LOG(FATAL) << "Invalid type for the lag argument";
    }
  }
  return 0;
}

Here is the caller graph for this function:

int64_t anonymous_namespace{WindowContext.cpp}::get_lag_or_lead_argument

(

const Analyzer::WindowFunction *

window_func

)

Definition at line 331 of file WindowContext.cpp.

References run_benchmark_import::args, CHECK, CHECK_EQ, get_int_constant_from_expr(), Analyzer::WindowFunction::getArgs(), Analyzer::WindowFunction::getKind(), LAG, and LEAD.

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                            {
  CHECK(window_func->getKind() == SqlWindowFunctionKind::LAG ||
        window_func->getKind() == SqlWindowFunctionKind::LEAD);
  const auto& args = window_func->getArgs();
  if (args.size() == 3) {
    throw std::runtime_error("LAG with default not supported yet");
  }
  if (args.size() == 2) {
    const int64_t lag_or_lead =
        static_cast<int64_t>(get_int_constant_from_expr(args[1].get()));
    return window_func->getKind() == SqlWindowFunctionKind::LAG ? lag_or_lead
                                                                : -lag_or_lead;
  }
  CHECK_EQ(args.size(), size_t(1));
  return window_func->getKind() == SqlWindowFunctionKind::LAG ? 1 : -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t anonymous_namespace{WindowContext.cpp}::get_target_idx_for_first_or_last_value_func	(	const Analyzer::WindowFunction *	window_func,
		const size_t	partition_size
	)

Definition at line 348 of file WindowContext.cpp.

References CHECK, FIRST_VALUE, Analyzer::WindowFunction::getKind(), and LAST_VALUE.

Referenced by WindowFunctionContext::computePartitionBuffer().

                                 {
  CHECK(window_func->getKind() == SqlWindowFunctionKind::FIRST_VALUE ||
        window_func->getKind() == SqlWindowFunctionKind::LAST_VALUE);
  return window_func->getKind() == SqlWindowFunctionKind::FIRST_VALUE
             ? 0
             : partition_size - 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<double> anonymous_namespace{WindowContext.cpp}::index_to_cume_dist	(	const int64_t *	index,
		const size_t	index_size,
		const std::function< bool(const int64_t lhs, const int64_t rhs)> &	comparator
	)

Definition at line 265 of file WindowContext.cpp.

References advance_current_rank().

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                               {
  std::vector<double> cume_dist(index_size);
  size_t start_peer_group = 0;
  while (start_peer_group < index_size) {
    size_t end_peer_group = start_peer_group + 1;
    while (end_peer_group < index_size &&
           !advance_current_rank(comparator, index, end_peer_group)) {
      ++end_peer_group;
    }
    for (size_t i = start_peer_group; i < end_peer_group; ++i) {
      cume_dist[index[i]] = static_cast<double>(end_peer_group) / index_size;
    }
    start_peer_group = end_peer_group;
  }
  return cume_dist;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<int64_t> anonymous_namespace{WindowContext.cpp}::index_to_dense_rank	(	const int64_t *	index,
		const size_t	index_size,
		const std::function< bool(const int64_t lhs, const int64_t rhs)> &	comparator
	)

Definition at line 232 of file WindowContext.cpp.

References advance_current_rank().

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                               {
  std::vector<int64_t> dense_rank(index_size);
  size_t crt_rank = 1;
  for (size_t i = 0; i < index_size; ++i) {
    if (advance_current_rank(comparator, index, i)) {
      ++crt_rank;
    }
    dense_rank[index[i]] = crt_rank;
  }
  return dense_rank;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<int64_t> anonymous_namespace{WindowContext.cpp}::index_to_ntile	(	const int64_t *	index,
		const size_t	index_size,
		const size_t	n
	)

Definition at line 286 of file WindowContext.cpp.

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                    {
  std::vector<int64_t> row_numbers(index_size);
  if (!n) {
    throw std::runtime_error("NTILE argument cannot be zero");
  }
  const size_t tile_size = (index_size + n - 1) / n;
  for (size_t i = 0; i < index_size; ++i) {
    row_numbers[index[i]] = i / tile_size + 1;
  }
  return row_numbers;
}

Here is the caller graph for this function:

void anonymous_namespace{WindowContext.cpp}::index_to_partition_end	(	const int8_t *	partition_end,
		const size_t	off,
		const int64_t *	index,
		const size_t	index_size,
		const std::function< bool(const int64_t lhs, const int64_t rhs)> &	comparator
	)

Definition at line 413 of file WindowContext.cpp.

References advance_current_rank(), agg_count_distinct_bitmap(), and CHECK.

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                               {
  int64_t partition_end_handle = reinterpret_cast<int64_t>(partition_end);
  for (size_t i = 0; i < index_size; ++i) {
    if (advance_current_rank(comparator, index, i)) {
      agg_count_distinct_bitmap(&partition_end_handle, off + i - 1, 0, 0);
    }
  }
  CHECK(index_size);
  agg_count_distinct_bitmap(&partition_end_handle, off + index_size - 1, 0, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<double> anonymous_namespace{WindowContext.cpp}::index_to_percent_rank	(	const int64_t *	index,
		const size_t	index_size,
		const std::function< bool(const int64_t lhs, const int64_t rhs)> &	comparator
	)

Definition at line 248 of file WindowContext.cpp.

References advance_current_rank().

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                               {
  std::vector<double> percent_rank(index_size);
  size_t crt_rank = 1;
  for (size_t i = 0; i < index_size; ++i) {
    if (advance_current_rank(comparator, index, i)) {
      crt_rank = i + 1;
    }
    percent_rank[index[i]] =
        index_size == 1 ? 0 : static_cast<double>(crt_rank - 1) / (index_size - 1);
  }
  return percent_rank;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<int64_t> anonymous_namespace{WindowContext.cpp}::index_to_rank	(	const int64_t *	index,
		const size_t	index_size,
		const std::function< bool(const int64_t lhs, const int64_t rhs)> &	comparator
	)

Definition at line 216 of file WindowContext.cpp.

References advance_current_rank().

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                               {
  std::vector<int64_t> rank(index_size);
  size_t crt_rank = 1;
  for (size_t i = 0; i < index_size; ++i) {
    if (advance_current_rank(comparator, index, i)) {
      crt_rank = i + 1;
    }
    rank[index[i]] = crt_rank;
  }
  return rank;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<int64_t> anonymous_namespace{WindowContext.cpp}::index_to_row_number	(	const int64_t *	index,
		const size_t	index_size
	)

Definition at line 195 of file WindowContext.cpp.

Referenced by WindowFunctionContext::computePartitionBuffer().

                                                                                      {
  std::vector<int64_t> row_numbers(index_size);
  for (size_t i = 0; i < index_size; ++i) {
    row_numbers[index[i]] = i + 1;
  }
  return row_numbers;
}

Here is the caller graph for this function:

template<class T >

WindowFunctionContext::WindowComparatorResult anonymous_namespace{WindowContext.cpp}::integer_comparator_asc	(	const int8_t *	order_column_buffer,
		const SQLTypeInfo &	ti,
		const int32_t *	partition_indices,
		const int64_t	lhs,
		const int64_t	rhs,
		const bool	asc_ordering,
		const bool	nulls_first
	)

Definition at line 1033 of file WindowContext.cpp.

References WindowFunctionContext::EQ, WindowFunctionContext::GT, inline_fixed_encoding_null_val(), WindowFunctionContext::LT, and heavydb.dtypes::T.

                            {
  const auto values = reinterpret_cast<const T*>(order_column_buffer);
  const auto lhs_val = values[partition_indices[lhs]];
  const auto rhs_val = values[partition_indices[rhs]];
  const auto null_val = inline_fixed_encoding_null_val(ti);
  if (lhs_val == null_val && rhs_val == null_val) {
    return WindowFunctionContext::WindowComparatorResult::EQ;
  }
  if (lhs_val == null_val && rhs_val != null_val) {
    return nulls_first ? WindowFunctionContext::WindowComparatorResult::LT
                       : WindowFunctionContext::WindowComparatorResult::GT;
  }
  if (rhs_val == null_val && lhs_val != null_val) {
    return !nulls_first ? WindowFunctionContext::WindowComparatorResult::LT
                        : WindowFunctionContext::WindowComparatorResult::GT;
  }
  if (lhs_val < rhs_val) {
    return WindowFunctionContext::WindowComparatorResult::LT;
  }
  if (lhs_val > rhs_val) {
    return WindowFunctionContext::WindowComparatorResult::GT;
  }
  return WindowFunctionContext::WindowComparatorResult::EQ;
}

Here is the call graph for this function:

template<class T >

WindowFunctionContext::WindowComparatorResult anonymous_namespace{WindowContext.cpp}::integer_comparator_desc	(	const int8_t *	order_column_buffer,
		const SQLTypeInfo &	ti,
		const int32_t *	partition_indices,
		const int64_t	lhs,
		const int64_t	rhs,
		const bool	asc_ordering,
		const bool	nulls_first
	)

Definition at line 1066 of file WindowContext.cpp.

References WindowFunctionContext::EQ, WindowFunctionContext::GT, inline_fixed_encoding_null_val(), WindowFunctionContext::LT, and heavydb.dtypes::T.

                            {
  const auto values = reinterpret_cast<const T*>(order_column_buffer);
  const auto lhs_val = values[partition_indices[lhs]];
  const auto rhs_val = values[partition_indices[rhs]];
  const auto null_val = inline_fixed_encoding_null_val(ti);
  if (lhs_val == null_val && rhs_val == null_val) {
    return WindowFunctionContext::WindowComparatorResult::EQ;
  }
  if (lhs_val == null_val && rhs_val != null_val) {
    return !nulls_first ? WindowFunctionContext::WindowComparatorResult::LT
                        : WindowFunctionContext::WindowComparatorResult::GT;
  }
  if (rhs_val == null_val && lhs_val != null_val) {
    return nulls_first ? WindowFunctionContext::WindowComparatorResult::LT
                       : WindowFunctionContext::WindowComparatorResult::GT;
  }
  if (lhs_val < rhs_val) {
    return WindowFunctionContext::WindowComparatorResult::LT;
  }
  if (lhs_val > rhs_val) {
    return WindowFunctionContext::WindowComparatorResult::GT;
  }
  return WindowFunctionContext::WindowComparatorResult::EQ;
}

Here is the call graph for this function:

bool anonymous_namespace{WindowContext.cpp}::pos_is_set	(	const int64_t	bitset,
		const int64_t	pos
	)

Definition at line 429 of file WindowContext.cpp.

Referenced by apply_window_pending_outputs_double(), apply_window_pending_outputs_float(), apply_window_pending_outputs_float_columnar(), and apply_window_pending_outputs_int().

                                                         {
  return (reinterpret_cast<const int8_t*>(bitset))[pos >> 3] & (1 << (pos & 7));
}

Here is the caller graph for this function:

size_t anonymous_namespace{WindowContext.cpp}::window_function_buffer_element_size

(

const SqlWindowFunctionKind

)

Definition at line 302 of file WindowContext.cpp.

Referenced by WindowFunctionContext::compute().

                                                                          {
  return 8;
}

Here is the caller graph for this function: