OmniSciDB  a987f07e93
 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:973
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:986
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 1047 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().

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

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

References kAPPROX_QUANTILE.

973  {
974  ResultSet::ApproxQuantileBuffers approx_quantile_materialized_buffers;
975  for (const auto& order_entry : order_entries_) {
976  if (result_set_->targets_[order_entry.tle_no - 1].agg_kind == kAPPROX_QUANTILE) {
977  approx_quantile_materialized_buffers.emplace_back(
978  materializeApproxQuantileColumn(order_entry));
979  }
980  }
981  return approx_quantile_materialized_buffers;
982 }
std::vector< std::vector< double >> ApproxQuantileBuffers
Definition: ResultSet.h:821
ApproxQuantileBuffers::value_type materializeApproxQuantileColumn(const Analyzer::OrderEntry &order_entry) const
Definition: ResultSet.cpp:1047
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 1001 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().

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

+ Here is the call graph for this function:

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

Definition at line 950 of file ResultSet.cpp.

References is_distinct_target().

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

950  {
951  for (const auto& order_entry : order_entries_) {
952  if (is_distinct_target(result_set_->targets_[order_entry.tle_no - 1])) {
954  materializeCountDistinctColumn(order_entry));
955  }
956  }
957 }
std::vector< int64_t > materializeCountDistinctColumn(const Analyzer::OrderEntry &order_entry) const
Definition: ResultSet.cpp:1001
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 1116 of file ResultSet.cpp.

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

1117  {
1118  ResultSet::ModeBuffers::value_type materialized_buffer(
1119  result_set_->query_mem_desc_.getEntryCount());
1120  ModeScatter mode_scatter{
1121  logger::thread_local_ids(), this, order_entry, materialized_buffer};
1122  if (single_threaded_) {
1123  mode_scatter(ModeBlockedRange(0, permutation_.size())); // Still has new thread_id.
1124  } else {
1125  tbb::parallel_for(ModeBlockedRange(0, permutation_.size()), mode_scatter);
1126  }
1127  return materialized_buffer;
1128 }
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:1090
ThreadLocalIds thread_local_ids()
Definition: Logger.cpp:873

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

References kMODE.

986  {
987  ResultSet::ModeBuffers mode_buffers;
988  IsAggKind const is_mode(result_set_->targets_, kMODE);
989  mode_buffers.reserve(
990  std::count_if(order_entries_.begin(), order_entries_.end(), is_mode));
991  for (auto const& order_entry : order_entries_) {
992  if (is_mode(order_entry)) {
993  mode_buffers.emplace_back(materializeModeColumn(order_entry));
994  }
995  }
996  return mode_buffers;
997 }
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:1116
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 1131 of file ResultSet.cpp.

References CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, 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.

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