OmniSciDB  72c90bc290
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE > Struct Template Reference
+ Collaboration diagram for ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >:

Public Types

using BufferIteratorType = BUFFER_ITERATOR_TYPE
 

Public Member Functions

 ResultSetComparator (const std::list< Analyzer::OrderEntry > &order_entries, const ResultSet *result_set, const PermutationView permutation, const Executor *executor, const bool single_threaded)
 
void materializeCountDistinctColumns ()
 
ApproxQuantileBuffers materializeApproxQuantileColumns () const
 
ModeBuffers materializeModeColumns () const
 
std::vector< int64_t > materializeCountDistinctColumn (const Analyzer::OrderEntry &order_entry) const
 
ApproxQuantileBuffers::value_type materializeApproxQuantileColumn (const Analyzer::OrderEntry &order_entry) const
 
ModeBuffers::value_type materializeModeColumn (const Analyzer::OrderEntry &order_entry) const
 
bool operator() (const PermutationIdx lhs, const PermutationIdx rhs) const
 

Public Attributes

const std::list
< Analyzer::OrderEntry > & 
order_entries_
 
const ResultSetresult_set_
 
const PermutationView permutation_
 
const BufferIteratorType buffer_itr_
 
const Executorexecutor_
 
const bool single_threaded_
 
std::vector< std::vector
< int64_t > > 
count_distinct_materialized_buffers_
 
const ApproxQuantileBuffers approx_quantile_materialized_buffers_
 
const ModeBuffers mode_buffers_
 

Detailed Description

template<typename BUFFER_ITERATOR_TYPE>
struct ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >

Definition at line 833 of file ResultSet.h.

Member Typedef Documentation

template<typename BUFFER_ITERATOR_TYPE>
using ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::BufferIteratorType = BUFFER_ITERATOR_TYPE

Definition at line 834 of file ResultSet.h.

Constructor & Destructor Documentation

template<typename BUFFER_ITERATOR_TYPE>
ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::ResultSetComparator ( const std::list< Analyzer::OrderEntry > &  order_entries,
const ResultSet result_set,
const PermutationView  permutation,
const Executor executor,
const bool  single_threaded 
)
inline

Definition at line 836 of file ResultSet.h.

References ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeCountDistinctColumns().

841  : order_entries_(order_entries)
842  , result_set_(result_set)
843  , permutation_(permutation)
844  , buffer_itr_(result_set)
845  , executor_(executor)
846  , single_threaded_(single_threaded)
850  }
const ApproxQuantileBuffers approx_quantile_materialized_buffers_
Definition: ResultSet.h:872
const BufferIteratorType buffer_itr_
Definition: ResultSet.h:868
const Executor * executor_
Definition: ResultSet.h:869
ApproxQuantileBuffers materializeApproxQuantileColumns() const
Definition: ResultSet.cpp:983
const ResultSet * result_set_
Definition: ResultSet.h:866
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:865
const PermutationView permutation_
Definition: ResultSet.h:867
ModeBuffers materializeModeColumns() const
Definition: ResultSet.cpp:996
const ModeBuffers mode_buffers_
Definition: ResultSet.h:873

+ Here is the call graph for this function:

Member Function Documentation

template<typename BUFFER_ITERATOR_TYPE >
ResultSet::ApproxQuantileBuffers::value_type ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeApproxQuantileColumn ( const Analyzer::OrderEntry order_entry) const

Definition at line 1057 of file ResultSet.cpp.

References cpu_threads(), NULL_DOUBLE, threading_std::task_group::run(), logger::thread_local_ids(), Analyzer::OrderEntry::tle_no, and threading_std::task_group::wait().

