OmniSciDB  c1a53651b2
 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 825 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 826 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 828 of file ResultSet.h.

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

833  : order_entries_(order_entries)
834  , result_set_(result_set)
835  , permutation_(permutation)
836  , buffer_itr_(result_set)
837  , executor_(executor)
838  , single_threaded_(single_threaded)
842  }
const ApproxQuantileBuffers approx_quantile_materialized_buffers_
Definition: ResultSet.h:864
const BufferIteratorType buffer_itr_
Definition: ResultSet.h:860
const Executor * executor_
Definition: ResultSet.h:861
ApproxQuantileBuffers materializeApproxQuantileColumns() const
Definition: ResultSet.cpp:971
const ResultSet * result_set_
Definition: ResultSet.h:858
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:857
const PermutationView permutation_
Definition: ResultSet.h:859
ModeBuffers materializeModeColumns() const
Definition: ResultSet.cpp:984
const ModeBuffers mode_buffers_
Definition: ResultSet.h:865

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

1046  {
1047  ResultSet::ApproxQuantileBuffers::value_type materialized_buffer(
1048  result_set_->query_mem_desc_.getEntryCount());
1049  const size_t size = permutation_.size();
1050  const auto work = [&, parent_thread_local_ids = logger::thread_local_ids()](
1051  const size_t start, const size_t end) {
1052  logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
1053  for (size_t i = start; i < end; ++i) {
1054  const PermutationIdx permuted_idx = permutation_[i];
1055  const auto storage_lookup_result = result_set_->findStorage(permuted_idx);
1056  const auto storage = storage_lookup_result.storage_ptr;
1057  const auto off = storage_lookup_result.fixedup_entry_idx;
1058  const auto value = buffer_itr_.getColumnInternal(
1059  storage->buff_, off, order_entry.tle_no - 1, storage_lookup_result);
1060  materialized_buffer[permuted_idx] =
1061  value.i1 ? calculateQuantile(reinterpret_cast<quantile::TDigest*>(value.i1))
1062  : NULL_DOUBLE;
1063  }
1064  };
1065  if (single_threaded_) {
1066  work(0, size);
1067  } else {
1068  threading::task_group thread_pool;
1069  for (auto interval : makeIntervals<size_t>(0, size, cpu_threads())) {
1070  thread_pool.run([=] { work(interval.begin, interval.end); });
1071  }
1072  thread_pool.wait();
1073  }
1074  return materialized_buffer;
1075 }
#define NULL_DOUBLE
const BufferIteratorType buffer_itr_
Definition: ResultSet.h:860
int tle_no
Definition: Analyzer.h:2473
DEVICE size_type size() const
Definition: VectorView.h:83
const ResultSet * result_set_
Definition: ResultSet.h:858
const PermutationView permutation_
Definition: ResultSet.h:859
static double calculateQuantile(quantile::TDigest *const t_digest)
Definition: ResultSet.cpp:1035
uint32_t PermutationIdx
Definition: ResultSet.h:152
int cpu_threads()
Definition: thread_count.h:25
ThreadLocalIds thread_local_ids()
Definition: Logger.cpp:874

+ 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 971 of file ResultSet.cpp.

References kAPPROX_QUANTILE.

971  {
972  ResultSet::ApproxQuantileBuffers approx_quantile_materialized_buffers;
973  for (const auto& order_entry : order_entries_) {
974  if (result_set_->targets_[order_entry.tle_no - 1].agg_kind == kAPPROX_QUANTILE) {
975  approx_quantile_materialized_buffers.emplace_back(
976  materializeApproxQuantileColumn(order_entry));
977  }
978  }
979  return approx_quantile_materialized_buffers;
980 }
std::vector< std::vector< double >> ApproxQuantileBuffers
Definition: ResultSet.h:821
ApproxQuantileBuffers::value_type materializeApproxQuantileColumn(const Analyzer::OrderEntry &order_entry) const
Definition: ResultSet.cpp:1045
const ResultSet * result_set_
Definition: ResultSet.h:858
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:857
template<typename BUFFER_ITERATOR_TYPE >
std::vector< int64_t > ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeCountDistinctColumn ( const Analyzer::OrderEntry order_entry) const

Definition at line 999 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().

1000  {
1001  const size_t num_storage_entries = result_set_->query_mem_desc_.getEntryCount();
1002  std::vector<int64_t> count_distinct_materialized_buffer(num_storage_entries);
1003  const CountDistinctDescriptor count_distinct_descriptor =
1004  result_set_->query_mem_desc_.getCountDistinctDescriptor(order_entry.tle_no - 1);
1005  const size_t num_non_empty_entries = permutation_.size();
1006 
1007  const auto work = [&, parent_thread_local_ids = logger::thread_local_ids()](
1008  const size_t start, const size_t end) {
1009  logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
1010  for (size_t i = start; i < end; ++i) {
1011  const PermutationIdx permuted_idx = permutation_[i];
1012  const auto storage_lookup_result = result_set_->findStorage(permuted_idx);
1013  const auto storage = storage_lookup_result.storage_ptr;
1014  const auto off = storage_lookup_result.fixedup_entry_idx;
1015  const auto value = buffer_itr_.getColumnInternal(
1016  storage->buff_, off, order_entry.tle_no - 1, storage_lookup_result);
1017  count_distinct_materialized_buffer[permuted_idx] =
1018  count_distinct_set_size(value.i1, count_distinct_descriptor);
1019  }
1020  };
1021  // TODO(tlm): Allow use of tbb after we determine how to easily encapsulate the choice
1022  // between thread pool types
1023  if (single_threaded_) {
1024  work(0, num_non_empty_entries);
1025  } else {
1026  threading::task_group thread_pool;
1027  for (auto interval : makeIntervals<size_t>(0, num_non_empty_entries, cpu_threads())) {
1028  thread_pool.run([=] { work(interval.begin, interval.end); });
1029  }
1030  thread_pool.wait();
1031  }
1032  return count_distinct_materialized_buffer;
1033 }
const BufferIteratorType buffer_itr_
Definition: ResultSet.h:860
int tle_no
Definition: Analyzer.h:2473
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:858
const PermutationView permutation_
Definition: ResultSet.h:859
uint32_t PermutationIdx
Definition: ResultSet.h:152
int cpu_threads()
Definition: thread_count.h:25
ThreadLocalIds thread_local_ids()
Definition: Logger.cpp:874

+ Here is the call graph for this function:

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

Definition at line 948 of file ResultSet.cpp.

References is_distinct_target().

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

948  {
949  for (const auto& order_entry : order_entries_) {
950  if (is_distinct_target(result_set_->targets_[order_entry.tle_no - 1])) {
952  materializeCountDistinctColumn(order_entry));
953  }
954  }
955 }
std::vector< int64_t > materializeCountDistinctColumn(const Analyzer::OrderEntry &order_entry) const
Definition: ResultSet.cpp:999
const ResultSet * result_set_
Definition: ResultSet.h:858
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:857
bool is_distinct_target(const TargetInfo &target_info)
Definition: TargetInfo.h:98
std::vector< std::vector< int64_t > > count_distinct_materialized_buffers_
Definition: ResultSet.h:863

+ 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 1114 of file ResultSet.cpp.

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

1115  {
1116  ResultSet::ModeBuffers::value_type materialized_buffer(
1117  result_set_->query_mem_desc_.getEntryCount());
1118  ModeScatter mode_scatter{
1119  logger::thread_local_ids(), this, order_entry, materialized_buffer};
1120  if (single_threaded_) {
1121  mode_scatter(ModeBlockedRange(0, permutation_.size())); // Still has new thread_id.
1122  } else {
1123  tbb::parallel_for(ModeBlockedRange(0, permutation_.size()), mode_scatter);
1124  }
1125  return materialized_buffer;
1126 }
DEVICE size_type size() const
Definition: VectorView.h:83
const ResultSet * result_set_
Definition: ResultSet.h:858
const PermutationView permutation_
Definition: ResultSet.h:859
void parallel_for(const blocked_range< Int > &range, const Body &body, const Partitioner &p=Partitioner())
tbb::blocked_range< size_t > ModeBlockedRange
Definition: ResultSet.cpp:1088
ThreadLocalIds thread_local_ids()
Definition: Logger.cpp:874

+ 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 984 of file ResultSet.cpp.

References kMODE.

984  {
985  ResultSet::ModeBuffers mode_buffers;
986  IsAggKind const is_mode(result_set_->targets_, kMODE);
987  mode_buffers.reserve(
988  std::count_if(order_entries_.begin(), order_entries_.end(), is_mode));
989  for (auto const& order_entry : order_entries_) {
990  if (is_mode(order_entry)) {
991  mode_buffers.emplace_back(materializeModeColumn(order_entry));
992  }
993  }
994  return mode_buffers;
995 }
const ResultSet * result_set_
Definition: ResultSet.h:858
const std::list< Analyzer::OrderEntry > & order_entries_
Definition: ResultSet.h:857
ModeBuffers::value_type materializeModeColumn(const Analyzer::OrderEntry &order_entry) const
Definition: ResultSet.cpp:1114
Definition: sqldefs.h:83
std::vector< std::vector< int64_t >> ModeBuffers
Definition: ResultSet.h:822
template<typename BUFFER_ITERATOR_TYPE >
bool ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::operator() ( const PermutationIdx  lhs,
const PermutationIdx  rhs 
) const

Definition at line 1129 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.

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

+ 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 864 of file ResultSet.h.

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

Definition at line 860 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 863 of file ResultSet.h.

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

Definition at line 861 of file ResultSet.h.

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

Definition at line 865 of file ResultSet.h.

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

Definition at line 857 of file ResultSet.h.

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

Definition at line 859 of file ResultSet.h.

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

Definition at line 858 of file ResultSet.h.

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

Definition at line 862 of file ResultSet.h.


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