Autonomy Software C++ 24.5.1
Welcome to the Autonomy Software repository of the Mars Rover Design Team (MRDT) at Missouri University of Science and Technology (Missouri S&T)! API reference contains the source code and other resources for the development of the autonomy software for our Mars rover. The Autonomy Software project aims to compete in the University Rover Challenge (URC) by demonstrating advanced autonomous capabilities and robust navigation algorithms.
Loading...
Searching...
No Matches
Static Public Member Functions | Static Private Member Functions | List of all members
duckdb::AggregateExecutor Class Reference

Static Public Member Functions

template<class STATE_TYPE , class OP >
static void NullaryScatter (Vector &states, AggregateInputData &aggr_input_data, idx_t count)
 
template<class STATE_TYPE , class OP >
static void NullaryUpdate (data_ptr_t state, AggregateInputData &aggr_input_data, idx_t count)
 
template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void UnaryScatter (Vector &input, Vector &states, AggregateInputData &aggr_input_data, idx_t count)
 
template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void UnaryUpdate (Vector &input, AggregateInputData &aggr_input_data, data_ptr_t state, idx_t count)
 
template<class STATE_TYPE , class A_TYPE , class B_TYPE , class OP >
static void BinaryScatter (AggregateInputData &aggr_input_data, Vector &a, Vector &b, Vector &states, idx_t count)
 
template<class STATE_TYPE , class A_TYPE , class B_TYPE , class OP >
static void BinaryUpdate (AggregateInputData &aggr_input_data, Vector &a, Vector &b, data_ptr_t state, idx_t count)
 
template<class STATE_TYPE , class OP >
static void Combine (Vector &source, Vector &target, AggregateInputData &aggr_input_data, idx_t count)
 
template<class STATE_TYPE , class RESULT_TYPE , class OP >
static void Finalize (Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count, idx_t offset)
 
template<class STATE_TYPE , class OP >
static void VoidFinalize (Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count, idx_t offset)
 
template<typename OP >
static void IntersectFrames (const SubFrames &lefts, const SubFrames &rights, OP &op)
 
template<class STATE_TYPE , class OP >
static void Destroy (Vector &states, AggregateInputData &aggr_input_data, idx_t count)
 

Static Private Member Functions

template<class STATE_TYPE , class OP >
static void NullaryFlatLoop (STATE_TYPE **__restrict states, AggregateInputData &aggr_input_data, idx_t count)
 
template<class STATE_TYPE , class OP >
static void NullaryScatterLoop (STATE_TYPE *__restrict const *__restrict const states, AggregateInputData &aggr_input_data, const SelectionVector &ssel, const idx_t count)
 
template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void UnaryFlatLoop (const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data, STATE_TYPE **__restrict states, ValidityMask &mask, idx_t count)
 
template<class STATE_TYPE , class INPUT_TYPE , class OP , bool HAS_ISEL, bool HAS_SSEL>
static void UnaryScatterLoop (const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data, STATE_TYPE **__restrict states, const SelectionVector &isel, const SelectionVector &ssel, ValidityMask &mask, idx_t count)
 
template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void UnaryFlatUpdateLoop (const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data, STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask)
 
template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void UnaryUpdateLoop (const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data, STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask, const SelectionVector &__restrict sel_vector)
 
template<class STATE_TYPE , class A_TYPE , class B_TYPE , class OP >
static void BinaryScatterLoop (const A_TYPE *__restrict adata, AggregateInputData &aggr_input_data, const B_TYPE *__restrict bdata, STATE_TYPE **__restrict states, idx_t count, const SelectionVector &asel, const SelectionVector &bsel, const SelectionVector &ssel, ValidityMask &avalidity, ValidityMask &bvalidity)
 
template<class STATE_TYPE , class A_TYPE , class B_TYPE , class OP >
static void BinaryUpdateLoop (const A_TYPE *__restrict adata, AggregateInputData &aggr_input_data, const B_TYPE *__restrict bdata, STATE_TYPE *__restrict state, idx_t count, const SelectionVector &asel, const SelectionVector &bsel, ValidityMask &avalidity, ValidityMask &bvalidity)
 