1058  {
1059  ResultSet::ApproxQuantileBuffers::value_type materialized_buffer(
1060  result_set_->query_mem_desc_.getEntryCount());
1061  const size_t size = permutation_.size();
1062  const auto work = [&, parent_thread_local_ids = logger::thread_local_ids()](
1063  const size_t start, const size_t end) {
1064  logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
1065  for (size_t i = start; i < end; ++i) {
1066  const PermutationIdx permuted_idx = permutation_[i];
1067  const auto storage_lookup_result = result_set_->findStorage(permuted_idx);
1068  const auto storage = storage_lookup_result.storage_ptr;
1069  const auto off = storage_lookup_result.fixedup_entry_idx;
1070  const auto value = buffer_itr_.getColumnInternal(
1071  storage->buff_, off, order_entry.tle_no - 1, storage_lookup_result);
1072  materialized_buffer[permuted_idx] =
1073  value.i1 ? calculateQuantile(reinterpret_cast<quantile::TDigest*>(value.i1))
1074  : NULL_DOUBLE;
1075  }
1076  };
1077  if (single_threaded_) {
1078  work(0, size);
1079  } else {
1080  threading::task_group thread_pool;
1081  for (auto interval : makeIntervals<size_t>(0, size, cpu_threads())) {
1082  thread_pool.run([=] { work(interval.begin, interval.end); });
1083  }
1084  thread_pool.wait();
1085  }
1086  return materialized_buffer;
1087 }
#define NULL_DOUBLE
const BufferIteratorType buffer_itr_
Definition: ResultSet.h:868
int tle_no
Definition: Analyzer.h:2680
DEVICE size_type size() const
Definition: VectorView.h:83
const ResultSet * result_set_
Definition: ResultSet.h:866
const PermutationView permutation_
Definition: ResultSet.h:867
static double calculateQuantile(quantile::TDigest *const t_digest)
Definition: ResultSet.cpp:1047
uint32_t PermutationIdx
Definition: ResultSet.h:152
int cpu_threads()
Definition: thread_count.h:25
ThreadLocalIds thread_local_ids()
Definition: Logger.cpp:880

+ Here is the call graph for this function:

template<typename BUFFER_ITERATOR_TYPE >
ResultSet::ApproxQuantileBuffers ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeApproxQuantileColumns ( ) const

Definition at line 983 of file ResultSet.cpp.

References kAPPROX_QUANTILE.

983  {
984  ResultSet::ApproxQuantileBuffers approx_quantile_materialized_buffers;
985  for (const auto& order_entry : order_entries_) {
986  if (result_set_->targets_[order_entry.tle_no - 1].agg_kind == kAPPROX_QUANTILE) {
987  approx_quantile_materialized_buffers.emplace_back(
988  materializeApproxQuantileColumn(order_entry));
989  }
990  }
991  return approx_quantile_materialized_buffers;
992 }
std::vector< std::vector< double >> ApproxQuantileBuffers
Definition: ResultSet.h:829
ApproxQuantileBuffers::value_type materializeApproxQuantileColumn(const Analyzer::OrderEntry &order_entry) const
Definition: ResultSet.cpp:1057
const ResultSet * result_set_
Definition: ResultSet.h:866
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:865
template<typename BUFFER_ITERATOR_TYPE >
std::vector< int64_t > ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeCountDistinctColumn ( const Analyzer::OrderEntry order_entry) const

Definition at line 1011 of file ResultSet.cpp.

References count_distinct_set_size(), cpu_threads(), threading_std::task_group::run(), logger::thread_local_ids(), Analyzer::OrderEntry::tle_no, and threading_std::task_group::wait().

1012  {
1013  const size_t num_storage_entries = result_set_->query_mem_desc_.getEntryCount();
1014  std::vector<int64_t> count_distinct_materialized_buffer(num_storage_entries);
1015  const CountDistinctDescriptor count_distinct_descriptor =
1016  result_set_->query_mem_desc_.getCountDistinctDescriptor(order_entry.tle_no - 1);
1017  const size_t num_non_empty_entries = permutation_.size();
1018 
1019  const auto work = [&, parent_thread_local_ids = logger::thread_local_ids()](
1020  const size_t start, const size_t end) {
1021  logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
1022  for (size_t i = start; i < end; ++i) {
1023  const PermutationIdx permuted_idx = permutation_[i];
1024  const auto storage_lookup_result = result_set_->findStorage(permuted_idx);
1025  const auto storage = storage_lookup_result.storage_ptr;
1026  const auto off = storage_lookup_result.fixedup_entry_idx;
1027  const auto value = buffer_itr_.getColumnInternal(
1028  storage->buff_, off, order_entry.tle_no - 1, storage_lookup_result);
1029  count_distinct_materialized_buffer[permuted_idx] =
1030  count_distinct_set_size(value.i1, count_distinct_descriptor);
1031  }
1032  };
1033  // TODO(tlm): Allow use of tbb after we determine how to easily encapsulate the choice
1034  // between thread pool types
1035  if (single_threaded_) {
1036  work(0, num_non_empty_entries);
1037  } else {
1038  threading::task_group thread_pool;
1039  for (auto interval : makeIntervals<size_t>(0, num_non_empty_entries, cpu_threads())) {
1040  thread_pool.run([=] { work(interval.begin, interval.end); });
1041  }
1042  thread_pool.wait();
1043  }
1044  return count_distinct_materialized_buffer;
1045 }
const BufferIteratorType buffer_itr_
Definition: ResultSet.h:868
int tle_no
Definition: Analyzer.h:2680
DEVICE size_type size() const
Definition: VectorView.h:83
int64_t count_distinct_set_size(const int64_t set_handle, const CountDistinctDescriptor &count_distinct_desc)
Definition: CountDistinct.h:75
const ResultSet * result_set_
Definition: ResultSet.h:866
const PermutationView permutation_
Definition: ResultSet.h:867
uint32_t PermutationIdx
Definition: ResultSet.h:152
int cpu_threads()
Definition: thread_count.h:25
ThreadLocalIds thread_local_ids()
Definition: Logger.cpp:880

