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 | List of all members
duckdb::BinaryExecutor Struct Reference

Static Public Member Functions

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC , bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
static void ExecuteFlatLoop (const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata, RESULT_TYPE *__restrict result_data, idx_t count, ValidityMask &mask, FUNC fun)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC >
static void ExecuteConstant (Vector &left, Vector &right, Vector &result, FUNC fun)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC , bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
static void ExecuteFlat (Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC >
static void ExecuteGenericLoop (const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata, RESULT_TYPE *__restrict result_data, const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel, idx_t count, ValidityMask &lvalidity, ValidityMask &rvalidity, ValidityMask &result_validity, FUNC fun)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC >
static void ExecuteGeneric (Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC >
static void ExecuteSwitch (Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class FUNC = std::function<RESULT_TYPE(LEFT_TYPE, RIGHT_TYPE)>>
static void Execute (Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OP , class OPWRAPPER = BinarySingleArgumentOperatorWrapper>
static void Execute (Vector &left, Vector &right, Vector &result, idx_t count)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OP >
static void ExecuteStandard (Vector &left, Vector &right, Vector &result, idx_t count)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class FUNC = std::function<RESULT_TYPE(LEFT_TYPE, RIGHT_TYPE, ValidityMask &, idx_t)>>
static void ExecuteWithNulls (Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP >
static idx_t SelectConstant (Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel, SelectionVector *false_sel)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
static idx_t SelectFlatLoop (const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata, const SelectionVector *sel, idx_t count, ValidityMask &validity_mask, SelectionVector *true_sel, SelectionVector *false_sel)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
static idx_t SelectFlatLoopSwitch (const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata, const SelectionVector *sel, idx_t count, ValidityMask &mask, SelectionVector *true_sel, SelectionVector *false_sel)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
static idx_t SelectFlat (Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel, SelectionVector *false_sel)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
static idx_t SelectGenericLoop (const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata, const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel, const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity, ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool NO_NULL>
static idx_t SelectGenericLoopSelSwitch (const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata, const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel, const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity, ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP >
static idx_t SelectGenericLoopSwitch (const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata, const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel, const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity, ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP >
static idx_t SelectGeneric (Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel, SelectionVector *false_sel)
 
template<class LEFT_TYPE , class RIGHT_TYPE , class OP >
static idx_t Select (Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel, SelectionVector *false_sel)
 

Member Function Documentation

◆ ExecuteFlatLoop()

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC , bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
static void duckdb::BinaryExecutor::ExecuteFlatLoop ( const LEFT_TYPE *__restrict  ldata,
const RIGHT_TYPE *__restrict  rdata,
RESULT_TYPE *__restrict  result_data,
idx_t  count,
ValidityMask &  mask,
FUNC  fun 
)
inlinestatic
11829 {
11830 if (!LEFT_CONSTANT) {
11831 ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
11832 }
11833 if (!RIGHT_CONSTANT) {
11834 ASSERT_RESTRICT(rdata, rdata + count, result_data, result_data + count);
11835 }
11836
11837 if (!mask.AllValid()) {
11838 idx_t base_idx = 0;
11839 auto entry_count = ValidityMask::EntryCount(count);
11840 for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
11841 auto validity_entry = mask.GetValidityEntry(entry_idx);
11842 idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
11843 if (ValidityMask::AllValid(validity_entry)) {
11844 // all valid: perform operation
11845 for (; base_idx < next; base_idx++) {
11846 auto lentry = ldata[LEFT_CONSTANT ? 0 : base_idx];
11847 auto rentry = rdata[RIGHT_CONSTANT ? 0 : base_idx];
11848 result_data[base_idx] =
11849 OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
11850 fun, lentry, rentry, mask, base_idx);
11851 }
11852 } else if (ValidityMask::NoneValid(validity_entry)) {
11853 // nothing valid: skip all
11854 base_idx = next;
11855 continue;
11856 } else {
11857 // partially valid: need to check individual elements for validity
11858 idx_t start = base_idx;
11859 for (; base_idx < next; base_idx++) {
11860 if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
11861 auto lentry = ldata[LEFT_CONSTANT ? 0 : base_idx];
11862 auto rentry = rdata[RIGHT_CONSTANT ? 0 : base_idx];
11863 result_data[base_idx] =
11864 OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
11865 fun, lentry, rentry, mask, base_idx);
11866 }
11867 }
11868 }
11869 }
11870 } else {
11871 for (idx_t i = 0; i < count; i++) {
11872 auto lentry = ldata[LEFT_CONSTANT ? 0 : i];
11873 auto rentry = rdata[RIGHT_CONSTANT ? 0 : i];
11874 result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
11875 fun, lentry, rentry, mask, i);
11876 }
11877 }
11878 }
mask
GMat mask(const GMat &src, const GMat &mask)

◆ ExecuteConstant()

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC >
static void duckdb::BinaryExecutor::ExecuteConstant ( Vector &  left,
Vector &  right,
Vector &  result,
FUNC  fun 
)
inlinestatic
11882 {
11883 result.SetVectorType(VectorType::CONSTANT_VECTOR);
11884
11885 auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
11886 auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
11887 auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
11888
11889 if (ConstantVector::IsNull(left) || ConstantVector::IsNull(right)) {
11890 ConstantVector::SetNull(result, true);
11891 return;
11892 }
11893 *result_data = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
11894 fun, *ldata, *rdata, ConstantVector::Validity(result), 0);
11895 }

◆ ExecuteFlat()

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC , bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
static void duckdb::BinaryExecutor::ExecuteFlat ( Vector &  left,
Vector &  right,
Vector &  result,
idx_t  count,
FUNC  fun 
)
inlinestatic
11900 {
11901 auto ldata = FlatVector::GetData<LEFT_TYPE>(left);
11902 auto rdata = FlatVector::GetData<RIGHT_TYPE>(right);
11903
11904 if ((LEFT_CONSTANT && ConstantVector::IsNull(left)) || (RIGHT_CONSTANT && ConstantVector::IsNull(right))) {
11905 // either left or right is constant NULL: result is constant NULL
11906 result.SetVectorType(VectorType::CONSTANT_VECTOR);
11907 ConstantVector::SetNull(result, true);
11908 return;
11909 }
11910
11911 result.SetVectorType(VectorType::FLAT_VECTOR);
11912 auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
11913 auto &result_validity = FlatVector::Validity(result);
11914 if (LEFT_CONSTANT) {
11915 if (OPWRAPPER::AddsNulls()) {
11916 result_validity.Copy(FlatVector::Validity(right), count);
11917 } else {
11918 FlatVector::SetValidity(result, FlatVector::Validity(right));
11919 }
11920 } else if (RIGHT_CONSTANT) {
11921 if (OPWRAPPER::AddsNulls()) {
11922 result_validity.Copy(FlatVector::Validity(left), count);
11923 } else {
11924 FlatVector::SetValidity(result, FlatVector::Validity(left));
11925 }
11926 } else {
11927 if (OPWRAPPER::AddsNulls()) {
11928 result_validity.Copy(FlatVector::Validity(left), count);
11929 if (result_validity.AllValid()) {
11930 result_validity.Copy(FlatVector::Validity(right), count);
11931 } else {
11932 result_validity.Combine(FlatVector::Validity(right), count);
11933 }
11934 } else {
11935 FlatVector::SetValidity(result, FlatVector::Validity(left));
11936 result_validity.Combine(FlatVector::Validity(right), count);
11937 }
11938 }
11939 ExecuteFlatLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, LEFT_CONSTANT, RIGHT_CONSTANT>(
11940 ldata, rdata, result_data, count, result_validity, fun);
11941 }

◆ ExecuteGenericLoop()

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC >
static void duckdb::BinaryExecutor::ExecuteGenericLoop ( const LEFT_TYPE *__restrict  ldata,
const RIGHT_TYPE *__restrict  rdata,
RESULT_TYPE *__restrict  result_data,
const SelectionVector *__restrict  lsel,
const SelectionVector *__restrict  rsel,
idx_t  count,
ValidityMask &  lvalidity,
ValidityMask &  rvalidity,
ValidityMask &  result_validity,
FUNC  fun 
)
inlinestatic
11948 {
11949 if (!lvalidity.AllValid() || !rvalidity.AllValid()) {
11950 for (idx_t i = 0; i < count; i++) {
11951 auto lindex = lsel->get_index(i);
11952 auto rindex = rsel->get_index(i);
11953 if (lvalidity.RowIsValid(lindex) && rvalidity.RowIsValid(rindex)) {
11954 auto lentry = ldata[lindex];
11955 auto rentry = rdata[rindex];
11956 result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
11957 fun, lentry, rentry, result_validity, i);
11958 } else {
11959 result_validity.SetInvalid(i);
11960 }
11961 }
11962 } else {
11963 for (idx_t i = 0; i < count; i++) {
11964 auto lentry = ldata[lsel->get_index(i)];
11965 auto rentry = rdata[rsel->get_index(i)];
11966 result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
11967 fun, lentry, rentry, result_validity, i);
11968 }
11969 }
11970 }

◆ ExecuteGeneric()

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC >
static void duckdb::BinaryExecutor::ExecuteGeneric ( Vector &  left,
Vector &  right,
Vector &  result,
idx_t  count,
FUNC  fun 
)
inlinestatic
11973 {
11974 UnifiedVectorFormat ldata, rdata;
11975
11976 left.ToUnifiedFormat(count, ldata);
11977 right.ToUnifiedFormat(count, rdata);
11978
11979 result.SetVectorType(VectorType::FLAT_VECTOR);
11980 auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
11981 ExecuteGenericLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(
11982 UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata),
11983 result_data, ldata.sel, rdata.sel, count, ldata.validity, rdata.validity, FlatVector::Validity(result),
11984 fun);
11985 }

◆ ExecuteSwitch()

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OPWRAPPER , class OP , class FUNC >
static void duckdb::BinaryExecutor::ExecuteSwitch ( Vector &  left,
Vector &  right,
Vector &  result,
idx_t  count,
FUNC  fun 
)
inlinestatic
11988 {
11989 auto left_vector_type = left.GetVectorType();
11990 auto right_vector_type = right.GetVectorType();
11991 if (left_vector_type == VectorType::CONSTANT_VECTOR && right_vector_type == VectorType::CONSTANT_VECTOR) {
11992 ExecuteConstant<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(left, right, result, fun);
11993#ifndef DUCKDB_SMALLER_BINARY
11994 } else if (left_vector_type == VectorType::FLAT_VECTOR && right_vector_type == VectorType::CONSTANT_VECTOR) {
11995 ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, false, true>(left, right, result,
11996 count, fun);
11997 } else if (left_vector_type == VectorType::CONSTANT_VECTOR && right_vector_type == VectorType::FLAT_VECTOR) {
11998 ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, true, false>(left, right, result,
11999 count, fun);
12000 } else if (left_vector_type == VectorType::FLAT_VECTOR && right_vector_type == VectorType::FLAT_VECTOR) {
12001 ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, false, false>(left, right, result,
12002 count, fun);
12003#endif
12004 } else {
12005 ExecuteGeneric<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(left, right, result, count, fun);
12006 }
12007 }

◆ Execute() [1/2]

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class FUNC = std::function<RESULT_TYPE(LEFT_TYPE, RIGHT_TYPE)>>
static void duckdb::BinaryExecutor::Execute ( Vector &  left,
Vector &  right,
Vector &  result,
idx_t  count,
FUNC  fun 
)
inlinestatic
12012 {
12013 ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryLambdaWrapper, bool, FUNC>(left, right, result, count,
12014 fun);
12015 }

◆ Execute() [2/2]

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OP , class OPWRAPPER = BinarySingleArgumentOperatorWrapper>
static void duckdb::BinaryExecutor::Execute ( Vector &  left,
Vector &  right,
Vector &  result,
idx_t  count 
)
inlinestatic
12019 {
12020 ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, bool>(left, right, result, count, false);
12021 }

◆ ExecuteStandard()

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class OP >
static void duckdb::BinaryExecutor::ExecuteStandard ( Vector &  left,
Vector &  right,
Vector &  result,
idx_t  count 
)
inlinestatic
12024 {
12025 ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryStandardOperatorWrapper, OP, bool>(left, right, result,
12026 count, false);
12027 }

◆ ExecuteWithNulls()

template<class LEFT_TYPE , class RIGHT_TYPE , class RESULT_TYPE , class FUNC = std::function<RESULT_TYPE(LEFT_TYPE, RIGHT_TYPE, ValidityMask &, idx_t)>>
static void duckdb::BinaryExecutor::ExecuteWithNulls ( Vector &  left,
Vector &  right,
Vector &  result,
idx_t  count,
FUNC  fun 
)
inlinestatic
12031 {
12032 ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryLambdaWrapperWithNulls, bool, FUNC>(left, right, result,
12033 count, fun);
12034 }

◆ SelectConstant()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP >
static idx_t duckdb::BinaryExecutor::SelectConstant ( Vector &  left,
Vector &  right,
const SelectionVector *  sel,
idx_t  count,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12039 {
12040 auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
12041 auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
12042
12043 // both sides are constant, return either 0 or the count
12044 // in this case we do not fill in the result selection vector at all
12045 if (ConstantVector::IsNull(left) || ConstantVector::IsNull(right) || !OP::Operation(*ldata, *rdata)) {
12046 if (false_sel) {
12047 for (idx_t i = 0; i < count; i++) {
12048 false_sel->set_index(i, sel->get_index(i));
12049 }
12050 }
12051 return 0;
12052 } else {
12053 if (true_sel) {
12054 for (idx_t i = 0; i < count; i++) {
12055 true_sel->set_index(i, sel->get_index(i));
12056 }
12057 }
12058 return count;
12059 }
12060 }

◆ SelectFlatLoop()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
static idx_t duckdb::BinaryExecutor::SelectFlatLoop ( const LEFT_TYPE *__restrict  ldata,
const RIGHT_TYPE *__restrict  rdata,
const SelectionVector *  sel,
idx_t  count,
ValidityMask &  validity_mask,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12067 {
12068 idx_t true_count = 0, false_count = 0;
12069 idx_t base_idx = 0;
12070 auto entry_count = ValidityMask::EntryCount(count);
12071 for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
12072 auto validity_entry = validity_mask.GetValidityEntry(entry_idx);
12073 idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
12074 if (ValidityMask::AllValid(validity_entry)) {
12075 // all valid: perform operation
12076 for (; base_idx < next; base_idx++) {
12077 idx_t result_idx = sel->get_index(base_idx);
12078 idx_t lidx = LEFT_CONSTANT ? 0 : base_idx;
12079 idx_t ridx = RIGHT_CONSTANT ? 0 : base_idx;
12080 bool comparison_result = OP::Operation(ldata[lidx], rdata[ridx]);
12081 if (HAS_TRUE_SEL) {
12082 true_sel->set_index(true_count, result_idx);
12083 true_count += comparison_result;
12084 }
12085 if (HAS_FALSE_SEL) {
12086 false_sel->set_index(false_count, result_idx);
12087 false_count += !comparison_result;
12088 }
12089 }
12090 } else if (ValidityMask::NoneValid(validity_entry)) {
12091 // nothing valid: skip all
12092 if (HAS_FALSE_SEL) {
12093 for (; base_idx < next; base_idx++) {
12094 idx_t result_idx = sel->get_index(base_idx);
12095 false_sel->set_index(false_count, result_idx);
12096 false_count++;
12097 }
12098 }
12099 base_idx = next;
12100 continue;
12101 } else {
12102 // partially valid: need to check individual elements for validity
12103 idx_t start = base_idx;
12104 for (; base_idx < next; base_idx++) {
12105 idx_t result_idx = sel->get_index(base_idx);
12106 idx_t lidx = LEFT_CONSTANT ? 0 : base_idx;
12107 idx_t ridx = RIGHT_CONSTANT ? 0 : base_idx;
12108 bool comparison_result = ValidityMask::RowIsValid(validity_entry, base_idx - start) &&
12109 OP::Operation(ldata[lidx], rdata[ridx]);
12110 if (HAS_TRUE_SEL) {
12111 true_sel->set_index(true_count, result_idx);
12112 true_count += comparison_result;
12113 }
12114 if (HAS_FALSE_SEL) {
12115 false_sel->set_index(false_count, result_idx);
12116 false_count += !comparison_result;
12117 }
12118 }
12119 }
12120 }
12121 if (HAS_TRUE_SEL) {
12122 return true_count;
12123 } else {
12124 return count - false_count;
12125 }
12126 }

◆ SelectFlatLoopSwitch()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
static idx_t duckdb::BinaryExecutor::SelectFlatLoopSwitch ( const LEFT_TYPE *__restrict  ldata,
const RIGHT_TYPE *__restrict  rdata,
const SelectionVector *  sel,
idx_t  count,
ValidityMask &  mask,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12131 {
12132 if (true_sel && false_sel) {
12133 return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, true, true>(
12134 ldata, rdata, sel, count, mask, true_sel, false_sel);
12135 } else if (true_sel) {
12136 return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, true, false>(
12137 ldata, rdata, sel, count, mask, true_sel, false_sel);
12138 } else {
12139 D_ASSERT(false_sel);
12140 return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, false, true>(
12141 ldata, rdata, sel, count, mask, true_sel, false_sel);
12142 }
12143 }

◆ SelectFlat()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
static idx_t duckdb::BinaryExecutor::SelectFlat ( Vector &  left,
Vector &  right,
const SelectionVector *  sel,
idx_t  count,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12147 {
12148 auto ldata = FlatVector::GetData<LEFT_TYPE>(left);
12149 auto rdata = FlatVector::GetData<RIGHT_TYPE>(right);
12150
12151 if (LEFT_CONSTANT && ConstantVector::IsNull(left)) {
12152 if (false_sel) {
12153 for (idx_t i = 0; i < count; i++) {
12154 false_sel->set_index(i, sel->get_index(i));
12155 }
12156 }
12157 return 0;
12158 }
12159 if (RIGHT_CONSTANT && ConstantVector::IsNull(right)) {
12160 if (false_sel) {
12161 for (idx_t i = 0; i < count; i++) {
12162 false_sel->set_index(i, sel->get_index(i));
12163 }
12164 }
12165 return 0;
12166 }
12167
12168 if (LEFT_CONSTANT) {
12169 return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
12170 ldata, rdata, sel, count, FlatVector::Validity(right), true_sel, false_sel);
12171 } else if (RIGHT_CONSTANT) {
12172 return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
12173 ldata, rdata, sel, count, FlatVector::Validity(left), true_sel, false_sel);
12174 } else {
12175 ValidityMask combined_mask = FlatVector::Validity(left);
12176 combined_mask.Combine(FlatVector::Validity(right), count);
12177 return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
12178 ldata, rdata, sel, count, combined_mask, true_sel, false_sel);
12179 }
12180 }

◆ SelectGenericLoop()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
static idx_t duckdb::BinaryExecutor::SelectGenericLoop ( const LEFT_TYPE *__restrict  ldata,
const RIGHT_TYPE *__restrict  rdata,
const SelectionVector *__restrict  lsel,
const SelectionVector *__restrict  rsel,
const SelectionVector *__restrict  result_sel,
idx_t  count,
ValidityMask &  lvalidity,
ValidityMask &  rvalidity,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12192 {
12193 idx_t true_count = 0, false_count = 0;
12194#ifdef DUCKDB_SMALLER_BINARY
12195 const bool HAS_TRUE_SEL = true_sel;
12196 const bool HAS_FALSE_SEL = false_sel;
12197 const bool NO_NULL = false;
12198#endif
12199 for (idx_t i = 0; i < count; i++) {
12200 auto result_idx = result_sel->get_index(i);
12201 auto lindex = lsel->get_index(i);
12202 auto rindex = rsel->get_index(i);
12203 if ((NO_NULL || (lvalidity.RowIsValid(lindex) && rvalidity.RowIsValid(rindex))) &&
12204 OP::Operation(ldata[lindex], rdata[rindex])) {
12205 if (HAS_TRUE_SEL) {
12206 true_sel->set_index(true_count++, result_idx);
12207 }
12208 } else {
12209 if (HAS_FALSE_SEL) {
12210 false_sel->set_index(false_count++, result_idx);
12211 }
12212 }
12213 }
12214 if (HAS_TRUE_SEL) {
12215 return true_count;
12216 } else {
12217 return count - false_count;
12218 }
12219 }

◆ SelectGenericLoopSelSwitch()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP , bool NO_NULL>
static idx_t duckdb::BinaryExecutor::SelectGenericLoopSelSwitch ( const LEFT_TYPE *__restrict  ldata,
const RIGHT_TYPE *__restrict  rdata,
const SelectionVector *__restrict  lsel,
const SelectionVector *__restrict  rsel,
const SelectionVector *__restrict  result_sel,
idx_t  count,
ValidityMask &  lvalidity,
ValidityMask &  rvalidity,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12227 {
12228 if (true_sel && false_sel) {
12229 return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, true>(
12230 ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
12231 } else if (true_sel) {
12232 return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, false>(
12233 ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
12234 } else {
12235 D_ASSERT(false_sel);
12236 return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, false, true>(
12237 ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
12238 }
12239 }

◆ SelectGenericLoopSwitch()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP >
static idx_t duckdb::BinaryExecutor::SelectGenericLoopSwitch ( const LEFT_TYPE *__restrict  ldata,
const RIGHT_TYPE *__restrict  rdata,
const SelectionVector *__restrict  lsel,
const SelectionVector *__restrict  rsel,
const SelectionVector *__restrict  result_sel,
idx_t  count,
ValidityMask &  lvalidity,
ValidityMask &  rvalidity,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12247 {
12248#ifndef DUCKDB_SMALLER_BINARY
12249 if (!lvalidity.AllValid() || !rvalidity.AllValid()) {
12250 return SelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, false>(
12251 ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
12252 } else {
12253 return SelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, true>(
12254 ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
12255 }
12256#else
12257 return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP>(ldata, rdata, lsel, rsel, result_sel, count, lvalidity,
12258 rvalidity, true_sel, false_sel);
12259#endif
12260 }

◆ SelectGeneric()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP >
static idx_t duckdb::BinaryExecutor::SelectGeneric ( Vector &  left,
Vector &  right,
const SelectionVector *  sel,
idx_t  count,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12264 {
12265 UnifiedVectorFormat ldata, rdata;
12266
12267 left.ToUnifiedFormat(count, ldata);
12268 right.ToUnifiedFormat(count, rdata);
12269
12270 return SelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>(
12271 UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata), ldata.sel,
12272 rdata.sel, sel, count, ldata.validity, rdata.validity, true_sel, false_sel);
12273 }

◆ Select()

template<class LEFT_TYPE , class RIGHT_TYPE , class OP >
static idx_t duckdb::BinaryExecutor::Select ( Vector &  left,
Vector &  right,
const SelectionVector *  sel,
idx_t  count,
SelectionVector *  true_sel,
SelectionVector *  false_sel 
)
inlinestatic
12277 {
12278 if (!sel) {
12279 sel = FlatVector::IncrementalSelectionVector();
12280 }
12281 if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
12282 right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
12283 return SelectConstant<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
12284#ifndef DUCKDB_SMALLER_BINARY
12285 } else if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
12286 right.GetVectorType() == VectorType::FLAT_VECTOR) {
12287 return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, true, false>(left, right, sel, count, true_sel, false_sel);
12288 } else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
12289 right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
12290 return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, true>(left, right, sel, count, true_sel, false_sel);
12291 } else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
12292 right.GetVectorType() == VectorType::FLAT_VECTOR) {
12293 return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, false>(left, right, sel, count, true_sel, false_sel);
12294#endif
12295 } else {
12296 return SelectGeneric<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
12297 }
12298 }
The documentation for this struct was generated from the following file: