Kùzu C++ API
Loading...
Searching...
No Matches
binary_function_executor.h
Go to the documentation of this file.
1#pragma once
2
3#include "value_vector.h"
4
5namespace kuzu {
6namespace function {
7
14 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename OP>
15 static inline void operation(LEFT_TYPE& left, RIGHT_TYPE& right, RESULT_TYPE& result,
16 common::ValueVector* /*leftValueVector*/, common::ValueVector* /*rightValueVector*/,
17 common::ValueVector* /*resultValueVector*/, uint64_t /*resultPos*/, void* /*dataPtr*/) {
18 OP::operation(left, right, result);
19 }
20};
21
23 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename OP>
24 static void operation(LEFT_TYPE& left, RIGHT_TYPE& right, RESULT_TYPE& result,
25 common::ValueVector* leftValueVector, common::ValueVector* rightValueVector,
26 common::ValueVector* resultValueVector, uint64_t /*resultPos*/, void* /*dataPtr*/) {
27 OP::operation(left, right, result, *leftValueVector, *rightValueVector, *resultValueVector);
28 }
29};
30
32 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename OP>
33 static void operation(LEFT_TYPE& left, RIGHT_TYPE& right, RESULT_TYPE& result,
34 common::ValueVector* leftValueVector, common::ValueVector* rightValueVector,
35 common::ValueVector* resultValueVector, uint64_t /*resultPos*/, void* dataPtr) {
36 OP::operation(left, right, result, *leftValueVector, *rightValueVector, *resultValueVector,
37 dataPtr);
38 }
39};
40
42 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename OP>
43 static inline void operation(LEFT_TYPE& left, RIGHT_TYPE& right, RESULT_TYPE& result,
44 common::ValueVector* leftValueVector, common::ValueVector* rightValueVector,
45 common::ValueVector* resultValueVector, uint64_t resultPos, void* /*dataPtr*/) {
46 OP::operation(left, right, result, *leftValueVector, *rightValueVector, *resultValueVector,
47 resultPos);
48 }
49};
50
52 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename OP>
53 static inline void operation(LEFT_TYPE& left, RIGHT_TYPE& right, RESULT_TYPE& result,
54 common::ValueVector* /*leftValueVector*/, common::ValueVector* /*rightValueVector*/,
55 common::ValueVector* resultValueVector, uint64_t /*resultPos*/, void* /*dataPtr*/) {
56 OP::operation(left, right, result, *resultValueVector);
57 }
58};
59
61 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename OP>
62 static inline void operation(LEFT_TYPE& left, RIGHT_TYPE& right, RESULT_TYPE& result,
63 common::ValueVector* leftValueVector, common::ValueVector* rightValueVector,
64 common::ValueVector* /*resultValueVector*/, uint64_t /*resultPos*/, void* /*dataPtr*/) {
65 OP::operation(left, right, result, leftValueVector, rightValueVector);
66 }
67};
68
70 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename OP>
71 static inline void operation(LEFT_TYPE& left, RIGHT_TYPE& right, RESULT_TYPE& result,
72 common::ValueVector* /*leftValueVector*/, common::ValueVector* /*rightValueVector*/,
73 common::ValueVector* /*resultValueVector*/, uint64_t /*resultPos*/, void* dataPtr) {
74 OP::operation(left, right, result, dataPtr);
75 }
76};
77
79 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC,
80 typename OP_WRAPPER>
81 static inline void executeOnValue(common::ValueVector& left, common::ValueVector& right,
82 common::ValueVector& resultValueVector, uint64_t lPos, uint64_t rPos, uint64_t resPos,
83 void* dataPtr) {
84 OP_WRAPPER::template operation<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, FUNC>(
85 ((LEFT_TYPE*)left.getData())[lPos], ((RIGHT_TYPE*)right.getData())[rPos],
86 ((RESULT_TYPE*)resultValueVector.getData())[resPos], &left, &right, &resultValueVector,
87 resPos, dataPtr);
88 }
89
90 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC,
91 typename OP_WRAPPER>
93 common::ValueVector& result, void* dataPtr) {
94 auto lPos = left.state->getSelVector()[0];
95 auto rPos = right.state->getSelVector()[0];
96 auto resPos = result.state->getSelVector()[0];
97 result.setNull(resPos, left.isNull(lPos) || right.isNull(rPos));
98 if (!result.isNull(resPos)) {
100 result, lPos, rPos, resPos, dataPtr);
101 }
102 }
103
104 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC,
105 typename OP_WRAPPER>
107 common::ValueVector& result, void* dataPtr) {
108 auto lPos = left.state->getSelVector()[0];
109 auto& rightSelVector = right.state->getSelVector();
110 if (left.isNull(lPos)) {
111 result.setAllNull();
112 } else if (right.hasNoNullsGuarantee()) {
113 if (rightSelVector.isUnfiltered()) {
114 for (auto i = 0u; i < rightSelVector.getSelSize(); ++i) {
116 right, result, lPos, i, i, dataPtr);
117 }
118 } else {
119 for (auto i = 0u; i < rightSelVector.getSelSize(); ++i) {
120 auto rPos = rightSelVector[i];
122 right, result, lPos, rPos, rPos, dataPtr);
123 }
124 }
125 } else {
126 if (rightSelVector.isUnfiltered()) {
127 for (auto i = 0u; i < rightSelVector.getSelSize(); ++i) {
128 result.setNull(i, right.isNull(i)); // left is always not null
129 if (!result.isNull(i)) {
131 right, result, lPos, i, i, dataPtr);
132 }
133 }
134 } else {
135 for (auto i = 0u; i < rightSelVector.getSelSize(); ++i) {
136 auto rPos = rightSelVector[i];
137 result.setNull(rPos, right.isNull(rPos)); // left is always not null
138 if (!result.isNull(rPos)) {
140 right, result, lPos, rPos, rPos, dataPtr);
141 }
142 }
143 }
144 }
145 }
146
147 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC,
148 typename OP_WRAPPER>
150 common::ValueVector& result, void* dataPtr) {
151 auto rPos = right.state->getSelVector()[0];
152 auto& leftSelVector = left.state->getSelVector();
153 if (right.isNull(rPos)) {
154 result.setAllNull();
155 } else if (left.hasNoNullsGuarantee()) {
156 if (leftSelVector.isUnfiltered()) {
157 for (auto i = 0u; i < leftSelVector.getSelSize(); ++i) {
159 right, result, i, rPos, i, dataPtr);
160 }
161 } else {
162 for (auto i = 0u; i < leftSelVector.getSelSize(); ++i) {
163 auto lPos = leftSelVector[i];
165 right, result, lPos, rPos, lPos, dataPtr);
166 }
167 }
168 } else {
169 if (leftSelVector.isUnfiltered()) {
170 for (auto i = 0u; i < leftSelVector.getSelSize(); ++i) {
171 result.setNull(i, left.isNull(i)); // right is always not null
172 if (!result.isNull(i)) {
174 right, result, i, rPos, i, dataPtr);
175 }
176 }
177 } else {
178 for (auto i = 0u; i < leftSelVector.getSelSize(); ++i) {
179 auto lPos = leftSelVector[i];
180 result.setNull(lPos, left.isNull(lPos)); // right is always not null
181 if (!result.isNull(lPos)) {
183 right, result, lPos, rPos, lPos, dataPtr);
184 }
185 }
186 }
187 }
188 }
189
190 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC,
191 typename OP_WRAPPER>
193 common::ValueVector& result, void* dataPtr) {
194 KU_ASSERT(left.state == right.state);
195 auto& resultSelVector = result.state->getSelVector();
196 if (left.hasNoNullsGuarantee() && right.hasNoNullsGuarantee()) {
197 if (resultSelVector.isUnfiltered()) {
198 for (uint64_t i = 0; i < resultSelVector.getSelSize(); i++) {
200 right, result, i, i, i, dataPtr);
201 }
202 } else {
203 for (uint64_t i = 0; i < resultSelVector.getSelSize(); i++) {
204 auto pos = resultSelVector[i];
206 right, result, pos, pos, pos, dataPtr);
207 }
208 }
209 } else {
210 if (resultSelVector.isUnfiltered()) {
211 for (uint64_t i = 0; i < resultSelVector.getSelSize(); i++) {
212 result.setNull(i, left.isNull(i) || right.isNull(i));
213 if (!result.isNull(i)) {
215 right, result, i, i, i, dataPtr);
216 }
217 }
218 } else {
219 for (uint64_t i = 0; i < resultSelVector.getSelSize(); i++) {
220 auto pos = resultSelVector[i];
221 result.setNull(pos, left.isNull(pos) || right.isNull(pos));
222 if (!result.isNull(pos)) {
224 right, result, pos, pos, pos, dataPtr);
225 }
226 }
227 }
228 }
229 }
230
231 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC,
232 typename OP_WRAPPER>
234 common::ValueVector& result, void* dataPtr) {
235 result.resetAuxiliaryBuffer();
236 if (left.state->isFlat() && right.state->isFlat()) {
238 result, dataPtr);
239 } else if (left.state->isFlat() && !right.state->isFlat()) {
241 result, dataPtr);
242 } else if (!left.state->isFlat() && right.state->isFlat()) {
244 result, dataPtr);
245 } else if (!left.state->isFlat() && !right.state->isFlat()) {
247 result, dataPtr);
248 } else {
249 KU_ASSERT(false);
250 }
251 }
252
253 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
255 common::ValueVector& result) {
257 result, nullptr /* dataPtr */);
258 }
259
260 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
262 common::ValueVector& result) {
264 right, result, nullptr /* dataPtr */);
265 }
266
267 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
273
274 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
280
281 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
287
288 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
294
295 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
297 common::ValueVector& result, void* dataPtr) {
299 right, result, dataPtr);
300 }
301
303 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename OP>
304 static inline void operation(LEFT_TYPE& left, RIGHT_TYPE& right, uint8_t& result,
305 common::ValueVector* /*leftValueVector*/, common::ValueVector* /*rightValueVector*/) {
306 OP::operation(left, right, result);
307 }
308 };
309
311 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename OP>
312 static inline void operation(LEFT_TYPE& left, RIGHT_TYPE& right, uint8_t& result,
313 common::ValueVector* leftValueVector, common::ValueVector* rightValueVector) {
314 OP::operation(left, right, result, leftValueVector, rightValueVector);
315 }
316 };
317
318 template<class LEFT_TYPE, class RIGHT_TYPE, class FUNC, typename SELECT_WRAPPER>
319 static void selectOnValue(common::ValueVector& left, common::ValueVector& right, uint64_t lPos,
320 uint64_t rPos, uint64_t resPos, uint64_t& numSelectedValues,
321 std::span<common::sel_t> selectedPositionsBuffer) {
322 uint8_t resultValue = 0;
323 SELECT_WRAPPER::template operation<LEFT_TYPE, RIGHT_TYPE, FUNC>(
324 ((LEFT_TYPE*)left.getData())[lPos], ((RIGHT_TYPE*)right.getData())[rPos], resultValue,
325 &left, &right);
326 selectedPositionsBuffer[numSelectedValues] = resPos;
327 numSelectedValues += (resultValue == true);
328 }
329
330 template<class LEFT_TYPE, class RIGHT_TYPE, class FUNC, typename SELECT_WRAPPER>
332 auto lPos = left.state->getSelVector()[0];
333 auto rPos = right.state->getSelVector()[0];
334 uint8_t resultValue = 0;
335 if (!left.isNull(lPos) && !right.isNull(rPos)) {
336 SELECT_WRAPPER::template operation<LEFT_TYPE, RIGHT_TYPE, FUNC>(
337 ((LEFT_TYPE*)left.getData())[lPos], ((RIGHT_TYPE*)right.getData())[rPos],
338 resultValue, &left, &right);
339 }
340 return resultValue == true;
341 }
342
343 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename FUNC, typename SELECT_WRAPPER>
345 common::SelectionVector& selVector) {
346 auto lPos = left.state->getSelVector()[0];
347 uint64_t numSelectedValues = 0;
348 auto selectedPositionsBuffer = selVector.getMultableBuffer();
349 auto& rightSelVector = right.state->getSelVector();
350 if (left.isNull(lPos)) {
351 return numSelectedValues;
352 } else if (right.hasNoNullsGuarantee()) {
353 if (rightSelVector.isUnfiltered()) {
354 for (auto i = 0u; i < rightSelVector.getSelSize(); ++i) {
356 i, numSelectedValues, selectedPositionsBuffer);
357 }
358 } else {
359 for (auto i = 0u; i < rightSelVector.getSelSize(); ++i) {
360 auto rPos = rightSelVector[i];
362 rPos, rPos, numSelectedValues, selectedPositionsBuffer);
363 }
364 }
365 } else {
366 if (rightSelVector.isUnfiltered()) {
367 for (auto i = 0u; i < rightSelVector.getSelSize(); ++i) {
368 if (!right.isNull(i)) {
370 lPos, i, i, numSelectedValues, selectedPositionsBuffer);
371 }
372 }
373 } else {
374 for (auto i = 0u; i < rightSelVector.getSelSize(); ++i) {
375 auto rPos = rightSelVector[i];
376 if (!right.isNull(rPos)) {
378 lPos, rPos, rPos, numSelectedValues, selectedPositionsBuffer);
379 }
380 }
381 }
382 }
383 selVector.setSelSize(numSelectedValues);
384 return numSelectedValues > 0;
385 }
386
387 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename FUNC, typename SELECT_WRAPPER>
389 common::SelectionVector& selVector) {
390 auto rPos = right.state->getSelVector()[0];
391 uint64_t numSelectedValues = 0;
392 auto selectedPositionsBuffer = selVector.getMultableBuffer();
393 auto& leftSelVector = left.state->getSelVector();
394 if (right.isNull(rPos)) {
395 return numSelectedValues;
396 } else if (left.hasNoNullsGuarantee()) {
397 if (leftSelVector.isUnfiltered()) {
398 for (auto i = 0u; i < leftSelVector.getSelSize(); ++i) {
400 i, numSelectedValues, selectedPositionsBuffer);
401 }
402 } else {
403 for (auto i = 0u; i < leftSelVector.getSelSize(); ++i) {
404 auto lPos = leftSelVector[i];
406 rPos, lPos, numSelectedValues, selectedPositionsBuffer);
407 }
408 }
409 } else {
410 if (leftSelVector.isUnfiltered()) {
411 for (auto i = 0u; i < leftSelVector.getSelSize(); ++i) {
412 if (!left.isNull(i)) {
414 rPos, i, numSelectedValues, selectedPositionsBuffer);
415 }
416 }
417 } else {
418 for (auto i = 0u; i < leftSelVector.getSelSize(); ++i) {
419 auto lPos = leftSelVector[i];
420 if (!left.isNull(lPos)) {
422 lPos, rPos, lPos, numSelectedValues, selectedPositionsBuffer);
423 }
424 }
425 }
426 }
427 selVector.setSelSize(numSelectedValues);
428 return numSelectedValues > 0;
429 }
430
431 // Right, left, and result vectors share the same selectedPositions.
432 template<class LEFT_TYPE, class RIGHT_TYPE, class FUNC, typename SELECT_WRAPPER>
434 common::SelectionVector& selVector) {
435 uint64_t numSelectedValues = 0;
436 auto selectedPositionsBuffer = selVector.getMultableBuffer();
437 auto& leftSelVector = left.state->getSelVector();
438 if (left.hasNoNullsGuarantee() && right.hasNoNullsGuarantee()) {
439 if (leftSelVector.isUnfiltered()) {
440 for (auto i = 0u; i < leftSelVector.getSelSize(); i++) {
442 numSelectedValues, selectedPositionsBuffer);
443 }
444 } else {
445 for (auto i = 0u; i < leftSelVector.getSelSize(); i++) {
446 auto pos = leftSelVector[i];
448 pos, pos, numSelectedValues, selectedPositionsBuffer);
449 }
450 }
451 } else {
452 if (leftSelVector.isUnfiltered()) {
453 for (uint64_t i = 0; i < leftSelVector.getSelSize(); i++) {
454 auto isNull = left.isNull(i) || right.isNull(i);
455 if (!isNull) {
457 i, i, numSelectedValues, selectedPositionsBuffer);
458 }
459 }
460 } else {
461 for (uint64_t i = 0; i < leftSelVector.getSelSize(); i++) {
462 auto pos = leftSelVector[i];
463 auto isNull = left.isNull(pos) || right.isNull(pos);
464 if (!isNull) {
466 pos, pos, numSelectedValues, selectedPositionsBuffer);
467 }
468 }
469 }
470 }
471 selVector.setSelSize(numSelectedValues);
472 return numSelectedValues > 0;
473 }
474
475 // BOOLEAN (AND, OR, XOR)
476 template<class LEFT_TYPE, class RIGHT_TYPE, class FUNC>
478 common::SelectionVector& selVector) {
479 if (left.state->isFlat() && right.state->isFlat()) {
481 } else if (left.state->isFlat() && !right.state->isFlat()) {
483 selVector);
484 } else if (!left.state->isFlat() && right.state->isFlat()) {
486 selVector);
487 } else {
489 selVector);
490 }
491 }
492
493 // COMPARISON (GT, GTE, LT, LTE, EQ, NEQ)
494 template<class LEFT_TYPE, class RIGHT_TYPE, class FUNC>
496 common::SelectionVector& selVector) {
497 if (left.state->isFlat() && right.state->isFlat()) {
499 right);
500 } else if (left.state->isFlat() && !right.state->isFlat()) {
502 left, right, selVector);
503 } else if (!left.state->isFlat() && right.state->isFlat()) {
505 left, right, selVector);
506 } else {
508 left, right, selVector);
509 }
510 }
511};
512
513} // namespace function
514} // namespace kuzu
#define KU_ASSERT(condition)
Definition assert.h:19
Definition sel_vector.h:12
void setSelSize(sel_t size)
Definition sel_vector.h:48
std::span< sel_t > getMultableBuffer()
Definition sel_vector.h:40
Definition value_vector.h:20
uint8_t * getData() const
Definition value_vector.h:82
uint8_t isNull(uint32_t pos) const
Definition value_vector.h:47
bool hasNoNullsGuarantee() const
Definition value_vector.h:41
void setAllNull()
Definition value_vector.h:38
void setNull(uint32_t pos, bool isNull)
std::shared_ptr< DataChunkState > state
Definition value_vector.h:105
Definition alter_type.h:5
Definition binary_function_executor.h:60
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, RESULT_TYPE &result, common::ValueVector *leftValueVector, common::ValueVector *rightValueVector, common::ValueVector *, uint64_t, void *)
Definition binary_function_executor.h:62
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, uint8_t &result, common::ValueVector *leftValueVector, common::ValueVector *rightValueVector)
Definition binary_function_executor.h:312
Definition binary_function_executor.h:302
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, uint8_t &result, common::ValueVector *, common::ValueVector *)
Definition binary_function_executor.h:304
Definition binary_function_executor.h:78
static void executeListStruct(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result)
Definition binary_function_executor.h:268
static void executeUDF(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result, void *dataPtr)
Definition binary_function_executor.h:296
static void executeComparison(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result)
Definition binary_function_executor.h:289
static void executeOnValue(common::ValueVector &left, common::ValueVector &right, common::ValueVector &resultValueVector, uint64_t lPos, uint64_t rPos, uint64_t resPos, void *dataPtr)
Definition binary_function_executor.h:81
static void executeBothUnFlat(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result, void *dataPtr)
Definition binary_function_executor.h:192
static bool select(common::ValueVector &left, common::ValueVector &right, common::SelectionVector &selVector)
Definition binary_function_executor.h:477
static void executeFlatUnFlat(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result, void *dataPtr)
Definition binary_function_executor.h:106
static void selectOnValue(common::ValueVector &left, common::ValueVector &right, uint64_t lPos, uint64_t rPos, uint64_t resPos, uint64_t &numSelectedValues, std::span< common::sel_t > selectedPositionsBuffer)
Definition binary_function_executor.h:319
static void executeListExtract(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result)
Definition binary_function_executor.h:282
static bool selectComparison(common::ValueVector &left, common::ValueVector &right, common::SelectionVector &selVector)
Definition binary_function_executor.h:495
static void executeSwitch(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result, void *dataPtr)
Definition binary_function_executor.h:233
static uint64_t selectBothFlat(common::ValueVector &left, common::ValueVector &right)
Definition binary_function_executor.h:331
static void execute(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result)
Definition binary_function_executor.h:254
static void executeBothFlat(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result, void *dataPtr)
Definition binary_function_executor.h:92
static bool selectBothUnFlat(common::ValueVector &left, common::ValueVector &right, common::SelectionVector &selVector)
Definition binary_function_executor.h:433
static bool selectFlatUnFlat(common::ValueVector &left, common::ValueVector &right, common::SelectionVector &selVector)
Definition binary_function_executor.h:344
static void executeUnFlatFlat(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result, void *dataPtr)
Definition binary_function_executor.h:149
static bool selectUnFlatFlat(common::ValueVector &left, common::ValueVector &right, common::SelectionVector &selVector)
Definition binary_function_executor.h:388
static void executeMapCreation(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result, void *dataPtr)
Definition binary_function_executor.h:275
static void executeString(common::ValueVector &left, common::ValueVector &right, common::ValueVector &result)
Definition binary_function_executor.h:261
Definition binary_function_executor.h:13
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, RESULT_TYPE &result, common::ValueVector *, common::ValueVector *, common::ValueVector *, uint64_t, void *)
Definition binary_function_executor.h:15
Definition binary_function_executor.h:41
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, RESULT_TYPE &result, common::ValueVector *leftValueVector, common::ValueVector *rightValueVector, common::ValueVector *resultValueVector, uint64_t resultPos, void *)
Definition binary_function_executor.h:43
Definition binary_function_executor.h:22
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, RESULT_TYPE &result, common::ValueVector *leftValueVector, common::ValueVector *rightValueVector, common::ValueVector *resultValueVector, uint64_t, void *)
Definition binary_function_executor.h:24
Definition binary_function_executor.h:31
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, RESULT_TYPE &result, common::ValueVector *leftValueVector, common::ValueVector *rightValueVector, common::ValueVector *resultValueVector, uint64_t, void *dataPtr)
Definition binary_function_executor.h:33
Definition binary_function_executor.h:51
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, RESULT_TYPE &result, common::ValueVector *, common::ValueVector *, common::ValueVector *resultValueVector, uint64_t, void *)
Definition binary_function_executor.h:53
Definition binary_function_executor.h:69
static void operation(LEFT_TYPE &left, RIGHT_TYPE &right, RESULT_TYPE &result, common::ValueVector *, common::ValueVector *, common::ValueVector *, uint64_t, void *dataPtr)
Definition binary_function_executor.h:71