+ Here is the call graph for this function:

template<typename BUFFER_ITERATOR_TYPE >
void ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeCountDistinctColumns ( )

Definition at line 960 of file ResultSet.cpp.

References is_distinct_target().

Referenced by ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::ResultSetComparator().

960  {
961  for (const auto& order_entry : order_entries_) {
962  if (is_distinct_target(result_set_->targets_[order_entry.tle_no - 1])) {
964  materializeCountDistinctColumn(order_entry));
965  }
966  }
967 }
std::vector< int64_t > materializeCountDistinctColumn(const Analyzer::OrderEntry &order_entry) const
Definition: ResultSet.cpp:1011
const ResultSet * result_set_
Definition: ResultSet.h:866
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:865
bool is_distinct_target(const TargetInfo &target_info)
Definition: TargetInfo.h:102
std::vector< std::vector< int64_t > > count_distinct_materialized_buffers_
Definition: ResultSet.h:871

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<typename BUFFER_ITERATOR_TYPE >
ResultSet::ModeBuffers::value_type ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeModeColumn ( const Analyzer::OrderEntry order_entry) const

Definition at line 1126 of file ResultSet.cpp.

References threading_serial::parallel_for(), and logger::thread_local_ids().

1127  {
1128  ResultSet::ModeBuffers::value_type materialized_buffer(
1129  result_set_->query_mem_desc_.getEntryCount());
1130  ModeScatter mode_scatter{
1131  logger::thread_local_ids(), this, order_entry, materialized_buffer};
1132  if (single_threaded_) {
1133  mode_scatter(ModeBlockedRange(0, permutation_.size())); // Still has new thread_id.
1134  } else {
1135  tbb::parallel_for(ModeBlockedRange(0, permutation_.size()), mode_scatter);
1136  }
1137  return materialized_buffer;
1138 }
DEVICE size_type size() const
Definition: VectorView.h:83
const ResultSet * result_set_
Definition: ResultSet.h:866
const PermutationView permutation_
Definition: ResultSet.h:867
void parallel_for(const blocked_range< Int > &range, const Body &body, const Partitioner &p=Partitioner())
tbb::blocked_range< size_t > ModeBlockedRange
Definition: ResultSet.cpp:1100
ThreadLocalIds thread_local_ids()
Definition: Logger.cpp:880

+ Here is the call graph for this function:

template<typename BUFFER_ITERATOR_TYPE >
ResultSet::ModeBuffers ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeModeColumns ( ) const

Definition at line 996 of file ResultSet.cpp.

References kMODE.

996  {
997  ResultSet::ModeBuffers mode_buffers;
998  IsAggKind const is_mode(result_set_->targets_, kMODE);
999  mode_buffers.reserve(
1000  std::count_if(order_entries_.begin(), order_entries_.end(), is_mode));
1001  for (auto const& order_entry : order_entries_) {
1002  if (is_mode(order_entry)) {
1003  mode_buffers.emplace_back(materializeModeColumn(order_entry));
1004  }
1005  }
1006  return mode_buffers;
1007 }
const ResultSet * result_set_
Definition: ResultSet.h:866
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:865
ModeBuffers::value_type materializeModeColumn(const Analyzer::OrderEntry &order_entry) const
Definition: ResultSet.cpp:1126
Definition: sqldefs.h:83
std::vector< std::vector< int64_t >> ModeBuffers
Definition: ResultSet.h:830
template<typename BUFFER_ITERATOR_TYPE >
bool ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::operator() ( const PermutationIdx  lhs,
const PermutationIdx  rhs 
) const

Definition at line 1141 of file ResultSet.cpp.

References CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, executor_(), get_compact_type(), is_distinct_target(), kAPPROX_QUANTILE, kENCODING_DICT, kFLOAT, kMODE, LIKELY, NULL_BIGINT, NULL_DOUBLE, pair_to_double(), takes_float_argument(), and UNLIKELY.

1143  {
1144  // NB: The compare function must define a strict weak ordering, otherwise
1145  // std::sort will trigger a segmentation fault (or corrupt memory).
1146  const auto lhs_storage_lookup_result = result_set_->findStorage(lhs);
1147  const auto rhs_storage_lookup_result = result_set_->findStorage(rhs);
1148  const auto lhs_storage = lhs_storage_lookup_result.storage_ptr;
1149  const auto rhs_storage = rhs_storage_lookup_result.storage_ptr;
1150  const auto fixedup_lhs = lhs_storage_lookup_result.fixedup_entry_idx;
1151  const auto fixedup_rhs = rhs_storage_lookup_result.fixedup_entry_idx;
1152  size_t materialized_count_distinct_buffer_idx{0};
1153  size_t materialized_approx_quantile_buffer_idx{0};
1154  size_t materialized_mode_buffer_idx{0};
1155 
1156  for (const auto& order_entry : order_entries_) {
1157  CHECK_GE(order_entry.tle_no, 1);
1158  // lhs_entry_ti and rhs_entry_ti can differ on comp_param w/ UNION of string dicts.
1159  const auto& lhs_agg_info = lhs_storage->targets_[order_entry.tle_no - 1];
1160  const auto& rhs_agg_info = rhs_storage->targets_[order_entry.tle_no - 1];
1161  const auto lhs_entry_ti = get_compact_type(lhs_agg_info);
1162  const auto rhs_entry_ti = get_compact_type(rhs_agg_info);
1163  // When lhs vs rhs doesn't matter, the lhs is used. For example:
1164  bool float_argument_input = takes_float_argument(lhs_agg_info);
1165  // Need to determine if the float value has been stored as float
1166  // or if it has been compacted to a different (often larger 8 bytes)
1167  // in distributed case the floats are actually 4 bytes
1168  // TODO the above takes_float_argument() is widely used wonder if this problem
1169  // exists elsewhere
1170  if (lhs_entry_ti.get_type() == kFLOAT) {
1171  const auto is_col_lazy =
1172  !result_set_->lazy_fetch_info_.empty() &&
1173  result_set_->lazy_fetch_info_[order_entry.tle_no - 1].is_lazily_fetched;
1174  if (result_set_->query_mem_desc_.getPaddedSlotWidthBytes(order_entry.tle_no - 1) ==
1175  sizeof(float)) {
1176  float_argument_input =
1177  result_set_->query_mem_desc_.didOutputColumnar() ? !is_col_lazy : true;
1178  }
1179  }
1180 
1181  if (UNLIKELY(is_distinct_target(lhs_agg_info))) {
1182  CHECK_LT(materialized_count_distinct_buffer_idx,
1184 
1185  const auto& count_distinct_materialized_buffer =
1186  count_distinct_materialized_buffers_[materialized_count_distinct_buffer_idx];
1187  const auto lhs_sz = count_distinct_materialized_buffer[lhs];
1188  const auto rhs_sz = count_distinct_materialized_buffer[rhs];
1189  ++materialized_count_distinct_buffer_idx;
1190  if (lhs_sz == rhs_sz) {
1191  continue;
1192  }
1193  return (lhs_sz < rhs_sz) != order_entry.is_desc;
1194  } else if (UNLIKELY(lhs_agg_info.agg_kind == kAPPROX_QUANTILE)) {
1195  CHECK_LT(materialized_approx_quantile_buffer_idx,
1197  const auto& approx_quantile_materialized_buffer =
1198  approx_quantile_materialized_buffers_[materialized_approx_quantile_buffer_idx];
1199  const auto lhs_value = approx_quantile_materialized_buffer[lhs];
1200  const auto rhs_value = approx_quantile_materialized_buffer[rhs];
1201  ++materialized_approx_quantile_buffer_idx;
1202  if (lhs_value == rhs_value) {
1203  continue;
1204  } else if (!lhs_entry_ti.get_notnull()) {
1205  if (lhs_value == NULL_DOUBLE) {
1206  return order_entry.nulls_first;
1207  } else if (rhs_value == NULL_DOUBLE) {
1208  return !order_entry.nulls_first;
1209  }
1210  }
1211  return (lhs_value < rhs_value) != order_entry.is_desc;
1212  } else if (UNLIKELY(lhs_agg_info.agg_kind == kMODE)) {
1213  CHECK_LT(materialized_mode_buffer_idx, mode_buffers_.size());
1214  auto const& mode_buffer = mode_buffers_[materialized_mode_buffer_idx++];
1215  int64_t const lhs_value = mode_buffer[lhs];
1216  int64_t const rhs_value = mode_buffer[rhs];
1217  if (lhs_value == rhs_value) {
1218  continue;
1219  // MODE(x) can only be NULL when the group is empty, since it skips null values.
1220  } else if (lhs_value == NULL_BIGINT) { // NULL_BIGINT from materializeMode()
1221  return order_entry.nulls_first;
1222  } else if (rhs_value == NULL_BIGINT) {
1223  return !order_entry.nulls_first;
1224  } else {
1225  return result_set_->isLessThan(lhs_entry_ti, lhs_value, rhs_value) !=
1226  order_entry.is_desc;
1227  }
1228  }
1229 
1230  const auto lhs_v = buffer_itr_.getColumnInternal(lhs_storage->buff_,
1231  fixedup_lhs,
1232  order_entry.tle_no - 1,
1233  lhs_storage_lookup_result);
1234  const auto rhs_v = buffer_itr_.getColumnInternal(rhs_storage->buff_,
1235  fixedup_rhs,
1236  order_entry.tle_no - 1,
1237  rhs_storage_lookup_result);
1238 
1239  if (UNLIKELY(isNull(lhs_entry_ti, lhs_v, float_argument_input) &&
1240  isNull(rhs_entry_ti, rhs_v, float_argument_input))) {
1241  continue;
1242  }
1243  if (UNLIKELY(isNull(lhs_entry_ti, lhs_v, float_argument_input) &&
1244  !isNull(rhs_entry_ti, rhs_v, float_argument_input))) {
1245  return order_entry.nulls_first;
1246  }
1247  if (UNLIKELY(isNull(rhs_entry_ti, rhs_v, float_argument_input) &&
1248  !isNull(lhs_entry_ti, lhs_v, float_argument_input))) {
1249  return !order_entry.nulls_first;
1250  }
1251 
1252  if (LIKELY(lhs_v.isInt())) {
1253  CHECK(rhs_v.isInt());
1254  if (UNLIKELY(lhs_entry_ti.is_string() &&
1255  lhs_entry_ti.get_compression() == kENCODING_DICT)) {
1256  CHECK_EQ(4, lhs_entry_ti.get_logical_size());
1257  CHECK(executor_);
1258  const auto lhs_string_dict_proxy = executor_->getStringDictionaryProxy(
1259  lhs_entry_ti.getStringDictKey(), result_set_->row_set_mem_owner_, false);
1260  const auto rhs_string_dict_proxy = executor_->getStringDictionaryProxy(
1261  rhs_entry_ti.getStringDictKey(), result_set_->row_set_mem_owner_, false);
1262  const auto lhs_str = lhs_string_dict_proxy->getString(lhs_v.i1);
1263  const auto rhs_str = rhs_string_dict_proxy->getString(rhs_v.i1);
1264  if (lhs_str == rhs_str) {
1265  continue;
1266  }
1267  return (lhs_str < rhs_str) != order_entry.is_desc;
1268  }
1269 
1270  if (lhs_v.i1 == rhs_v.i1) {
1271  continue;
1272  }
1273  if (lhs_entry_ti.is_fp()) {
1274  if (float_argument_input) {
1275  const auto lhs_dval = *reinterpret_cast<const float*>(may_alias_ptr(&lhs_v.i1));
1276  const auto rhs_dval = *reinterpret_cast<const float*>(may_alias_ptr(&rhs_v.i1));
1277  return (lhs_dval < rhs_dval) != order_entry.is_desc;
1278  } else {
1279  const auto lhs_dval =
1280  *reinterpret_cast<const double*>(may_alias_ptr(&lhs_v.i1));
1281  const auto rhs_dval =
1282  *reinterpret_cast<const double*>(may_alias_ptr(&rhs_v.i1));
1283  return (lhs_dval < rhs_dval) != order_entry.is_desc;
1284  }
1285  }
1286  return (lhs_v.i1 < rhs_v.i1) != order_entry.is_desc;
1287  } else {
1288  if (lhs_v.isPair()) {
1289  CHECK(rhs_v.isPair());
1290  const auto lhs =
1291  pair_to_double({lhs_v.i1, lhs_v.i2}, lhs_entry_ti, float_argument_input);
1292  const auto rhs =
1293  pair_to_double({rhs_v.i1, rhs_v.i2}, rhs_entry_ti, float_argument_input);
1294  if (lhs == rhs) {
1295  continue;
1296  }
1297  return (lhs < rhs) != order_entry.is_desc;
1298  } else {
1299  CHECK(lhs_v.isStr() && rhs_v.isStr());
1300  const auto lhs = lhs_v.strVal();
1301  const auto rhs = rhs_v.strVal();
1302  if (lhs == rhs) {
1303  continue;
1304  }
1305  return (lhs < rhs) != order_entry.is_desc;
1306  }
1307  }
1308  }
1309  return false;
1310 }
#define CHECK_EQ(x, y)
Definition: Logger.h:301
#define NULL_DOUBLE
const ApproxQuantileBuffers approx_quantile_materialized_buffers_
Definition: ResultSet.h:872
const BufferIteratorType buffer_itr_
Definition: ResultSet.h:868
#define NULL_BIGINT
const Executor * executor_
Definition: ResultSet.h:869
static bool isNull(const SQLTypeInfo &ti, const InternalTargetValue &val, const bool float_argument_input)
#define CHECK_GE(x, y)
Definition: Logger.h:306
double pair_to_double(const std::pair< int64_t, int64_t > &fp_pair, const SQLTypeInfo &ti, const bool float_argument_input)
bool takes_float_argument(const TargetInfo &target_info)
Definition: TargetInfo.h:106
const SQLTypeInfo get_compact_type(const TargetInfo &target)
const ResultSet * result_set_
Definition: ResultSet.h:866
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:865
#define LIKELY(x)
Definition: likely.h:24
bool is_distinct_target(const TargetInfo &target_info)
Definition: TargetInfo.h:102
#define UNLIKELY(x)
Definition: likely.h:25
#define CHECK_LT(x, y)
Definition: Logger.h:303
#define CHECK(condition)
Definition: Logger.h:291
std::vector< std::vector< int64_t > > count_distinct_materialized_buffers_
Definition: ResultSet.h:871
Definition: sqldefs.h:83
const ModeBuffers mode_buffers_
Definition: ResultSet.h:873

+ Here is the call graph for this function:

Member Data Documentation

template<typename BUFFER_ITERATOR_TYPE>
const ApproxQuantileBuffers ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::approx_quantile_materialized_buffers_

Definition at line 872 of file ResultSet.h.

template<typename BUFFER_ITERATOR_TYPE>
const BufferIteratorType ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::buffer_itr_

Definition at line 868 of file ResultSet.h.

template<typename BUFFER_ITERATOR_TYPE>
std::vector<std::vector<int64_t> > ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::count_distinct_materialized_buffers_

Definition at line 871 of file ResultSet.h.

template<typename BUFFER_ITERATOR_TYPE>
const Executor* ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::executor_

Definition at line 869 of file ResultSet.h.

template<typename BUFFER_ITERATOR_TYPE>
const ModeBuffers ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::mode_buffers_

Definition at line 873 of file ResultSet.h.

template<typename BUFFER_ITERATOR_TYPE>
const std::list<Analyzer::OrderEntry>& ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::order_entries_

Definition at line 865 of file ResultSet.h.

template<typename BUFFER_ITERATOR_TYPE>
const PermutationView ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::permutation_

Definition at line 867 of file ResultSet.h.

template<typename BUFFER_ITERATOR_TYPE>
const ResultSet* ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::result_set_

Definition at line 866 of file ResultSet.h.

template<typename BUFFER_ITERATOR_TYPE>
const bool ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::single_threaded_

Definition at line 870 of file ResultSet.h.


The documentation for this struct was generated from the following files: