Unbreak comparison kernels - register them as returning YQL bool type, not ui8. Fix filter column handling in aggregations

5 files changed, 116 insertions, 98 deletions

diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg.cpp
index fdbe826fda..729d014c76 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg.cpp
@@ -1,5 +1,6 @@
 #include "mkql_block_agg.h"
 #include "mkql_block_agg_factory.h"
+#include "mkql_bit_utils.h"
 #include "mkql_rh_hash.h"
 
 #include <ydb/library/yql/minikql/computation/mkql_computation_node_impl.h>
@@ -299,6 +300,13 @@ private:
     const std::shared_ptr<arrow::DataType> DataType_;
 };
 
+size_t GetBitmapPopCount(const std::shared_ptr<arrow::ArrayData>& arr) {
+    size_t len = (size_t)arr->length;
+    MKQL_ENSURE(arr->GetNullCount() == 0, "Bitmap block should not have nulls");
+    const ui8* src = arr->GetValues<ui8>(1);
+    return GetSparseBitmapPopCount(src, len);
+}
+
 class TBlockCombineAllWrapper : public TStatefulWideFlowComputationNode<TBlockCombineAllWrapper> {
 public:
     TBlockCombineAllWrapper(TComputationMutables& mutables,
@@ -338,12 +346,11 @@ public:
                 if (FilterColumn_) {
                     auto filterDatum = TArrowBlock::From(s.Values_[*FilterColumn_]).GetDatum();
                     if (filterDatum.is_scalar()) {
-                        if (!filterDatum.scalar_as<arrow::BooleanScalar>().value) {
+                        if (!filterDatum.scalar_as<arrow::UInt8Scalar>().value) {
                             continue;
                         }
                     } else {
-                        arrow::BooleanArray arr(filterDatum.array());

-                        ui64 popCount = (ui64)arr.true_count();
+                        ui64 popCount = GetBitmapPopCount(filterDatum.array());
                         if (popCount == 0) {
                             continue;
                         }
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_count.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_count.cpp
index 5bf945f068..0224d23a5d 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_count.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_count.cpp
@@ -143,12 +143,12 @@ public:
                 const auto& filterArray = filterDatum.array();
                 MKQL_ENSURE(filterArray->GetNullCount() == 0, "Expected non-nullable bool column");
                 auto nullBitmapPtr = array->GetValues<uint8_t>(0, 0);
-                auto filterBitmap = filterArray->GetValues<uint8_t>(1, 0);
+                const ui8* filterBitmap = filterArray->GetValues<uint8_t>(1);
                 auto state = typedState->Count_;
                 for (ui32 i = 0; i < array->length; ++i) {
                     ui64 fullIndex = i + array->offset;
                     auto bit1 = ((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1);
-                    auto bit2 = ((filterBitmap[fullIndex >> 3] >> (fullIndex & 0x07)) & 1);
+                    auto bit2 = filterBitmap[i];
                     state += bit1 & bit2;
                 }
 
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_minmax.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_minmax.cpp
index 6849728fbd..e961aedaf1 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_minmax.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_minmax.cpp
@@ -108,7 +108,7 @@ public:
                     for (int64_t i = 0; i < len; ++i) {
                         ui64 fullIndex = i + array->offset;
                         // bit 1 -> mask 0xFF..FF, bit 0 -> mask 0x00..00
-                        TIn mask = (((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
+                        TIn mask = -TIn((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1);
                         value = UpdateMinMax<IsMin>(value, TIn((ptr[i] & mask) | (value & ~mask)));
                     }
                 }
@@ -124,7 +124,7 @@ public:
                 if (array->GetNullCount() == 0) {
                     typedState->IsValid_ = 1;
                     for (int64_t i = 0; i < len; ++i) {
-                        TIn filterMask = (((*filterBitmap++) & 1) ^ 1) - TIn(1);
+                        TIn filterMask = -TIn(filterBitmap[i]);
                         value = UpdateMinMax<IsMin>(value, TIn((ptr[i] & filterMask) | (value & ~filterMask)));
                     }
                 } else {
@@ -133,8 +133,8 @@ public:
                     for (int64_t i = 0; i < len; ++i) {
                         ui64 fullIndex = i + array->offset;
                         // bit 1 -> mask 0xFF..FF, bit 0 -> mask 0x00..00
-                        TIn mask = (((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
-                        TIn filterMask = (((*filterBitmap++) & 1) ^ 1) - TIn(1);
+                        TIn mask = -TIn((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1);
+                        TIn filterMask = -TIn(filterBitmap[i]);
                         mask &= filterMask;
                         value = UpdateMinMax<IsMin>(value, TIn((ptr[i] & mask) | (value & ~mask)));
                         count += mask & 1;
@@ -180,7 +180,7 @@ public:
                 auto nullBitmapPtr = array->GetValues<uint8_t>(0, 0);
                 ui64 fullIndex = row + array->offset;
                 // bit 1 -> mask 0xFF..FF, bit 0 -> mask 0x00..00
-                TIn mask = (((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
+                TIn mask = -TIn((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1);
                 typedState->Value_ = UpdateMinMax<IsMin>(typedState->Value_, TIn((ptr[row] & mask) | (typedState->Value_ & ~mask)));
                 typedState->IsValid_ |= mask & 1;
             }
@@ -273,8 +273,7 @@ public:
 
             TIn value = typedState->Value_;
             for (int64_t i = 0; i < len; ++i) {
-                ui64 fullIndex = i + array->offset;
-                TIn filterMask = (((*filterBitmap++) & 1) ^ 1) - TIn(1);
+                TIn filterMask = -TIn(filterBitmap[i]);
                 value = UpdateMinMax<IsMin>(value, TIn((ptr[i] & filterMask) | (value & ~filterMask)));
             }
 
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_sum.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_sum.cpp
index 74e2d884a3..5d1c162ffd 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_sum.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_sum.cpp
@@ -100,14 +100,13 @@ public:
                 const auto& filterDatum = TArrowBlock::From(columns[*FilterColumn_]).GetDatum();
                 const auto& filterArray = filterDatum.array();
                 MKQL_ENSURE(filterArray->GetNullCount() == 0, "Expected non-nullable bool column");
-                auto filterBitmap = filterArray->template GetValues<uint8_t>(1, 0);
+                const ui8* filterBitmap = filterArray->template GetValues<uint8_t>(1);
                 TSum sum = typedState->Sum_;
                 if (array->GetNullCount() == 0) {
                     typedState->IsValid_ = 1;
                     for (int64_t i = 0; i < len; ++i) {
-                        ui64 fullIndex = i + array->offset;
                         // bit 1 -> mask 0xFF..FF, bit 0 -> mask 0x00..00
-                        TIn filterMask = (((filterBitmap[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
+                        TIn filterMask = -TIn(filterBitmap[i]);
                         sum += ptr[i] & filterMask;
                     }
                 } else {
@@ -117,7 +116,7 @@ public:
                         ui64 fullIndex = i + array->offset;
                         // bit 1 -> mask 0xFF..FF, bit 0 -> mask 0x00..00
                         TIn mask = (((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
-                        TIn filterMask = (((filterBitmap[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
+                        TIn filterMask = -TIn(filterBitmap[i]);
                         mask &= filterMask;
                         sum += (ptr[i] & mask);
                         count += mask & 1;
@@ -243,11 +242,10 @@ public:
             const auto& filterDatum = TArrowBlock::From(columns[*FilterColumn_]).GetDatum();
             const auto& filterArray = filterDatum.array();
             MKQL_ENSURE(filterArray->GetNullCount() == 0, "Expected non-nullable bool column");
-            auto filterBitmap = filterArray->template GetValues<uint8_t>(1, 0);
+            const ui8* filterBitmap = filterArray->template GetValues<uint8_t>(1);
             for (int64_t i = 0; i < len; ++i) {
-                ui64 fullIndex = i + array->offset;
                 // bit 1 -> mask 0xFF..FF, bit 0 -> mask 0x00..00
-                TIn filterMask = (((filterBitmap[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
+                TIn filterMask = -TIn(filterBitmap[i]);
                 sum += ptr[i] & filterMask;
             }
         }
@@ -339,15 +337,14 @@ public:
                 const auto& filterDatum = TArrowBlock::From(columns[*FilterColumn_]).GetDatum();
                 const auto& filterArray = filterDatum.array();
                 MKQL_ENSURE(filterArray->GetNullCount() == 0, "Expected non-nullable bool column");
-                auto filterBitmap = filterArray->template GetValues<uint8_t>(1, 0);
+                const ui8* filterBitmap = filterArray->template GetValues<uint8_t>(1);
 
                 double sum = typedState->Sum_;
                 ui64 count = typedState->Count_;
                 if (array->GetNullCount() == 0) {
                     for (int64_t i = 0; i < len; ++i) {
-                        ui64 fullIndex = i + array->offset;
                         // bit 1 -> mask 0xFF..FF, bit 0 -> mask 0x00..00
-                        TIn filterMask = (((filterBitmap[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
+                        TIn filterMask = -TIn(filterBitmap[i]);
                         sum += double(ptr[i] & filterMask);
                         count += filterMask & 1;
                     }
@@ -356,8 +353,8 @@ public:
                     for (int64_t i = 0; i < len; ++i) {
                         ui64 fullIndex = i + array->offset;
                         // bit 1 -> mask 0xFF..FF, bit 0 -> mask 0x00..00
-                        TIn mask = (((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
-                        TIn filterMask = (((filterBitmap[fullIndex >> 3] >> (fullIndex & 0x07)) & 1) ^ 1) - TIn(1);
+                        TIn mask = -TIn((nullBitmapPtr[fullIndex >> 3] >> (fullIndex & 0x07)) & 1);
+                        TIn filterMask = -TIn(filterBitmap[i]);
                         mask &= filterMask;
                         sum += double(ptr[i] & mask);
                         count += mask & 1;
diff --git a/ydb/library/yql/minikql/invoke_builtins/mkql_builtins_impl.h b/ydb/library/yql/minikql/invoke_builtins/mkql_builtins_impl.h
index 61d91fd57f..bef5393b26 100644
--- a/ydb/library/yql/minikql/invoke_builtins/mkql_builtins_impl.h
+++ b/ydb/library/yql/minikql/invoke_builtins/mkql_builtins_impl.h
@@ -815,7 +815,7 @@ std::shared_ptr<arrow::DataType> GetPrimitiveDataType();
 
 template <>
 inline std::shared_ptr<arrow::DataType> GetPrimitiveDataType<bool>() {
-    return arrow::boolean();
+    return arrow::uint8();
 }
 
 template <>
@@ -878,7 +878,7 @@ arrow::Datum MakeScalarDatum(T value);
 
 template <>
 inline arrow::Datum MakeScalarDatum<bool>(bool value) {
-    return arrow::Datum(std::make_shared<arrow::BooleanScalar>(value));
+    return arrow::Datum(std::make_shared<arrow::UInt8Scalar>(value));
 }
 
 template <>
@@ -1191,6 +1191,22 @@ void AddBinaryKernel(TKernelFamilyBase& owner) {
     owner.KernelMap.emplace(argTypes, std::make_unique<TPlainKernel>(owner, argTypes, returnType, k));
 }
 
+template<typename TInput1, typename TInput2,
+    template<typename, typename, typename> class TFunc>
+void AddBinaryPredicateKernel(TKernelFamilyBase& owner) {
+    // ui8 type is used as bool replacement
+    using TOutput = ui8;
+    using TFuncInstance = TFunc<TInput1, TInput2, TOutput>;
+    using TExecs = TBinaryKernelExecs<TInput1, TInput2, TOutput, TFunc, TFuncInstance::DefaultNulls>;
+
+    std::vector<NUdf::TDataTypeId> argTypes({ NUdf::TDataType<TInput1>::Id, NUdf::TDataType<TInput2>::Id });
+    NUdf::TDataTypeId returnType = NUdf::TDataType<bool>::Id;
+
+    arrow::compute::ScalarKernel k({ GetPrimitiveInputArrowType<TInput1>(), GetPrimitiveInputArrowType<TInput2>() }, GetPrimitiveOutputArrowType<TOutput>(), &TExecs::Exec);
+    k.null_handling = owner.NullMode == TKernelFamily::ENullMode::Default ? arrow::compute::NullHandling::INTERSECTION : arrow::compute::NullHandling::COMPUTED_PREALLOCATE;
+    owner.KernelMap.emplace(argTypes, std::make_unique<TPlainKernel>(owner, argTypes, returnType, k));
+}
+
 template<template<typename, typename, typename> class TFunc>
 void AddBinaryIntegralKernels(TKernelFamilyBase& owner) {
     AddBinaryKernel<ui8, ui8, ui8, TFunc>(owner);
@@ -1278,78 +1294,77 @@ public:
 
 template<template<typename, typename, typename> class TPred>
 void AddBinaryIntegralPredicateKernels(TKernelFamilyBase& owner) {
-    using TResult = ui8;
-    AddBinaryKernel<ui8, ui8, TResult, TPred>(owner);
-    AddBinaryKernel<ui8, i8, TResult, TPred>(owner);
-    AddBinaryKernel<ui8, ui16, TResult, TPred>(owner);
-    AddBinaryKernel<ui8, i16, TResult, TPred>(owner);
-    AddBinaryKernel<ui8, ui32, TResult, TPred>(owner);
-    AddBinaryKernel<ui8, i32, TResult, TPred>(owner);
-    AddBinaryKernel<ui8, ui64, TResult, TPred>(owner);
-    AddBinaryKernel<ui8, i64, TResult, TPred>(owner);
-
-    AddBinaryKernel<i8, ui8, TResult, TPred>(owner);
-    AddBinaryKernel<i8, i8, TResult, TPred>(owner);
-    AddBinaryKernel<i8, ui16, TResult, TPred>(owner);
-    AddBinaryKernel<i8, i16, TResult, TPred>(owner);
-    AddBinaryKernel<i8, ui32, TResult, TPred>(owner);
-    AddBinaryKernel<i8, i32, TResult, TPred>(owner);
-    AddBinaryKernel<i8, ui64, TResult, TPred>(owner);
-    AddBinaryKernel<i8, i64, TResult, TPred>(owner);
-
-    AddBinaryKernel<ui16, ui8, TResult, TPred>(owner);
-    AddBinaryKernel<ui16, i8, TResult, TPred>(owner);
-    AddBinaryKernel<ui16, ui16, TResult, TPred>(owner);
-    AddBinaryKernel<ui16, i16, TResult, TPred>(owner);
-    AddBinaryKernel<ui16, ui32, TResult, TPred>(owner);
-    AddBinaryKernel<ui16, i32, TResult, TPred>(owner);
-    AddBinaryKernel<ui16, ui64, TResult, TPred>(owner);
-    AddBinaryKernel<ui16, i64, TResult, TPred>(owner);
-
-    AddBinaryKernel<i16, ui8, TResult, TPred>(owner);
-    AddBinaryKernel<i16, i8, TResult, TPred>(owner);
-    AddBinaryKernel<i16, ui16, TResult, TPred>(owner);
-    AddBinaryKernel<i16, i16, TResult, TPred>(owner);
-    AddBinaryKernel<i16, ui32, TResult, TPred>(owner);
-    AddBinaryKernel<i16, i32, TResult, TPred>(owner);
-    AddBinaryKernel<i16, ui64, TResult, TPred>(owner);
-    AddBinaryKernel<i16, i64, TResult, TPred>(owner);
-
-    AddBinaryKernel<ui32, ui8, TResult, TPred>(owner);
-    AddBinaryKernel<ui32, i8, TResult, TPred>(owner);
-    AddBinaryKernel<ui32, ui16, TResult, TPred>(owner);
-    AddBinaryKernel<ui32, i16, TResult, TPred>(owner);
-    AddBinaryKernel<ui32, ui32, TResult, TPred>(owner);
-    AddBinaryKernel<ui32, i32, TResult, TPred>(owner);
-    AddBinaryKernel<ui32, ui64, TResult, TPred>(owner);
-    AddBinaryKernel<ui32, i64, TResult, TPred>(owner);
-
-    AddBinaryKernel<i32, ui8, TResult, TPred>(owner);
-    AddBinaryKernel<i32, i8, TResult, TPred>(owner);
-    AddBinaryKernel<i32, ui16, TResult, TPred>(owner);
-    AddBinaryKernel<i32, i16, TResult, TPred>(owner);
-    AddBinaryKernel<i32, ui32, TResult, TPred>(owner);
-    AddBinaryKernel<i32, i32, TResult, TPred>(owner);
-    AddBinaryKernel<i32, ui64, TResult, TPred>(owner);
-    AddBinaryKernel<i32, i64, TResult, TPred>(owner);
-
-    AddBinaryKernel<ui64, ui8, TResult, TPred>(owner);
-    AddBinaryKernel<ui64, i8, TResult, TPred>(owner);
-    AddBinaryKernel<ui64, ui16, TResult, TPred>(owner);
-    AddBinaryKernel<ui64, i16, TResult, TPred>(owner);
-    AddBinaryKernel<ui64, ui32, TResult, TPred>(owner);
-    AddBinaryKernel<ui64, i32, TResult, TPred>(owner);
-    AddBinaryKernel<ui64, ui64, TResult, TPred>(owner);
-    AddBinaryKernel<ui64, i64, TResult, TPred>(owner);
-
-    AddBinaryKernel<i64, ui8, TResult, TPred>(owner);
-    AddBinaryKernel<i64, i8, TResult, TPred>(owner);
-    AddBinaryKernel<i64, ui16, TResult, TPred>(owner);
-    AddBinaryKernel<i64, i16, TResult, TPred>(owner);
-    AddBinaryKernel<i64, ui32, TResult, TPred>(owner);
-    AddBinaryKernel<i64, i32, TResult, TPred>(owner);
-    AddBinaryKernel<i64, ui64, TResult, TPred>(owner);
-    AddBinaryKernel<i64, i64, TResult, TPred>(owner);
+    AddBinaryPredicateKernel<ui8, ui8, TPred>(owner);
+    AddBinaryPredicateKernel<ui8, i8, TPred>(owner);
+    AddBinaryPredicateKernel<ui8, ui16, TPred>(owner);
+    AddBinaryPredicateKernel<ui8, i16, TPred>(owner);
+    AddBinaryPredicateKernel<ui8, ui32, TPred>(owner);
+    AddBinaryPredicateKernel<ui8, i32, TPred>(owner);
+    AddBinaryPredicateKernel<ui8, ui64, TPred>(owner);
+    AddBinaryPredicateKernel<ui8, i64, TPred>(owner);
+
+    AddBinaryPredicateKernel<i8, ui8, TPred>(owner);
+    AddBinaryPredicateKernel<i8, i8, TPred>(owner);
+    AddBinaryPredicateKernel<i8, ui16, TPred>(owner);
+    AddBinaryPredicateKernel<i8, i16, TPred>(owner);
+    AddBinaryPredicateKernel<i8, ui32, TPred>(owner);
+    AddBinaryPredicateKernel<i8, i32, TPred>(owner);
+    AddBinaryPredicateKernel<i8, ui64, TPred>(owner);
+    AddBinaryPredicateKernel<i8, i64, TPred>(owner);
+
+    AddBinaryPredicateKernel<ui16, ui8, TPred>(owner);
+    AddBinaryPredicateKernel<ui16, i8, TPred>(owner);
+    AddBinaryPredicateKernel<ui16, ui16, TPred>(owner);
+    AddBinaryPredicateKernel<ui16, i16, TPred>(owner);
+    AddBinaryPredicateKernel<ui16, ui32, TPred>(owner);
+    AddBinaryPredicateKernel<ui16, i32, TPred>(owner);
+    AddBinaryPredicateKernel<ui16, ui64, TPred>(owner);
+    AddBinaryPredicateKernel<ui16, i64, TPred>(owner);
+
+    AddBinaryPredicateKernel<i16, ui8, TPred>(owner);
+    AddBinaryPredicateKernel<i16, i8, TPred>(owner);
+    AddBinaryPredicateKernel<i16, ui16, TPred>(owner);
+    AddBinaryPredicateKernel<i16, i16, TPred>(owner);
+    AddBinaryPredicateKernel<i16, ui32, TPred>(owner);
+    AddBinaryPredicateKernel<i16, i32, TPred>(owner);
+    AddBinaryPredicateKernel<i16, ui64, TPred>(owner);
+    AddBinaryPredicateKernel<i16, i64, TPred>(owner);
+
+    AddBinaryPredicateKernel<ui32, ui8, TPred>(owner);
+    AddBinaryPredicateKernel<ui32, i8, TPred>(owner);
+    AddBinaryPredicateKernel<ui32, ui16, TPred>(owner);
+    AddBinaryPredicateKernel<ui32, i16, TPred>(owner);
+    AddBinaryPredicateKernel<ui32, ui32, TPred>(owner);
+    AddBinaryPredicateKernel<ui32, i32, TPred>(owner);
+    AddBinaryPredicateKernel<ui32, ui64, TPred>(owner);
+    AddBinaryPredicateKernel<ui32, i64, TPred>(owner);
+
+    AddBinaryPredicateKernel<i32, ui8, TPred>(owner);
+    AddBinaryPredicateKernel<i32, i8, TPred>(owner);
+    AddBinaryPredicateKernel<i32, ui16, TPred>(owner);
+    AddBinaryPredicateKernel<i32, i16, TPred>(owner);
+    AddBinaryPredicateKernel<i32, ui32, TPred>(owner);
+    AddBinaryPredicateKernel<i32, i32, TPred>(owner);
+    AddBinaryPredicateKernel<i32, ui64, TPred>(owner);
+    AddBinaryPredicateKernel<i32, i64, TPred>(owner);
+
+    AddBinaryPredicateKernel<ui64, ui8, TPred>(owner);
+    AddBinaryPredicateKernel<ui64, i8, TPred>(owner);
+    AddBinaryPredicateKernel<ui64, ui16, TPred>(owner);
+    AddBinaryPredicateKernel<ui64, i16, TPred>(owner);
+    AddBinaryPredicateKernel<ui64, ui32, TPred>(owner);
+    AddBinaryPredicateKernel<ui64, i32, TPred>(owner);
+    AddBinaryPredicateKernel<ui64, ui64, TPred>(owner);
+    AddBinaryPredicateKernel<ui64, i64, TPred>(owner);
+
+    AddBinaryPredicateKernel<i64, ui8, TPred>(owner);
+    AddBinaryPredicateKernel<i64, i8, TPred>(owner);
+    AddBinaryPredicateKernel<i64, ui16, TPred>(owner);
+    AddBinaryPredicateKernel<i64, i16, TPred>(owner);
+    AddBinaryPredicateKernel<i64, ui32, TPred>(owner);
+    AddBinaryPredicateKernel<i64, i32, TPred>(owner);
+    AddBinaryPredicateKernel<i64, ui64, TPred>(owner);
+    AddBinaryPredicateKernel<i64, i64, TPred>(owner);
 }
 
 template<template<typename, typename, typename> class TPred>