duckdb::TernaryExecutor Struct Reference

Static Public Member Functions
template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class OPWRAPPER , class FUN >
static void	ExecuteGeneric (Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun)
template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class FUN = std::function<RESULT_TYPE(A_TYPE, B_TYPE, C_TYPE)>>
static void	Execute (Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun)
template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class OP >
static void	ExecuteStandard (Vector &a, Vector &b, Vector &c, Vector &result, idx_t count)
template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class FUN = std::function<RESULT_TYPE(A_TYPE, B_TYPE, C_TYPE, ValidityMask &, idx_t)>>
static void	ExecuteWithNulls (Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun)
template<class A_TYPE , class B_TYPE , class C_TYPE , class OP >
static idx_t	Select (Vector &a, Vector &b, Vector &c, const SelectionVector *sel, idx_t count, SelectionVector *true_sel, SelectionVector *false_sel)

Static Private Member Functions
template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class OPWRAPPER , class FUN >
static void	ExecuteLoop (const A_TYPE *__restrict adata, const B_TYPE *__restrict bdata, const C_TYPE *__restrict cdata, RESULT_TYPE *__restrict result_data, idx_t count, const SelectionVector &asel, const SelectionVector &bsel, const SelectionVector &csel, ValidityMask &avalidity, ValidityMask &bvalidity, ValidityMask &cvalidity, ValidityMask &result_validity, FUN fun)
template<class A_TYPE , class B_TYPE , class C_TYPE , class OP , bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
static idx_t	SelectLoop (const A_TYPE *__restrict adata, const B_TYPE *__restrict bdata, const C_TYPE *__restrict cdata, const SelectionVector *result_sel, idx_t count, const SelectionVector &asel, const SelectionVector &bsel, const SelectionVector &csel, ValidityMask &avalidity, ValidityMask &bvalidity, ValidityMask &cvalidity, SelectionVector *true_sel, SelectionVector *false_sel)
template<class A_TYPE , class B_TYPE , class C_TYPE , class OP , bool NO_NULL>
static idx_t	SelectLoopSelSwitch (UnifiedVectorFormat &adata, UnifiedVectorFormat &bdata, UnifiedVectorFormat &cdata, const SelectionVector *sel, idx_t count, SelectionVector *true_sel, SelectionVector *false_sel)
template<class A_TYPE , class B_TYPE , class C_TYPE , class OP >
static idx_t	SelectLoopSwitch (UnifiedVectorFormat &adata, UnifiedVectorFormat &bdata, UnifiedVectorFormat &cdata, const SelectionVector *sel, idx_t count, SelectionVector *true_sel, SelectionVector *false_sel)

Member Function Documentation

ExecuteLoop()

template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class OPWRAPPER , class FUN >

static void duckdb::TernaryExecutor::ExecuteLoop ( const A_TYPE *__restrict  adata, const B_TYPE *__restrict  bdata, const C_TYPE *__restrict  cdata, RESULT_TYPE *__restrict  result_data, idx_t  count, const SelectionVector &  asel, const SelectionVector &  bsel, const SelectionVector &  csel, ValidityMask &  avalidity, ValidityMask &  bvalidity, ValidityMask &  cvalidity, ValidityMask &  result_validity, FUN  fun  )

inlinestaticprivate

                                                                                                    {
        if (!avalidity.AllValid() || !bvalidity.AllValid() || !cvalidity.AllValid()) {
            for (idx_t i = 0; i < count; i++) {
                auto aidx = asel.get_index(i);
                auto bidx = bsel.get_index(i);
                auto cidx = csel.get_index(i);
                if (avalidity.RowIsValid(aidx) && bvalidity.RowIsValid(bidx) && cvalidity.RowIsValid(cidx)) {
                    result_data[i] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
                        fun, adata[aidx], bdata[bidx], cdata[cidx], result_validity, i);
                } else {
                    result_validity.SetInvalid(i);
                }
            }
        } else {
            for (idx_t i = 0; i < count; i++) {
                auto aidx = asel.get_index(i);
                auto bidx = bsel.get_index(i);
                auto cidx = csel.get_index(i);
                result_data[i] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
                    fun, adata[aidx], bdata[bidx], cdata[cidx], result_validity, i);
            }
        }
    }

ExecuteGeneric()

template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class OPWRAPPER , class FUN >

static void duckdb::TernaryExecutor::ExecuteGeneric ( Vector &  a, Vector &  b, Vector &  c, Vector &  result, idx_t  count, FUN  fun  )

inlinestatic

                                                                                                      {
        if (a.GetVectorType() == VectorType::CONSTANT_VECTOR && b.GetVectorType() == VectorType::CONSTANT_VECTOR &&
            c.GetVectorType() == VectorType::CONSTANT_VECTOR) {
            result.SetVectorType(VectorType::CONSTANT_VECTOR);
            if (ConstantVector::IsNull(a) || ConstantVector::IsNull(b) || ConstantVector::IsNull(c)) {
                ConstantVector::SetNull(result, true);
            } else {
                auto adata = ConstantVector::GetData<A_TYPE>(a);
                auto bdata = ConstantVector::GetData<B_TYPE>(b);
                auto cdata = ConstantVector::GetData<C_TYPE>(c);
                auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
                auto &result_validity = ConstantVector::Validity(result);
                result_data[0] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
                    fun, adata[0], bdata[0], cdata[0], result_validity, 0);
            }
        } else {
            result.SetVectorType(VectorType::FLAT_VECTOR);
 
            UnifiedVectorFormat adata, bdata, cdata;
            a.ToUnifiedFormat(count, adata);
            b.ToUnifiedFormat(count, bdata);
            c.ToUnifiedFormat(count, cdata);
 
            ExecuteLoop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OPWRAPPER>(
                UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
                UnifiedVectorFormat::GetData<C_TYPE>(cdata), FlatVector::GetData<RESULT_TYPE>(result), count,
                *adata.sel, *bdata.sel, *cdata.sel, adata.validity, bdata.validity, cdata.validity,
                FlatVector::Validity(result), fun);
        }
    }

Execute()

template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class FUN = std::function<RESULT_TYPE(A_TYPE, B_TYPE, C_TYPE)>>

static void duckdb::TernaryExecutor::Execute ( Vector &  a, Vector &  b, Vector &  c, Vector &  result, idx_t  count, FUN  fun  )

inlinestatic

                                                                                               {
        ExecuteGeneric<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, TernaryLambdaWrapper, FUN>(a, b, c, result, count, fun);
    }

ExecuteStandard()

template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class OP >

static void duckdb::TernaryExecutor::ExecuteStandard ( Vector &  a, Vector &  b, Vector &  c, Vector &  result, idx_t  count  )

inlinestatic

                                                                                              {
        ExecuteGeneric<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, TernaryStandardOperatorWrapper<OP>, bool>(a, b, c, result,
                                                                                                      count, false);
    }

ExecuteWithNulls()

template<class A_TYPE , class B_TYPE , class C_TYPE , class RESULT_TYPE , class FUN = std::function<RESULT_TYPE(A_TYPE, B_TYPE, C_TYPE, ValidityMask &, idx_t)>>

static void duckdb::TernaryExecutor::ExecuteWithNulls ( Vector &  a, Vector &  b, Vector &  c, Vector &  result, idx_t  count, FUN  fun  )

inlinestatic

                                                                                                        {
        ExecuteGeneric<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, TernaryLambdaWrapperWithNulls, FUN>(a, b, c, result, count,
                                                                                                fun);
    }

SelectLoop()

template<class A_TYPE , class B_TYPE , class C_TYPE , class OP , bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>

static idx_t duckdb::TernaryExecutor::SelectLoop ( const A_TYPE *__restrict  adata, const B_TYPE *__restrict  bdata, const C_TYPE *__restrict  cdata, const SelectionVector *  result_sel, idx_t  count, const SelectionVector &  asel, const SelectionVector &  bsel, const SelectionVector &  csel, ValidityMask &  avalidity, ValidityMask &  bvalidity, ValidityMask &  cvalidity, SelectionVector *  true_sel, SelectionVector *  false_sel  )

inlinestaticprivate

                                                                                                                   {
        idx_t true_count = 0, false_count = 0;
        for (idx_t i = 0; i < count; i++) {
            auto result_idx = result_sel->get_index(i);
            auto aidx = asel.get_index(i);
            auto bidx = bsel.get_index(i);
            auto cidx = csel.get_index(i);
            bool comparison_result =
                (NO_NULL || (avalidity.RowIsValid(aidx) && bvalidity.RowIsValid(bidx) && cvalidity.RowIsValid(cidx))) &&
                OP::Operation(adata[aidx], bdata[bidx], cdata[cidx]);
            if (HAS_TRUE_SEL) {
                true_sel->set_index(true_count, result_idx);
                true_count += comparison_result;
            }
            if (HAS_FALSE_SEL) {
                false_sel->set_index(false_count, result_idx);
                false_count += !comparison_result;
            }
        }
        if (HAS_TRUE_SEL) {
            return true_count;
        } else {
            return count - false_count;
        }
    }

SelectLoopSelSwitch()

template<class A_TYPE , class B_TYPE , class C_TYPE , class OP , bool NO_NULL>

static idx_t duckdb::TernaryExecutor::SelectLoopSelSwitch ( UnifiedVectorFormat &  adata, UnifiedVectorFormat &  bdata, UnifiedVectorFormat &  cdata, const SelectionVector *  sel, idx_t  count, SelectionVector *  true_sel, SelectionVector *  false_sel  )

inlinestaticprivate

                                                                                                   {
        if (true_sel && false_sel) {
            return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, true, true>(
                UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
                UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
                adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
        } else if (true_sel) {
            return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, true, false>(
                UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
                UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
                adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
        } else {
            D_ASSERT(false_sel);
            return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, false, true>(
                UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
                UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
                adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
        }
    }

SelectLoopSwitch()

template<class A_TYPE , class B_TYPE , class C_TYPE , class OP >

static idx_t duckdb::TernaryExecutor::SelectLoopSwitch ( UnifiedVectorFormat &  adata, UnifiedVectorFormat &  bdata, UnifiedVectorFormat &  cdata, const SelectionVector *  sel, idx_t  count, SelectionVector *  true_sel, SelectionVector *  false_sel  )

inlinestaticprivate

                                                                                                {
        if (!adata.validity.AllValid() || !bdata.validity.AllValid() || !cdata.validity.AllValid()) {
            return SelectLoopSelSwitch<A_TYPE, B_TYPE, C_TYPE, OP, false>(adata, bdata, cdata, sel, count, true_sel,
                                                                          false_sel);
        } else {
            return SelectLoopSelSwitch<A_TYPE, B_TYPE, C_TYPE, OP, true>(adata, bdata, cdata, sel, count, true_sel,
                                                                         false_sel);
        }
    }

Select()

template<class A_TYPE , class B_TYPE , class C_TYPE , class OP >

static idx_t duckdb::TernaryExecutor::Select ( Vector &  a, Vector &  b, Vector &  c, const SelectionVector *  sel, idx_t  count, SelectionVector *  true_sel, SelectionVector *  false_sel  )

inlinestatic

                                                                               {
        if (!sel) {
            sel = FlatVector::IncrementalSelectionVector();
        }
        UnifiedVectorFormat adata, bdata, cdata;
        a.ToUnifiedFormat(count, adata);
        b.ToUnifiedFormat(count, bdata);
        c.ToUnifiedFormat(count, cdata);
 
        return SelectLoopSwitch<A_TYPE, B_TYPE, C_TYPE, OP>(adata, bdata, cdata, sel, count, true_sel, false_sel);
    }

---

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

• external/duckdb/duckdb.hpp