Member Function Documentation

◆ NullaryFlatLoop()

template<class STATE_TYPE , class OP >
static void duckdb::AggregateExecutor::NullaryFlatLoop ( STATE_TYPE **__restrict  states,
AggregateInputData &  aggr_input_data,
idx_t  count 
)
inlinestaticprivate
16939 {
16940 for (idx_t i = 0; i < count; i++) {
16941 OP::template Operation<STATE_TYPE, OP>(*states[i], aggr_input_data, i);
16942 }
16943 }

◆ NullaryScatterLoop()

template<class STATE_TYPE , class OP >
static void duckdb::AggregateExecutor::NullaryScatterLoop ( STATE_TYPE *__restrict const *__restrict const  states,
AggregateInputData &  aggr_input_data,
const SelectionVector &  ssel,
const idx_t  count 
)
inlinestaticprivate
16949 {
16950 if (ssel.IsSet()) {
16951 for (idx_t i = 0; i < count; i++) {
16952 auto sidx = ssel.get_index_unsafe(i);
16953 OP::template Operation<STATE_TYPE, OP>(*states[sidx], aggr_input_data, sidx);
16954 }
16955 } else {
16956 for (idx_t i = 0; i < count; i++) {
16957 OP::template Operation<STATE_TYPE, OP>(*states[i], aggr_input_data, i);
16958 }
16959 }
16960 }

◆ UnaryFlatLoop()

template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void duckdb::AggregateExecutor::UnaryFlatLoop ( const INPUT_TYPE *__restrict  idata,
AggregateInputData &  aggr_input_data,
STATE_TYPE **__restrict  states,
ValidityMask &  mask,
idx_t  count 
)
inlinestaticprivate
16965 {
16966 if (OP::IgnoreNull() && !mask.AllValid()) {
16967 AggregateUnaryInput input(aggr_input_data, mask);
16968 auto &base_idx = input.input_idx;
16969 base_idx = 0;
16970 auto entry_count = ValidityMask::EntryCount(count);
16971 for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
16972 auto validity_entry = mask.GetValidityEntry(entry_idx);
16973 idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
16974 if (ValidityMask::AllValid(validity_entry)) {
16975 // all valid: perform operation
16976 for (; base_idx < next; base_idx++) {
16977 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[base_idx], idata[base_idx], input);
16978 }
16979 } else if (ValidityMask::NoneValid(validity_entry)) {
16980 // nothing valid: skip all
16981 base_idx = next;
16982 continue;
16983 } else {
16984 // partially valid: need to check individual elements for validity
16985 idx_t start = base_idx;
16986 for (; base_idx < next; base_idx++) {
16987 if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
16988 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[base_idx], idata[base_idx],
16989 input);
16990 }
16991 }
16992 }
16993 }
16994 } else {
16995 AggregateUnaryInput input(aggr_input_data, mask);
16996 auto &i = input.input_idx;
16997 for (i = 0; i < count; i++) {
16998 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[i], idata[i], input);
16999 }
17000 }
17001 }
mask
GMat mask(const GMat &src, const GMat &mask)

◆ UnaryScatterLoop()

template<class STATE_TYPE , class INPUT_TYPE , class OP , bool HAS_ISEL, bool HAS_SSEL>
static void duckdb::AggregateExecutor::UnaryScatterLoop ( const INPUT_TYPE *__restrict  idata,
AggregateInputData &  aggr_input_data,
STATE_TYPE **__restrict  states,
const SelectionVector &  isel,
const SelectionVector &  ssel,
ValidityMask &  mask,
idx_t  count 
)
inlinestaticprivate
17011 {
17012#ifdef DUCKDB_SMALLER_BINARY
17013 const auto HAS_ISEL = isel.IsSet();
17014 const auto HAS_SSEL = ssel.IsSet();
17015#endif
17016 if (OP::IgnoreNull() && !mask.AllValid()) {
17017 // potential NULL values and NULL values are ignored
17018 AggregateUnaryInput input(aggr_input_data, mask);
17019 for (idx_t i = 0; i < count; i++) {
17020 input.input_idx = HAS_ISEL ? isel.get_index_unsafe(i) : i;
17021 auto sidx = HAS_SSEL ? ssel.get_index_unsafe(i) : i;
17022 if (mask.RowIsValidUnsafe(input.input_idx)) {
17023 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[sidx], idata[input.input_idx], input);
17024 }
17025 }
17026 } else {
17027 // quick path: no NULL values or NULL values are not ignored
17028 AggregateUnaryInput input(aggr_input_data, mask);
17029 for (idx_t i = 0; i < count; i++) {
17030 input.input_idx = HAS_ISEL ? isel.get_index_unsafe(i) : i;
17031 auto sidx = HAS_SSEL ? ssel.get_index_unsafe(i) : i;
17032 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*states[sidx], idata[input.input_idx], input);
17033 }
17034 }
17035 }

◆ UnaryFlatUpdateLoop()

template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void duckdb::AggregateExecutor::UnaryFlatUpdateLoop ( const INPUT_TYPE *__restrict  idata,
AggregateInputData &  aggr_input_data,
STATE_TYPE *__restrict  state,
idx_t  count,
ValidityMask &  mask 
)
inlinestaticprivate
17040 {
17041 AggregateUnaryInput input(aggr_input_data, mask);
17042 auto &base_idx = input.input_idx;
17043 base_idx = 0;
17044 auto entry_count = ValidityMask::EntryCount(count);
17045 for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
17046 auto validity_entry = mask.GetValidityEntry(entry_idx);
17047 idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
17048 if (!OP::IgnoreNull() || ValidityMask::AllValid(validity_entry)) {
17049 // all valid: perform operation
17050 for (; base_idx < next; base_idx++) {
17051 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*state, idata[base_idx], input);
17052 }
17053 } else if (ValidityMask::NoneValid(validity_entry)) {
17054 // nothing valid: skip all
17055 base_idx = next;
17056 continue;
17057 } else {
17058 // partially valid: need to check individual elements for validity
17059 idx_t start = base_idx;
17060 for (; base_idx < next; base_idx++) {
17061 if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
17062 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*state, idata[base_idx], input);
17063 }
17064 }
17065 }
17066 }
17067 }

◆ UnaryUpdateLoop()

template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void duckdb::AggregateExecutor::UnaryUpdateLoop ( const INPUT_TYPE *__restrict  idata,
AggregateInputData &  aggr_input_data,
STATE_TYPE *__restrict  state,
idx_t  count,
ValidityMask &  mask,
const SelectionVector &__restrict  sel_vector 
)
inlinestaticprivate
17073 {
17074 AggregateUnaryInput input(aggr_input_data, mask);
17075 if (OP::IgnoreNull() && !mask.AllValid()) {
17076 // potential NULL values and NULL values are ignored
17077 for (idx_t i = 0; i < count; i++) {
17078 input.input_idx = sel_vector.get_index(i);
17079 if (mask.RowIsValid(input.input_idx)) {
17080 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*state, idata[input.input_idx], input);
17081 }
17082 }
17083 } else {
17084 // quick path: no NULL values or NULL values are not ignored
17085 for (idx_t i = 0; i < count; i++) {
17086 input.input_idx = sel_vector.get_index(i);
17087 OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(*state, idata[input.input_idx], input);
17088 }
17089 }
17090 }

◆ BinaryScatterLoop()

template<class STATE_TYPE , class A_TYPE , class B_TYPE , class OP >
static void duckdb::AggregateExecutor::BinaryScatterLoop ( const A_TYPE *__restrict  adata,
AggregateInputData &  aggr_input_data,
const B_TYPE *__restrict  bdata,
STATE_TYPE **__restrict  states,
idx_t  count,
const SelectionVector &  asel,
const SelectionVector &  bsel,
const SelectionVector &  ssel,
ValidityMask &  avalidity,
ValidityMask &  bvalidity 
)
inlinestaticprivate
17097 {
17098 AggregateBinaryInput input(aggr_input_data, avalidity, bvalidity);
17099 if (OP::IgnoreNull() && (!avalidity.AllValid() || !bvalidity.AllValid())) {
17100 // potential NULL values and NULL values are ignored
17101 for (idx_t i = 0; i < count; i++) {
17102 input.lidx = asel.get_index(i);
17103 input.ridx = bsel.get_index(i);
17104 auto sidx = ssel.get_index(i);
17105 if (avalidity.RowIsValid(input.lidx) && bvalidity.RowIsValid(input.ridx)) {
17106 OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(*states[sidx], adata[input.lidx],
17107 bdata[input.ridx], input);
17108 }
17109 }
17110 } else {
17111 // quick path: no NULL values or NULL values are not ignored
17112 for (idx_t i = 0; i < count; i++) {
17113 input.lidx = asel.get_index(i);
17114 input.ridx = bsel.get_index(i);
17115 auto sidx = ssel.get_index(i);
17116 OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(*states[sidx], adata[input.lidx],
17117 bdata[input.ridx], input);
17118 }
17119 }
17120 }

◆ BinaryUpdateLoop()

template<class STATE_TYPE , class A_TYPE , class B_TYPE , class OP >
static void duckdb::AggregateExecutor::BinaryUpdateLoop ( const A_TYPE *__restrict  adata,
AggregateInputData &  aggr_input_data,
const B_TYPE *__restrict  bdata,
STATE_TYPE *__restrict  state,
idx_t  count,
const SelectionVector &  asel,
const SelectionVector &  bsel,
ValidityMask &  avalidity,
ValidityMask &  bvalidity 
)
inlinestaticprivate
17126 {
17127 AggregateBinaryInput input(aggr_input_data, avalidity, bvalidity);
17128 if (OP::IgnoreNull() && (!avalidity.AllValid() || !bvalidity.AllValid())) {
17129 // potential NULL values and NULL values are ignored
17130 for (idx_t i = 0; i < count; i++) {
17131 input.lidx = asel.get_index(i);
17132 input.ridx = bsel.get_index(i);
17133 if (avalidity.RowIsValid(input.lidx) && bvalidity.RowIsValid(input.ridx)) {
17134 OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(*state, adata[input.lidx], bdata[input.ridx],
17135 input);
17136 }
17137 }
17138 } else {
17139 // quick path: no NULL values or NULL values are not ignored
17140 for (idx_t i = 0; i < count; i++) {
17141 input.lidx = asel.get_index(i);
17142 input.ridx = bsel.get_index(i);
17143 OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(*state, adata[input.lidx], bdata[input.ridx],
17144 input);
17145 }
17146 }
17147 }

◆ NullaryScatter()

template<class STATE_TYPE , class OP >
static void duckdb::AggregateExecutor::NullaryScatter ( Vector &  states,
AggregateInputData &  aggr_input_data,
idx_t  count 
)
inlinestatic
17151 {
17152 if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
17153 auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
17154 OP::template ConstantOperation<STATE_TYPE, OP>(**sdata, aggr_input_data, count);
17155#ifndef DUCKDB_SMALLER_BINARY
17156 } else if (states.GetVectorType() == VectorType::FLAT_VECTOR) {
17157 auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
17158 NullaryFlatLoop<STATE_TYPE, OP>(sdata, aggr_input_data, count);
17159#endif
17160 } else {
17161 UnifiedVectorFormat sdata;
17162 states.ToUnifiedFormat(count, sdata);
17163 NullaryScatterLoop<STATE_TYPE, OP>((STATE_TYPE **)sdata.data, aggr_input_data, *sdata.sel, count);
17164 }
17165 }

◆ NullaryUpdate()

template<class STATE_TYPE , class OP >
static void duckdb::AggregateExecutor::NullaryUpdate ( data_ptr_t  state,
AggregateInputData &  aggr_input_data,
idx_t  count 
)
inlinestatic
17168 {
17169 OP::template ConstantOperation<STATE_TYPE, OP>(*reinterpret_cast<STATE_TYPE *>(state), aggr_input_data, count);
17170 }

◆ UnaryScatter()

template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void duckdb::AggregateExecutor::UnaryScatter ( Vector &  input,
Vector &  states,
AggregateInputData &  aggr_input_data,
idx_t  count 
)
inlinestatic
17173 {
17174 if (input.GetVectorType() == VectorType::CONSTANT_VECTOR &&
17175 states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
17176 if (OP::IgnoreNull() && ConstantVector::IsNull(input)) {
17177 // constant NULL input in function that ignores NULL values
17178 return;
17179 }
17180 // regular constant: get first state
17181 auto idata = ConstantVector::GetData<INPUT_TYPE>(input);
17182 auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
17183 AggregateUnaryInput input_data(aggr_input_data, ConstantVector::Validity(input));
17184 OP::template ConstantOperation<INPUT_TYPE, STATE_TYPE, OP>(**sdata, *idata, input_data, count);
17185#ifndef DUCKDB_SMALLER_BINARY
17186 } else if (input.GetVectorType() == VectorType::FLAT_VECTOR &&
17187 states.GetVectorType() == VectorType::FLAT_VECTOR) {
17188 auto idata = FlatVector::GetData<INPUT_TYPE>(input);
17189 auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
17190 UnaryFlatLoop<STATE_TYPE, INPUT_TYPE, OP>(idata, aggr_input_data, sdata, FlatVector::Validity(input),
17191 count);
17192#endif
17193 } else {
17194 UnifiedVectorFormat idata, sdata;
17195 input.ToUnifiedFormat(count, idata);
17196 states.ToUnifiedFormat(count, sdata);
17197#ifdef DUCKDB_SMALLER_BINARY
17198 UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP>(UnifiedVectorFormat::GetData<INPUT_TYPE>(idata),
17199 aggr_input_data, (STATE_TYPE **)sdata.data, *idata.sel,
17200 *sdata.sel, idata.validity, count);
17201#else
17202 if (idata.sel->IsSet()) {
17203 if (sdata.sel->IsSet()) {
17204 UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP, true, true>(
17205 UnifiedVectorFormat::GetData<INPUT_TYPE>(idata), aggr_input_data, (STATE_TYPE **)sdata.data,
17206 *idata.sel, *sdata.sel, idata.validity, count);
17207 } else {
17208 UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP, true, false>(
17209 UnifiedVectorFormat::GetData<INPUT_TYPE>(idata), aggr_input_data, (STATE_TYPE **)sdata.data,
17210 *idata.sel, *sdata.sel, idata.validity, count);
17211 }
17212 } else {
17213 if (sdata.sel->IsSet()) {
17214 UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP, false, true>(
17215 UnifiedVectorFormat::GetData<INPUT_TYPE>(idata), aggr_input_data, (STATE_TYPE **)sdata.data,
17216 *idata.sel, *sdata.sel, idata.validity, count);
17217 } else {
17218 UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP, false, false>(
17219 UnifiedVectorFormat::GetData<INPUT_TYPE>(idata), aggr_input_data, (STATE_TYPE **)sdata.data,
17220 *idata.sel, *sdata.sel, idata.validity, count);
17221 }
17222 }
17223
17224#endif
17225 }
17226 }

◆ UnaryUpdate()

template<class STATE_TYPE , class INPUT_TYPE , class OP >
static void duckdb::AggregateExecutor::UnaryUpdate ( Vector &  input,
AggregateInputData &  aggr_input_data,
data_ptr_t  state,
idx_t  count 
)
inlinestatic
17229 {
17230 switch (input.GetVectorType()) {
17231 case VectorType::CONSTANT_VECTOR: {
17232 if (OP::IgnoreNull() && ConstantVector::IsNull(input)) {
17233 return;
17234 }
17235 auto idata = ConstantVector::GetData<INPUT_TYPE>(input);
17236 AggregateUnaryInput input_data(aggr_input_data, ConstantVector::Validity(input));
17237 OP::template ConstantOperation<INPUT_TYPE, STATE_TYPE, OP>(*reinterpret_cast<STATE_TYPE *>(state), *idata,
17238 input_data, count);
17239 break;
17240 }
17241#ifndef DUCKDB_SMALLER_BINARY
17242 case VectorType::FLAT_VECTOR: {
17243 auto idata = FlatVector::GetData<INPUT_TYPE>(input);
17244 UnaryFlatUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>(idata, aggr_input_data, (STATE_TYPE *)state, count,
17245 FlatVector::Validity(input));
17246 break;
17247 }
17248#endif
17249 default: {
17250 UnifiedVectorFormat idata;
17251 input.ToUnifiedFormat(count, idata);
17252 UnaryUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>(UnifiedVectorFormat::GetData<INPUT_TYPE>(idata),
17253 aggr_input_data, (STATE_TYPE *)state, count, idata.validity,
17254 *idata.sel);
17255 break;
17256 }
17257 }
17258 }

◆ BinaryScatter()

template<class STATE_TYPE , class A_TYPE , class B_TYPE , class OP >
static void duckdb::AggregateExecutor::BinaryScatter ( AggregateInputData &  aggr_input_data,
Vector &  a,
Vector &  b,
Vector &  states,
idx_t  count 
)
inlinestatic
17261 {
17262 UnifiedVectorFormat adata, bdata, sdata;
17263
17264 a.ToUnifiedFormat(count, adata);
17265 b.ToUnifiedFormat(count, bdata);
17266 states.ToUnifiedFormat(count, sdata);
17267
17268 BinaryScatterLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>(
17269 UnifiedVectorFormat::GetData<A_TYPE>(adata), aggr_input_data, UnifiedVectorFormat::GetData<B_TYPE>(bdata),
17270 (STATE_TYPE **)sdata.data, count, *adata.sel, *bdata.sel, *sdata.sel, adata.validity, bdata.validity);
17271 }

◆ BinaryUpdate()

template<class STATE_TYPE , class A_TYPE , class B_TYPE , class OP >
static void duckdb::AggregateExecutor::BinaryUpdate ( AggregateInputData &  aggr_input_data,
Vector &  a,
Vector &  b,
data_ptr_t  state,
idx_t  count 
)
inlinestatic
17274 {
17275 UnifiedVectorFormat adata, bdata;
17276
17277 a.ToUnifiedFormat(count, adata);
17278 b.ToUnifiedFormat(count, bdata);
17279
17280 BinaryUpdateLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>(
17281 UnifiedVectorFormat::GetData<A_TYPE>(adata), aggr_input_data, UnifiedVectorFormat::GetData<B_TYPE>(bdata),
17282 (STATE_TYPE *)state, count, *adata.sel, *bdata.sel, adata.validity, bdata.validity);
17283 }

◆ Combine()

template<class STATE_TYPE , class OP >
static void duckdb::AggregateExecutor::Combine ( Vector &  source,
Vector &  target,
AggregateInputData &  aggr_input_data,
idx_t  count 
)
inlinestatic
17286 {
17287 D_ASSERT(source.GetType().id() == LogicalTypeId::POINTER && target.GetType().id() == LogicalTypeId::POINTER);
17288 auto sdata = FlatVector::GetData<const STATE_TYPE *>(source);
17289 auto tdata = FlatVector::GetData<STATE_TYPE *>(target);
17290
17291 for (idx_t i = 0; i < count; i++) {
17292 OP::template Combine<STATE_TYPE, OP>(*sdata[i], *tdata[i], aggr_input_data);
17293 }
17294 }

◆ Finalize()

template<class STATE_TYPE , class RESULT_TYPE , class OP >
static void duckdb::AggregateExecutor::Finalize ( Vector &  states,
AggregateInputData &  aggr_input_data,
Vector &  result,
idx_t  count,
idx_t  offset 
)
inlinestatic
17298 {
17299 if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
17300 result.SetVectorType(VectorType::CONSTANT_VECTOR);
17301
17302 auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
17303 auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
17304 AggregateFinalizeData finalize_data(result, aggr_input_data);
17305 OP::template Finalize<RESULT_TYPE, STATE_TYPE>(**sdata, *rdata, finalize_data);
17306 } else {
17307 D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
17308 result.SetVectorType(VectorType::FLAT_VECTOR);
17309
17310 auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
17311 auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
17312 AggregateFinalizeData finalize_data(result, aggr_input_data);
17313 for (idx_t i = 0; i < count; i++) {
17314 finalize_data.result_idx = i + offset;
17315 OP::template Finalize<RESULT_TYPE, STATE_TYPE>(*sdata[i], rdata[finalize_data.result_idx],
17316 finalize_data);
17317 }
17318 }
17319 }

◆ VoidFinalize()

template<class STATE_TYPE , class OP >
static void duckdb::AggregateExecutor::VoidFinalize ( Vector &  states,
AggregateInputData &  aggr_input_data,
Vector &  result,
idx_t  count,
idx_t  offset 
)
inlinestatic
17323 {
17324 if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
17325 result.SetVectorType(VectorType::CONSTANT_VECTOR);
17326
17327 auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
17328 AggregateFinalizeData finalize_data(result, aggr_input_data);
17329 OP::template Finalize<STATE_TYPE>(**sdata, finalize_data);
17330 } else {
17331 D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
17332 result.SetVectorType(VectorType::FLAT_VECTOR);
17333
17334 auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
17335 AggregateFinalizeData finalize_data(result, aggr_input_data);
17336 for (idx_t i = 0; i < count; i++) {
17337 finalize_data.result_idx = i + offset;
17338 OP::template Finalize<STATE_TYPE>(*sdata[i], finalize_data);
17339 }
17340 }
17341 }

◆ IntersectFrames()

template<typename OP >
static void duckdb::AggregateExecutor::IntersectFrames ( const SubFrames &  lefts,
const SubFrames &  rights,
OP &  op 
)
inlinestatic
17344 {
17345 const auto cover_start = MinValue(rights[0].start, lefts[0].start);
17346 const auto cover_end = MaxValue(rights.back().end, lefts.back().end);
17347 const FrameBounds last(cover_end, cover_end);
17348
17349 // Subframe indices
17350 idx_t l = 0;
17351 idx_t r = 0;
17352 for (auto i = cover_start; i < cover_end;) {
17353 uint8_t overlap = 0;
17354
17355 // Are we in the previous frame?
17356 auto left = &last;
17357 if (l < lefts.size()) {
17358 left = &lefts[l];
17359 overlap |= uint8_t(left->start <= i && i < left->end) << 0;
17360 }
17361
17362 // Are we in the current frame?
17363 auto right = &last;
17364 if (r < rights.size()) {
17365 right = &rights[r];
17366 overlap |= uint8_t(right->start <= i && i < right->end) << 1;
17367 }
17368
17369 auto limit = i;
17370 switch (overlap) {
17371 case 0x00:
17372 // i ∉ F U P
17373 limit = MinValue(right->start, left->start);
17374 op.Neither(i, limit);
17375 break;
17376 case 0x01:
17377 // i ∈ P \ F
17378 limit = MinValue(left->end, right->start);
17379 op.Left(i, limit);
17380 break;
17381 case 0x02:
17382 // i ∈ F \ P
17383 limit = MinValue(right->end, left->start);
17384 op.Right(i, limit);
17385 break;
17386 case 0x03:
17387 default:
17388 D_ASSERT(overlap == 0x03);
17389 // i ∈ F ∩ P
17390 limit = MinValue(right->end, left->end);
17391 op.Both(i, limit);
17392 break;
17393 }
17394
17395 // Advance the subframe indices
17396 i = limit;
17397 l += (i == left->end);
17398 r += (i == right->end);
17399 }
17400 }
uint8_t
::uint8_t uint8_t

◆ Destroy()

template<class STATE_TYPE , class OP >
static void duckdb::AggregateExecutor::Destroy ( Vector &  states,
AggregateInputData &  aggr_input_data,
idx_t  count 
)
inlinestatic
17403 {
17404 auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
17405 for (idx_t i = 0; i < count; i++) {
17406 OP::template Destroy<STATE_TYPE>(*sdata[i], aggr_input_data);
17407 }
17408 }
The documentation for this class was generated from the following file: