OmniSciDB  a987f07e93
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TableFunctionsTesting.hpp
Go to the documentation of this file.
1 /*
2  * Copyright 2021 OmniSci, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #pragma once
18 
19 #include "../../QueryEngine/TableFunctions/SystemFunctions/os/Shared/TableFunctionsCommon.hpp"
20 #include "../../QueryEngine/heavydbTypes.h"
21 
22 /*
23  This file contains tesing compile-time UDTFs. The unit-tests are
24  implemented within the RBC package.
25  */
26 
27 #define CPU_DEVICE_CODE 0x637075; // 'cpu' in hex
28 #define GPU_DEVICE_CODE 0x677075; // 'gpu' in hex
29 
30 // clang-format off
31 /*
32  UDTF: ct_device_selection_udtf_any(Cursor<int32_t>, Constant<1>) -> Column<int32_t>
33  UDTF: ct_device_selection_udtf_cpu__cpu_(Cursor<int32_t>, Constant<1>) -> Column<int32_t>
34  UDTF: ct_device_selection_udtf_gpu__gpu_(Cursor<int32_t>, Constant<1>) -> Column<int32_t>
35  UDTF: ct_device_selection_udtf_both__cpu_(Cursor<int32_t>, Constant<1>) -> Column<int32_t>
36  UDTF: ct_device_selection_udtf_both__gpu_(Cursor<int32_t>, Constant<1>) -> Column<int32_t>
37 */
38 // clang-format on
39 
40 EXTENSION_NOINLINE
41 int32_t ct_device_selection_udtf_any(const Column<int32_t>& input, Column<int64_t>& out) {
42 #ifdef __CUDACC__
43  out[0] = GPU_DEVICE_CODE;
44 #else
45  out[0] = CPU_DEVICE_CODE;
46 #endif
47  return 1;
48 }
49 
50 #ifndef __CUDACC__
51 
52 EXTENSION_NOINLINE_HOST
53 int32_t ct_device_selection_udtf_cpu__cpu_(const Column<int32_t>& input,
54  Column<int64_t>& out) {
55  out[0] = CPU_DEVICE_CODE;
56  return 1;
57 }
58 
59 #endif // #ifndef __CUDACC__
60 
61 EXTENSION_NOINLINE
62 int32_t ct_device_selection_udtf_gpu__gpu_(const Column<int32_t>& input,
63  Column<int64_t>& out) {
64  out[0] = GPU_DEVICE_CODE;
65  return 1;
66 }
67 
68 #ifndef __CUDACC__
69 
70 EXTENSION_NOINLINE_HOST
71 int32_t ct_device_selection_udtf_both__cpu_(const Column<int32_t>& input,
72  Column<int64_t>& out) {
73  out[0] = CPU_DEVICE_CODE;
74  return 1;
75 }
76 
77 #endif // #ifndef __CUDACC__
78 
79 EXTENSION_NOINLINE
80 int32_t ct_device_selection_udtf_both__gpu_(const Column<int32_t>& input,
81  Column<int64_t>& out) {
82  out[0] = GPU_DEVICE_CODE;
83  return 1;
84 }
85 
86 #undef CPU_DEVICE_CODE
87 #undef GPU_DEVICE_CODE
88 
89 // clang-format off
90 /*
91  Test functions for constant sizer parameter:
92 
93  UDTF: ct_binding_udtf_constant__cpu_1(Cursor<int32_t>, Constant<1>) -> Column<int32_t>
94  UDTF: ct_binding_udtf_constant__cpu_2(Cursor<int32_t, int32_t>, Constant<1>) -> Column<int32_t>
95  UDTF: ct_binding_udtf_constant__cpu_3(Cursor<int32_t, int32_t, int32_t>, Constant<1>) -> Column<int32_t>
96  UDTF: ct_binding_udtf_constant__cpu_4(Cursor<int64_t, int32_t, int32_t>, Constant<1>) -> Column<int32_t>
97  UDTF: ct_binding_udtf_constant__cpu_5(Cursor<int64_t, int64_t, int32_t>, Constant<1>) -> Column<int32_t>
98  UDTF: ct_binding_udtf_constant__cpu_6(Cursor<int64_t, int32_t, int64_t>, Constant<1>) -> Column<int32_t>
99  UDTF: ct_binding_udtf_constant__cpu_7(Cursor<int32_t, ColumnList<int32_t>>, Constant<1>) -> Column<int32_t>
100  UDTF: ct_binding_udtf_constant__cpu_8(Cursor<ColumnList<int32_t>, int64_t>, Constant<1>) -> Column<int32_t>
101  UDTF: ct_binding_udtf_constant__cpu_9(Cursor<ColumnList<int32_t>, ColumnList<int64_t>>, Constant<1>) -> Column<int32_t>
102  UDTF: ct_binding_udtf_constant__cpu_10(Cursor<int64_t, ColumnList<int64_t>, int64_t>, Constant<1>) -> Column<int32_t>
103 
104 
105  Test functions for row multiplier sizer parameter:
106 
107  UDTF: ct_binding_udtf__cpu_11(Cursor<int32_t>, RowMultiplier) -> Column<int32_t>
108  UDTF: ct_binding_udtf__cpu_12(Cursor<int32_t, int32_t>, RowMultiplier) -> Column<int32_t>
109  UDTF: ct_binding_udtf__cpu_13(Cursor<int32_t, int32_t, int32_t>, RowMultiplier) -> Column<int32_t>
110  UDTF: ct_binding_udtf__cpu_14(Cursor<int64_t, int32_t, int32_t>, RowMultiplier) -> Column<int32_t>
111  UDTF: ct_binding_udtf__cpu_15(Cursor<int64_t, int64_t, int32_t>, RowMultiplier) -> Column<int32_t>
112  UDTF: ct_binding_udtf__cpu_16(Cursor<int64_t, int32_t, int64_t>, RowMultiplier) -> Column<int32_t>
113  UDTF: ct_binding_udtf__cpu_17(Cursor<int32_t, ColumnList<int32_t>>, RowMultiplier) -> Column<int32_t>
114  UDTF: ct_binding_udtf__cpu_18(Cursor<ColumnList<int32_t>, int64_t>, RowMultiplier) -> Column<int32_t>
115  UDTF: ct_binding_udtf__cpu_19(Cursor<ColumnList<int32_t>, ColumnList<int64_t>>, RowMultiplier) -> Column<int32_t>
116  UDTF: ct_binding_udtf__cpu_20(Cursor<int64_t, ColumnList<int64_t>, int64_t>, RowMultiplier) -> Column<int32_t>
117 
118  UDTF: ct_binding_udtf2__cpu_21(RowMultiplier, Cursor<int32_t>) -> Column<int32_t>
119  UDTF: ct_binding_udtf6__cpu_22(Cursor<int32_t>, RowMultiplier, int32_t) -> Column<int32_t>
120  UDTF: ct_binding_udtf4__cpu_23(Cursor<ColumnList<int32_t>>, RowMultiplier, int32_t) -> Column<int32_t>
121  UDTF: ct_binding_udtf5__cpu_24(Cursor<ColumnList<int32_t>>, int32_t, RowMultiplier) -> Column<int32_t>
122  UDTF: ct_binding_udtf3__cpu_25(Cursor<Column<int32_t>>, int32_t, RowMultiplier) -> Column<int32_t>
123 */
124 // clang-format on
125 
126 #ifndef __CUDACC__
127 
128 EXTENSION_NOINLINE_HOST int32_t
129 ct_binding_udtf_constant__cpu_1(const Column<int32_t>& input1, Column<int32_t>& out) {
130  out[0] = 1;
131  return 1;
132 }
133 EXTENSION_NOINLINE_HOST int32_t
134 ct_binding_udtf_constant__cpu_2(const Column<int32_t>& input1,
135  const Column<int32_t>& input2,
136  Column<int32_t>& out) {
137  out[0] = 11;
138  return 1;
139 }
140 EXTENSION_NOINLINE_HOST int32_t
141 ct_binding_udtf_constant__cpu_3(const Column<int32_t>& input1,
142  const Column<int32_t>& input2,
143  const Column<int32_t>& input3,
144  Column<int32_t>& out) {
145  out[0] = 111;
146  return 1;
147 }
148 EXTENSION_NOINLINE_HOST int32_t
149 ct_binding_udtf_constant__cpu_4(const Column<int64_t>& input1,
150  const Column<int32_t>& input2,
151  const Column<int32_t>& input3,
152  Column<int32_t>& out) {
153  out[0] = 211;
154  return 1;
155 }
156 EXTENSION_NOINLINE_HOST int32_t
157 ct_binding_udtf_constant__cpu_5(const Column<int64_t>& input1,
158  const Column<int64_t>& input2,
159  const Column<int32_t>& input3,
160  Column<int32_t>& out) {
161  out[0] = 221;
162  return 1;
163 }
164 EXTENSION_NOINLINE_HOST int32_t
165 ct_binding_udtf_constant__cpu_6(const Column<int64_t>& input1,
166  const Column<int32_t>& input2,
167  const Column<int64_t>& input3,
168  Column<int32_t>& out) {
169  out[0] = 212;
170  return 1;
171 }
172 EXTENSION_NOINLINE_HOST int32_t
173 ct_binding_udtf_constant__cpu_7(const Column<int32_t>& input1,
174  const ColumnList<int32_t>& input2,
175  Column<int32_t>& out) {
176  out[0] = 13;
177  return 1;
178 }
179 EXTENSION_NOINLINE_HOST int32_t
180 ct_binding_udtf_constant__cpu_8(const ColumnList<int32_t>& input1,
181  const Column<int64_t>& input2,
182  Column<int32_t>& out) {
183  out[0] = 32;
184  return 1;
185 }
186 EXTENSION_NOINLINE_HOST int32_t
187 ct_binding_udtf_constant__cpu_9(const ColumnList<int32_t>& input1,
188  const ColumnList<int64_t>& input2,
189  Column<int32_t>& out) {
190  out[0] = 34;
191  return 1;
192 }
193 EXTENSION_NOINLINE_HOST int32_t
194 ct_binding_udtf_constant__cpu_10(const Column<int64_t>& input1,
195  const ColumnList<int64_t>& input2,
196  const Column<int64_t>& input3,
197  Column<int64_t>& out) {
198  out[0] = 242;
199  return 1;
200 }
201 
202 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_11(const Column<int32_t>& input1,
203  const int32_t multiplier,
204  Column<int32_t>& out) {
205  out[0] = 1000 + 19 + multiplier;
206  return 1;
207 }
208 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_12(const Column<int32_t>& input1,
209  const Column<int32_t>& input2,
210  const int32_t multiplier,
211  Column<int32_t>& out) {
212  out[0] = 1000 + 119 + multiplier;
213  return 1;
214 }
215 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_13(const Column<int32_t>& input1,
216  const Column<int32_t>& input2,
217  const Column<int32_t>& input3,
218  const int32_t multiplier,
219  Column<int32_t>& out) {
220  out[0] = 1000 + 1119 + multiplier;
221  return 1;
222 }
223 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_14(const Column<int64_t>& input1,
224  const Column<int32_t>& input2,
225  const Column<int32_t>& input3,
226  const int32_t multiplier,
227  Column<int32_t>& out) {
228  out[0] = 1000 + 2119 + multiplier;
229  return 1;
230 }
231 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_15(const Column<int64_t>& input1,
232  const Column<int64_t>& input2,
233  const Column<int32_t>& input3,
234  const int32_t multiplier,
235  Column<int32_t>& out) {
236  out[0] = 1000 + 2219 + multiplier;
237  return 1;
238 }
239 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_16(const Column<int64_t>& input1,
240  const Column<int32_t>& input2,
241  const Column<int64_t>& input3,
242  const int32_t multiplier,
243  Column<int32_t>& out) {
244  out[0] = 1000 + 2129 + multiplier;
245  return 1;
246 }
247 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_17(const Column<int32_t>& input1,
248  const ColumnList<int32_t>& input2,
249  const int32_t multiplier,
250  Column<int32_t>& out) {
251  out[0] = 1000 + 139 + multiplier;
252  return 1;
253 }
254 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_18(const ColumnList<int32_t>& input1,
255  const Column<int64_t>& input2,
256  const int32_t multiplier,
257  Column<int32_t>& out) {
258  out[0] = 1000 + 329 + multiplier;
259  return 1;
260 }
261 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_19(const ColumnList<int32_t>& input1,
262  const ColumnList<int64_t>& input2,
263  const int32_t multiplier,
264  Column<int32_t>& out) {
265  out[0] = 1000 + 349 + multiplier;
266  return 1;
267 }
268 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_20(const Column<int64_t>& input1,
269  const ColumnList<int64_t>& input2,
270  const Column<int64_t>& input3,
271  const int32_t multiplier,
272  Column<int64_t>& out) {
273  out[0] = 1000 + 2429 + multiplier;
274  return 1;
275 }
276 
277 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf2__cpu_21(const int32_t multiplier,
278  const Column<int32_t>& input1,
279  Column<int32_t>& out) {
280  out[0] = 1000 + 91 + multiplier;
281  return 1;
282 }
283 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf6__cpu_22(const Column<int32_t>& input1,
284  const int32_t multiplier,
285  const int32_t input2,
286  Column<int32_t>& out) {
287  out[0] = 1000 + 196 + multiplier + 10 * input2;
288  return 1;
289 }
290 EXTENSION_NOINLINE_HOST int32_t
291 ct_binding_udtf4__cpu_23(const ColumnList<int32_t>& input1,
292  const int32_t multiplier,
293  const int32_t input2,
294  Column<int32_t>& out) {
295  out[0] = 1000 + 396 + multiplier + 10 * input2;
296  return 1;
297 }
298 EXTENSION_NOINLINE_HOST int32_t
299 ct_binding_udtf5__cpu_24(const ColumnList<int32_t>& input1,
300  const int32_t input2,
301  const int32_t multiplier,
302  Column<int32_t>& out) {
303  out[0] = 1000 + 369 + multiplier + 10 * input2;
304  return 1;
305 }
306 EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf3__cpu_25(const Column<int32_t>& input1,
307  const int32_t input2,
308  const int32_t multiplier,
309  Column<int32_t>& out) {
310  out[0] = 1000 + 169 + multiplier + 10 * input2;
311  return 1;
312 }
313 
314 #endif // #ifndef __CUDACC__
315 
316 /*
317  Test functions for default sizer parameter:
318 */
319 
320 // clang-format off
321 /*
322  UDTF: ct_udtf_default_sizer1a__cpu_1(Cursor<int32_t>, RowMultiplier) -> Column<int32_t>
323  UDTF: ct_udtf_default_sizer1b__cpu_2(Cursor<int32_t>, Cursor<int32_t>, RowMultiplier) -> Column<int32_t>
324  UDTF: ct_udtf_default_sizer1c__cpu_3(Cursor<int32_t, int32_t, int32_t>, RowMultiplier, Cursor<int32_t>, int32_t) -> Column<int32_t>
325  UDTF: ct_udtf_default_sizer1d__cpu_4(RowMultiplier, int32_t, Cursor<int32_t>) -> Column<int32_t>
326  UDTF: ct_udtf_default_sizer2a__cpu_1(Cursor<int32_t>, int32_t, RowMultiplier) -> Column<int32_t>
327  UDTF: ct_udtf_default_sizer2b__cpu_2(Cursor<int32_t>, RowMultiplier, Cursor<int32_t>) -> Column<int32_t>
328  UDTF: ct_udtf_default_sizer2c__cpu_3(int32_t, RowMultiplier, Cursor<int32_t>) -> Column<int32_t>
329  UDTF: ct_udtf_default_sizer3a__cpu_1(Cursor<int32_t>, RowMultiplier, int32_t) -> Column<int32_t>
330  UDTF: ct_udtf_default_sizer3b__cpu_2(Cursor<int32_t>, int32_t, Cursor<int32_t>, RowMultiplier) -> Column<int32_t>
331  UDTF: ct_udtf_default_sizer4a__cpu_1(Cursor<int32_t>, RowMultiplier, Cursor<int32_t>, int32_t) -> Column<int32_t>
332  UDTF: ct_udtf_default_sizer4b__cpu_2(RowMultiplier, Cursor<int32_t>, int32_t) -> Column<int32_t>
333 */
334 // clang-format on
335 
336 #ifndef __CUDACC__
337 
338 EXTENSION_NOINLINE_HOST int32_t
339 ct_udtf_default_sizer1a__cpu_1(const Column<int32_t>& input1,
340  const int32_t multiplier,
341  Column<int32_t>& out) {
342  out[0] = 1000 + 1 + 10 * multiplier;
343  return 1;
344 }
345 EXTENSION_NOINLINE_HOST int32_t
346 ct_udtf_default_sizer1b__cpu_2(const Column<int32_t>& input1,
347  const Column<int32_t>& input2,
348  const int32_t multiplier,
349  Column<int32_t>& out) {
350  out[0] = 1000 + 2 + 11 * multiplier;
351  return 1;
352 }
353 EXTENSION_NOINLINE_HOST int32_t
354 ct_udtf_default_sizer1c__cpu_3(const Column<int32_t>& input1,
355  const Column<int32_t>& input2,
356  const Column<int32_t>& input3,
357  const int32_t multiplier,
358  const Column<int32_t>& input4,
359  const int32_t x,
360  Column<int32_t>& out) {
361  out[0] = 1000 + 101 + 10 * multiplier + x;
362  return 1;
363 }
364 EXTENSION_NOINLINE_HOST int32_t
365 ct_udtf_default_sizer1d__cpu_4(const int32_t multiplier,
366  const int32_t x,
367  const Column<int32_t>& input1,
368  Column<int32_t>& out) {
369  out[0] = 1000 + 99 + 10 * multiplier + x;
370  return 1;
371 }
372 EXTENSION_NOINLINE_HOST int32_t
373 ct_udtf_default_sizer2a__cpu_1(const Column<int32_t>& input1,
374  const int32_t x,
375  const int32_t multiplier,
376  Column<int32_t>& out) {
377  out[0] = 1000 + 98 + multiplier + 10 * x;
378  return 1;
379 }
380 EXTENSION_NOINLINE_HOST int32_t
381 ct_udtf_default_sizer2b__cpu_2(const Column<int32_t>& input1,
382  const int32_t multiplier,
383  const Column<int32_t>& input2,
384  Column<int32_t>& out) {
385  out[0] = 1000 + 2 + multiplier;
386  return 1;
387 }
388 EXTENSION_NOINLINE_HOST int32_t
389 ct_udtf_default_sizer2c__cpu_3(const int32_t x,
390  const int32_t multiplier,
391  const Column<int32_t>& input1,
392  Column<int32_t>& out) {
393  out[0] = 1000 + 99 + multiplier + 11 * x;
394  return 1;
395 }
396 EXTENSION_NOINLINE_HOST int32_t
397 ct_udtf_default_sizer3a__cpu_1(const Column<int32_t>& input1,
398  const int32_t multiplier,
399  const int32_t x,
400  Column<int32_t>& out) {
401  out[0] = 1000 + 98 + 100 * multiplier + x;
402  return 1;
403 }
404 EXTENSION_NOINLINE_HOST int32_t
405 ct_udtf_default_sizer3b__cpu_2(const Column<int32_t>& input1,
406  const int32_t x,
407  const Column<int32_t>& input2,
408  const int32_t multiplier,
409  Column<int32_t>& out) {
410  out[0] = 1000 + 99 + 100 * multiplier + x;
411  return 1;
412 }
413 EXTENSION_NOINLINE_HOST int32_t
414 ct_udtf_default_sizer4a__cpu_1(const Column<int32_t>& input1,
415  const int32_t multiplier,
416  const Column<int32_t>& input2,
417  const int32_t x,
418  Column<int32_t>& out) {
419  out[0] = 1000 + 99 + 10 * multiplier + x;
420  return 1;
421 }
422 EXTENSION_NOINLINE_HOST int32_t
423 ct_udtf_default_sizer4b__cpu_2(const int32_t multiplier,
424  const Column<int32_t>& input,
425  const int32_t x,
426  Column<int32_t>& out) {
427  out[0] = 1000 + 99 + 9 * multiplier + x;
428  return 1;
429 }
430 
431 #endif // #ifndef __CUDACC__
432 
433 // clang-format off
434 /*
435  UDTF: ct_binding_dict_encoded1__cpu_1(Cursor<TextEncodingDict>, RowMultiplier) -> Column<TextEncodingDict> | input_id=args<0>
436  UDTF: ct_binding_dict_encoded2__cpu_1(Cursor<TextEncodingDict, TextEncodingDict>) -> Column<TextEncodingDict> | input_id=args<0, 0>, Column<TextEncodingDict> | input_id=args<0, 1>
437  UDTF: ct_binding_dict_encoded3__cpu_1(Cursor<TextEncodingDict, TextEncodingDict>) -> Column<TextEncodingDict> | input_id=args<0, 1>, Column<TextEncodingDict> | input_id=args<0, 0>
438  UDTF: ct_binding_dict_encoded4__cpu_1(Cursor<ColumnList<TextEncodingDict>>) -> Column<TextEncodingDict> | input_id=args<0,0>
439  UDTF: ct_binding_dict_encoded5__cpu_1(Cursor<ColumnList<TextEncodingDict>>) -> Column<TextEncodingDict> | input_id=args<0,1>
440  UDTF: ct_binding_dict_encoded6__cpu_1(Cursor<ColumnList<TextEncodingDict>>) -> Column<TextEncodingDict> | input_id=args<0,0>, Column<TextEncodingDict> | input_id=args<0,1>
441 */
442 // clang-format on
443 
444 #ifndef __CUDACC__
445 
446 EXTENSION_NOINLINE_HOST int32_t
447 ct_binding_dict_encoded1__cpu_1(const Column<TextEncodingDict>& input,
448  const int32_t multiplier,
449  Column<TextEncodingDict>& out) {
450  for (int64_t i = 0; i < input.size(); i++) {
451  out[i] = input[i]; // assign string id
452  }
453  return multiplier * input.size();
454 }
455 
456 EXTENSION_NOINLINE_HOST int32_t
457 ct_binding_dict_encoded2__cpu_1(const Column<TextEncodingDict>& input1,
458  const Column<TextEncodingDict>& input2,
459  Column<TextEncodingDict>& out1,
460  Column<TextEncodingDict>& out2) {
461  set_output_row_size(input1.size());
462  for (int64_t i = 0; i < input1.size(); i++) {
463  out1[i] = input1[i];
464  out2[i] = input2[i];
465  }
466  return input1.size();
467 }
468 
469 EXTENSION_NOINLINE_HOST int32_t
470 ct_binding_dict_encoded3__cpu_1(const Column<TextEncodingDict>& input1,
471  const Column<TextEncodingDict>& input2,
472  Column<TextEncodingDict>& out1,
473  Column<TextEncodingDict>& out2) {
474  set_output_row_size(input1.size());
475  for (int64_t i = 0; i < input1.size(); i++) {
476  out1[i] = input2[i];
477  out2[i] = input1[i];
478  }
479  return input1.size();
480 }
481 
482 EXTENSION_NOINLINE_HOST int32_t
483 ct_binding_dict_encoded4__cpu_1(const ColumnList<TextEncodingDict>& input,
484  Column<TextEncodingDict>& out) {
485  int64_t sz = input[0].size();
486  set_output_row_size(sz);
487  for (int64_t i = 0; i < sz; i++) {
488  out[i] = input[0][i];
489  }
490  return sz;
491 }
492 
493 EXTENSION_NOINLINE_HOST int32_t
494 ct_binding_dict_encoded5__cpu_1(const ColumnList<TextEncodingDict>& input,
495  Column<TextEncodingDict>& out) {
496  int64_t sz = input[1].size();
497  set_output_row_size(sz);
498  for (int64_t i = 0; i < sz; i++) {
499  out[i] = input[1][i];
500  }
501  return sz;
502 }
503 
504 EXTENSION_NOINLINE_HOST int32_t
505 ct_binding_dict_encoded6__cpu_1(const ColumnList<TextEncodingDict>& input,
506  Column<TextEncodingDict>& out0,
507  Column<TextEncodingDict>& out1) {
508  int64_t sz = input[0].size();
509  set_output_row_size(sz);
510  for (int64_t i = 0; i < sz; i++) {
511  out0[i] = input[0][i];
512  out1[i] = input[1][i];
513  }
514  return sz;
515 }
516 
517 #endif // #ifndef __CUDACC__
518 
519 // clang-format off
520 /*
521  UDTF: ct_binding_template__cpu_template(Cursor<TextEncodingDict>) -> Column<TextEncodingDict> | input_id=args<0>
522  UDTF: ct_binding_template__cpu_template(Cursor<int>) -> Column<int>
523  UDTF: ct_binding_template__cpu_template(Cursor<float>) -> Column<float>
524 */
525 // clang-format on
526 
527 #ifndef __CUDACC__
528 
529 template <typename T>
530 NEVER_INLINE HOST int32_t ct_binding_template__cpu_template(const Column<T>& input,
531  Column<T>& out) {
532  set_output_row_size(input.size());
533  for (int64_t i = 0; i < input.size(); i++) {
534  out[i] = input[i];
535  }
536  return input.size();
537 }
538 
539 #endif // #ifndef __CUDACC__
540 
541 // clang-format off
542 /*
543  UDTF: ct_binding_columnlist__cpu_template(Cursor<int32_t, ColumnList<int32_t>>) -> Column<int32_t>
544  UDTF: ct_binding_columnlist__cpu_template(Cursor<float, ColumnList<float>>) -> Column<int32_t>
545  UDTF: ct_binding_columnlist__cpu_template(Cursor<TextEncodingDict, ColumnList<TextEncodingDict>>) -> Column<int32_t>
546  UDTF: ct_binding_columnlist__cpu_template(Cursor<int16_t, ColumnList<int16_t>>) -> Column<int32_t>
547 */
548 // clang-format on
549 
550 #ifndef __CUDACC__
551 
552 template <typename T>
553 NEVER_INLINE HOST int32_t ct_binding_columnlist__cpu_template(const Column<T>& input1,
554  const ColumnList<T>& input2,
555  Column<int32_t>& out) {
556  set_output_row_size(1);
557  if constexpr (std::is_same<T, int32_t>::value) {
558  out[0] = 1;
559  } else if constexpr (std::is_same<T, float>::value) {
560  out[0] = 2;
561  } else if constexpr (std::is_same<T, TextEncodingDict>::value) {
562  out[0] = 3;
563  } else {
564  out[0] = 4;
565  }
566  return 1;
567 }
568 
569 #endif // #ifndef __CUDACC__
570 
571 // clang-format off
572 /*
573  UDTF: ct_binding_column__cpu_template(Column<int32_t>) -> Column<int32_t>
574  UDTF: ct_binding_column__cpu_template(Column<float>) -> Column<int32_t>
575 */
576 // clang-format on
577 
578 #ifndef __CUDACC__
579 
580 template <typename T>
581 NEVER_INLINE HOST int32_t ct_binding_column__cpu_template(const Column<T>& input,
582  Column<int32_t>& out) {
583  set_output_row_size(1);
584  if constexpr (std::is_same<T, int32_t>::value) {
585  out[0] = 10;
586  } else {
587  out[0] = 20;
588  }
589  return 1;
590 }
591 
592 #endif // #ifndef __CUDACC__
593 
594 // clang-format off
595 /*
596  UDTF: ct_binding_scalar_multiply__cpu_template(Cursor<Column<float>>, float) -> Column<float>
597  UDTF: ct_binding_scalar_multiply__cpu_template(Cursor<Column<double>>, double) -> Column<double>
598  UDTF: ct_binding_scalar_multiply__cpu_template(Cursor<Column<int32_t>>, int32_t) -> Column<int32_t>
599  UDTF: ct_binding_scalar_multiply__cpu_template(Cursor<Column<int64_t>>, int64_t) -> Column<int64_t>
600 */
601 // clang-format on
602 
603 #ifndef __CUDACC__
604 
605 template <typename T>
606 NEVER_INLINE HOST int32_t ct_binding_scalar_multiply__cpu_template(const Column<T>& input,
607  const T multiplier,
608  Column<T>& out) {
609  const int64_t num_rows = input.size();
610  set_output_row_size(num_rows);
611  for (int64_t r = 0; r < num_rows; ++r) {
612  if (!input.isNull(r)) {
613  out[r] = input[r] * multiplier;
614  } else {
615  out.setNull(r);
616  }
617  }
618  return num_rows;
619 }
620 
621 // clang-format off
622 /*
623  UDTF: ct_binding_str_length__cpu_(Cursor<TextEncodingDict>) -> Column<TextEncodingDict> string | input_id=args<0>, Column<int64_t> string_length
624 */
625 // clang-format on
626 EXTENSION_NOINLINE_HOST
627 int32_t ct_binding_str_length__cpu_(const Column<TextEncodingDict>& input_str,
628  Column<TextEncodingDict>& out_str,
629  Column<int64_t>& out_size) {
630  const int64_t num_rows = input_str.size();
631  set_output_row_size(num_rows);
632  for (int64_t i = 0; i < num_rows; i++) {
633  out_str[i] = input_str[i];
634  const std::string str = input_str.getString(i);
635  out_size[i] = str.size();
636  }
637  return num_rows;
638 }
639 
640 // clang-format off
641 /*
642  UDTF: ct_binding_str_equals__cpu_(Cursor<ColumnList<TextEncodingDict>>) -> Column<TextEncodingDict> string_if_equal | input_id=args<0, 0>, Column<bool> strings_are_equal
643 */
644 // clang-format on
645 EXTENSION_NOINLINE_HOST
646 int32_t ct_binding_str_equals__cpu_(const ColumnList<TextEncodingDict>& input_strings,
647  Column<TextEncodingDict>& string_if_equal,
648  Column<bool>& strings_are_equal) {
649  const int64_t num_rows = input_strings.size();
650  const int64_t num_cols = input_strings.numCols();
651  set_output_row_size(num_rows);
652  for (int64_t r = 0; r < num_rows; r++) {
653  bool are_equal = true;
654  if (num_cols > 0) {
655  std::string first_str = input_strings[0].getString(r);
656  for (int64_t c = 1; c != num_cols; ++c) {
657  if (input_strings[c].getString(r) != first_str) {
658  are_equal = false;
659  break;
660  }
661  }
662  strings_are_equal[r] = are_equal;
663  if (are_equal && num_cols > 0) {
664  string_if_equal[r] = input_strings[0][r];
665  } else {
666  string_if_equal.setNull(r);
667  }
668  }
669  }
670  return num_rows;
671 }
672 
673 // clang-format off
674 /*
675  UDTF: ct_substr__cpu_(TableFunctionManager, Cursor<Column<TextEncodingDict> str, Column<int> pos, Column<int> len>) -> Column<TextEncodingDict> substr | input_id=args<0>
676 */
677 // clang-format on
678 
679 EXTENSION_NOINLINE_HOST
680 int32_t ct_substr__cpu_(TableFunctionManager& mgr,
681  const Column<TextEncodingDict>& input_str,
682  const Column<int>& pos,
683  const Column<int>& len,
684  Column<TextEncodingDict>& output_substr) {
685  const int64_t num_rows = input_str.size();
686  mgr.set_output_row_size(num_rows);
687  for (int64_t row_idx = 0; row_idx < num_rows; row_idx++) {
688  const std::string input_string{input_str.getString(row_idx)};
689  const std::string substring = input_string.substr(pos[row_idx], len[row_idx]);
690  const TextEncodingDict substr_id = output_substr.getOrAddTransient(substring);
691  output_substr[row_idx] = substr_id;
692  }
693  return num_rows;
694 }
695 
696 // clang-format off
697 /*
698  UDTF: ct_string_concat__cpu_(TableFunctionManager, Cursor<ColumnList<TextEncodingDict>>, TextEncodingNone separator) -> Column<TextEncodingDict> concatted_str | input_id=args<0, 0>
699 */
700 // clang-format on
701 EXTENSION_NOINLINE_HOST
702 int32_t ct_string_concat__cpu_(TableFunctionManager& mgr,
703  const ColumnList<TextEncodingDict>& input_strings,
704  const TextEncodingNone& separator,
705  Column<TextEncodingDict>& concatted_string) {
706  const int64_t num_rows = input_strings.size();
707  const int64_t num_cols = input_strings.numCols();
708  const std::string separator_str{separator.getString()};
709  mgr.set_output_row_size(num_rows);
710  for (int64_t row_idx = 0; row_idx < num_rows; row_idx++) {
711  if (num_cols > 0) {
712  std::string concatted_output{input_strings[0].getString(row_idx)};
713  for (int64_t col_idx = 1; col_idx < num_cols; ++col_idx) {
714  concatted_output += separator_str;
715  concatted_output += input_strings[col_idx].getString(row_idx);
716  }
717  const TextEncodingDict concatted_str_id =
718  concatted_string.getOrAddTransient(concatted_output);
719  concatted_string[row_idx] = concatted_str_id;
720  } else {
721  concatted_string.setNull(row_idx);
722  }
723  }
724  return num_rows;
725 }
726 
727 // clang-format off
728 /*
729  UDTF: ct_synthesize_new_dict__cpu_(TableFunctionManager, int32_t num_strings) -> Column<TextEncodingDict> new_dict_col | input_id=args<0>
730 */
731 // clang-format on
732 EXTENSION_NOINLINE_HOST
733 int32_t ct_synthesize_new_dict__cpu_(TableFunctionManager& mgr,
734  const int64_t num_strings,
735  Column<TextEncodingDict>& new_dict_col) {
736  mgr.set_output_row_size(num_strings);
737  for (int32_t s = 0; s < num_strings; ++s) {
738  const std::string new_string = "String_" + std::to_string(s);
739  const int32_t string_id = new_dict_col.getOrAddTransient(new_string);
740  new_dict_col[s] = string_id;
741  }
742  return num_strings;
743 }
744 
745 #endif // #ifndef __CUDACC__
746 
747 #ifndef __CUDACC__
748 
749 #include <algorithm>
750 
751 template <typename T>
752 struct SortAsc {
753  SortAsc(const bool nulls_last)
754  : null_value_(std::numeric_limits<T>::lowest())
755  , null_value_mapped_(map_null_value(nulls_last)) {}
756  static T map_null_value(const bool nulls_last) {
757  return nulls_last ? std::numeric_limits<T>::max() : std::numeric_limits<T>::lowest();
758  }
759  inline T mapValue(const T& val) {
760  return val == null_value_ ? null_value_mapped_ : val;
761  }
762  bool operator()(const T& a, const T& b) { return mapValue(a) < mapValue(b); }
763  const T null_value_;
764  const T null_value_mapped_;
765 };
766 
767 template <typename T>
768 struct SortDesc {
769  SortDesc(const bool nulls_last)
770  : null_value_(std::numeric_limits<T>::lowest())
771  , null_value_mapped_(map_null_value(nulls_last)) {}
772  static T map_null_value(const bool nulls_last) {
773  return nulls_last ? std::numeric_limits<T>::lowest() : std::numeric_limits<T>::max();
774  }
775 
776  inline T mapValue(const T& val) {
777  return val == null_value_ ? null_value_mapped_ : val;
778  }
779 
780  bool operator()(const T& a, const T& b) { return mapValue(a) > mapValue(b); }
781  const T null_value_;
782  const T null_value_mapped_;
783 };
784 
785 // clang-format off
786 /*
787  UDTF: sort_column_limit__cpu_template(Cursor<Column<int8_t>>, int32_t, bool, bool) -> Column<int8_t>
788  UDTF: sort_column_limit__cpu_template(Cursor<Column<int16_t>>, int32_t, bool, bool) -> Column<int16_t>
789  UDTF: sort_column_limit__cpu_template(Cursor<Column<int32_t>>, int32_t, bool, bool) -> Column<int32_t>
790  UDTF: sort_column_limit__cpu_template(Cursor<Column<int64_t>>, int32_t, bool, bool) -> Column<int64_t>
791  UDTF: sort_column_limit__cpu_template(Cursor<Column<float>>, int32_t, bool, bool) -> Column<float>
792  UDTF: sort_column_limit__cpu_template(Cursor<Column<double>>, int32_t, bool, bool) -> Column<double>
793 */
794 // clang-format on
795 
796 template <typename T>
797 NEVER_INLINE HOST int32_t sort_column_limit__cpu_template(const Column<T>& input,
798  const int32_t limit,
799  const bool sort_ascending,
800  const bool nulls_last,
801  Column<T>& output) {
802  const int64_t num_rows = input.size();
803  set_output_row_size(num_rows);
804  output = input;
805  if (sort_ascending) {
806  std::sort(output.ptr_, output.ptr_ + num_rows, SortAsc<T>(nulls_last));
807  } else {
808  std::sort(output.ptr_, output.ptr_ + num_rows, SortDesc<T>(nulls_last));
809  }
810  if (limit < 0 || limit > num_rows) {
811  return num_rows;
812  }
813  return limit;
814 }
815 
816 #endif
817 
818 // clang-format off
819 /*
820  UDTF: ct_binding_column2__cpu_template(Column<T>, Column<U>) -> Column<K>, T=[int32_t, double], U=[int32_t, double], K=[int32_t]
821  UDTF: ct_binding_column2__cpu_template(Column<T>, Column<T>) -> Column<T> | input_id=args<0>, T=[TextEncodingDict]
822 */
823 // clang-format on
824 
825 #ifndef __CUDACC__
826 
827 template <typename T, typename U, typename K>
828 NEVER_INLINE HOST int32_t ct_binding_column2__cpu_template(const Column<T>& input1,
829  const Column<U>& input2,
830  Column<K>& out) {
831  if constexpr (std::is_same<T, TextEncodingDict>::value &&
832  std::is_same<U, TextEncodingDict>::value) {
833  set_output_row_size(input1.size());
834  for (int64_t i = 0; i < input1.size(); i++) {
835  out[i] = input1[i];
836  }
837  return input1.size();
838  }
839 
840  set_output_row_size(1);
841  if constexpr (std::is_same<T, int32_t>::value && std::is_same<U, double>::value) {
842  out[0] = 10;
843  } else if constexpr (std::is_same<T, double>::value && std::is_same<U, double>::value) {
844  out[0] = 20;
845  } else if constexpr (std::is_same<T, int32_t>::value &&
846  std::is_same<U, int32_t>::value) {
847  out[0] = 30;
848  } else if constexpr (std::is_same<T, double>::value &&
849  std::is_same<U, int32_t>::value) {
850  out[0] = 40;
851  }
852  return 1;
853 }
854 
855 #endif // #ifndef __CUDACC__
856 
857 // clang-format off
858 /*
859  UDTF: ct_named_output__cpu_template(Column<T> input) -> Column<T> total, T=[int32_t, double]
860  UDTF: ct_named_const_output__cpu_template(Column<T> input, Constant<2>) -> Column<T> total, T=[int32_t, double]
861  UDTF: ct_named_user_const_output__cpu_template(Column<T> input, ConstantParameter c) -> Column<T> total, T=[int32_t, double]
862  UDTF: ct_named_rowmul_output__cpu_template(Column<T> input, RowMultiplier m) -> Column<T> total, T=[int32_t, double]
863 */
864 // clang-format on
865 
866 #ifndef __CUDACC__
867 
868 template <typename T>
869 NEVER_INLINE HOST int32_t ct_named_output__cpu_template(const Column<T>& input,
870  Column<T>& out) {
871  set_output_row_size(1);
872  T acc = 0;
873  for (int64_t i = 0; i < input.size(); i++) {
874  acc += input[i];
875  }
876  out[0] = acc;
877  return 1;
878 }
879 
880 template <typename T>
881 NEVER_INLINE HOST int32_t ct_named_const_output__cpu_template(const Column<T>& input,
882  Column<T>& out) {
883  T acc1 = 0, acc2 = 0;
884  for (int64_t i = 0; i < input.size(); i++) {
885  if (i % 2 == 0) {
886  acc1 += input[i];
887  } else {
888  acc2 += input[i];
889  }
890  }
891  out[0] = acc1;
892  out[1] = acc2;
893  return 2;
894 }
895 
896 template <typename T>
897 NEVER_INLINE HOST int32_t ct_named_user_const_output__cpu_template(const Column<T>& input,
898  int32_t c,
899  Column<T>& out) {
900  for (int64_t i = 0; i < c; i++) {
901  out[i] = 0;
902  }
903  for (int64_t i = 0; i < input.size(); i++) {
904  out[i % c] += input[i];
905  }
906  return c;
907 }
908 
909 template <typename T>
910 NEVER_INLINE HOST int32_t ct_named_rowmul_output__cpu_template(const Column<T>& input,
911  int32_t m,
912  Column<T>& out) {
913  for (int64_t j = 0; j < m; j++) {
914  for (int64_t i = 0; i < input.size(); i++) {
915  out[j * input.size() + i] += input[i];
916  }
917  }
918  return m * input.size();
919 }
920 
921 #endif // #ifndef __CUDACC__
922 
923 // clang-format off
924 /*
925  UDTF: ct_no_arg_runtime_sizing__cpu_template() -> Column<T> answer, T=[int32_t]
926 */
927 // clang-format on
928 
929 #ifndef __CUDACC__
930 
931 template <typename T>
932 NEVER_INLINE HOST int32_t ct_no_arg_runtime_sizing__cpu_template(Column<T>& answer) {
933  set_output_row_size(1);
934  answer[0] = 42;
935  return 1;
936 }
937 
938 #endif // #ifndef __CUDACC__
939 
940 // clang-format off
941 /*
942  UDTF: ct_no_arg_constant_sizing(Constant<42>) -> Column<int32_t> answer
943 */
944 // clang-format on
945 
946 EXTENSION_NOINLINE int32_t ct_no_arg_constant_sizing(Column<int32_t>& answer) {
947 #ifdef __CUDACC__
948  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
949  int32_t stop = static_cast<int32_t>(42);
950  int32_t step = blockDim.x * gridDim.x;
951 #else
952  auto start = 0;
953  auto stop = 42;
954  auto step = 1;
955 #endif
956  for (auto i = start; i < stop; i += step) {
957  answer[i] = 42 * i;
958  }
959  return 42;
960 }
961 
962 // clang-format off
963 /*
964  UDTF: ct_scalar_1_arg_runtime_sizing__cpu_template(T num) -> Column<T> answer, T=[float, double, int32_t, int64_t]
965 */
966 // clang-format on
967 
968 #ifndef __CUDACC__
969 
970 template <typename T>
971 NEVER_INLINE HOST int32_t
972 ct_scalar_1_arg_runtime_sizing__cpu_template(const T num, Column<T>& answer) {
973  T quotient = num;
974  set_output_row_size(30);
975  int32_t counter{0};
976  while (quotient >= 1) {
977  answer[counter++] = quotient;
978  quotient /= 10;
979  }
980  return counter;
981 }
982 
983 #endif // #ifndef __CUDACC__
984 
985 // clang-format off
986 /*
987  UDTF: ct_scalar_2_args_constant_sizing(int64_t, int64_t, Constant<5>) -> Column<int64_t> answer1, Column<int64_t> answer2
988 */
989 // clang-format on
990 
991 EXTENSION_NOINLINE int32_t ct_scalar_2_args_constant_sizing(const int64_t num1,
992  const int64_t num2,
993  Column<int64_t>& answer1,
994  Column<int64_t>& answer2) {
995 #ifdef __CUDACC__
996  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
997  int32_t stop = static_cast<int32_t>(5);
998  int32_t step = blockDim.x * gridDim.x;
999 #else
1000  auto start = 0;
1001  auto stop = 5;
1002  auto step = 1;
1003 #endif
1004  for (auto i = start; i < stop; i += step) {
1005  answer1[i] = num1 + i * num2;
1006  answer2[i] = num1 - i * num2;
1007  }
1008  return 5;
1009 }
1010 
1011 // clang-format off
1012 /*
1013  UDTF: ct_no_cursor_user_constant_sizer__cpu_(int32_t, ConstantParameter c) -> Column<int32_t> output
1014 */
1015 // clang-format on
1016 
1017 #ifndef __CUDACC__
1018 
1019 EXTENSION_NOINLINE_HOST int32_t
1020 ct_no_cursor_user_constant_sizer__cpu_(const int32_t input_num,
1021  int32_t c,
1022  Column<int32_t>& output) {
1023  for (int32_t i = 0; i < c; i++) {
1024  output[i] = input_num;
1025  }
1026  return c;
1027 }
1028 
1029 #endif // #ifndef __CUDACC__
1030 
1031 // clang-format off
1032 /*
1033  UDTF: ct_templated_no_cursor_user_constant_sizer__cpu_template(T, ConstantParameter c) -> Column<T> output, T=[int32_t, float]
1034 */
1035 // clang-format on
1036 
1037 #ifndef __CUDACC__
1038 
1039 template <typename T>
1040 NEVER_INLINE HOST int32_t
1041 ct_templated_no_cursor_user_constant_sizer__cpu_template(const T input_num,
1042  int32_t c,
1043  Column<T>& output) {
1044  for (int32_t i = 0; i < c; i++) {
1045  output[i] = input_num;
1046  }
1047  return c;
1048 }
1049 
1050 #endif // #ifndef __CUDACC__
1051 
1052 #ifdef __CUDACC__
1053 
1054 // clang-format off
1055 /*
1056  UDTF: ct_no_cursor_user_constant_sizer__gpu_(int32_t, ConstantParameter c) -> Column<int32_t> output
1057 */
1058 // clang-format on
1059 
1060 EXTENSION_NOINLINE int32_t
1061 ct_no_cursor_user_constant_sizer__gpu_(const int32_t input_num,
1062  int32_t c,
1063  Column<int32_t>& output) {
1064  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
1065  int32_t step = blockDim.x * gridDim.x;
1066 
1067  for (int32_t i = start; i < c; i += step) {
1068  output[i] = input_num;
1069  }
1070  return c;
1071 }
1072 
1073 // clang-format off
1074 /*
1075  UDTF: ct_templated_no_cursor_user_constant_sizer__gpu_template(T, ConstantParameter c) -> Column<T> output, T=[int32_t, float]
1076 */
1077 // clang-format on
1078 
1079 template <typename T>
1080 TEMPLATE_NOINLINE int32_t
1081 ct_templated_no_cursor_user_constant_sizer__gpu_template(const T input_num,
1082  int32_t c,
1083  Column<T>& output) {
1084  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
1085  int32_t step = blockDim.x * gridDim.x;
1086 
1087  for (int32_t i = start; i < c; i += step) {
1088  output[i] = input_num;
1089  }
1090  return c;
1091 }
1092 
1093 #endif //__CUDACC__
1094 
1095 template <typename T>
1096 T safe_addition(T x, T y) {
1097  if (x >= 0) {
1098  if (y > (std::numeric_limits<T>::max() - x)) {
1099  throw std::overflow_error("Addition overflow detected");
1100  }
1101  } else {
1102  if (y < (std::numeric_limits<T>::min() - x)) {
1103  throw std::underflow_error("Addition underflow detected");
1104  }
1105  }
1106  return x + y;
1107 }
1108 
1109 // clang-format off
1110 /*
1111  UDTF: column_list_safe_row_sum__cpu_template(Cursor<ColumnList<T>>) -> Column<T>, T=[int32_t, int64_t, float, double]
1112 */
1113 // clang-format on
1114 
1115 #ifndef __CUDACC__
1116 
1117 template <typename T>
1118 NEVER_INLINE HOST int32_t
1119 column_list_safe_row_sum__cpu_template(const ColumnList<T>& input, Column<T>& out) {
1120  int32_t output_num_rows = input.numCols();
1121  set_output_row_size(output_num_rows);
1122  for (int i = 0; i < output_num_rows; i++) {
1123  auto col = input[i];
1124  T s = 0;
1125  for (int j = 0; j < col.size(); j++) {
1126  try {
1127  s = safe_addition(s, col[j]);
1128  } catch (const std::exception& e) {
1129  return TABLE_FUNCTION_ERROR(e.what());
1130  } catch (...) {
1131  return TABLE_FUNCTION_ERROR("Unknown error");
1132  }
1133  }
1134  out[i] = s;
1135  }
1136  return output_num_rows;
1137 }
1138 
1139 #endif // #ifndef __CUDACC__
1140 
1141 // clang-format off
1142 /*
1143  UDTF: ct_gpu_default_init__gpu_(Constant<1>) -> Column<int32_t> output_buffer
1144 */
1145 // clang-format on
1146 
1147 EXTENSION_NOINLINE int32_t ct_gpu_default_init__gpu_(Column<int32_t>& output_buffer) {
1148  // output_buffer[0] should always be 0 due to default initialization for GPU
1149  return 1;
1150 }
1151 
1152 // clang-format off
1153 /*
1154  UDTF: ct_hamming_distance(TextEncodingNone, TextEncodingNone, Constant<1>) -> Column<int32_t> hamming_distance
1155 */
1156 // clang-format on
1157 
1158 EXTENSION_NOINLINE int32_t ct_hamming_distance(const TextEncodingNone& str1,
1159  const TextEncodingNone& str2,
1160  Column<int32_t>& hamming_distance) {
1161  const int32_t str_len = str1.size() <= str2.size() ? str1.size() : str2.size();
1162 
1163 #ifdef __CUDACC__
1164  const int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
1165  const int32_t step = blockDim.x * gridDim.x;
1166  int32_t* output_ptr = hamming_distance.ptr_;
1167 #else
1168  const int32_t start = 0;
1169  const int32_t step = 1;
1170 #endif
1171 
1172  int32_t num_chars_unequal = 0;
1173  for (int32_t i = start; i < str_len; i += step) {
1174  num_chars_unequal += (str1[i] != str2[i]) ? 1 : 0;
1175  }
1176 #ifdef __CUDACC__
1177  atomicAdd(output_ptr, num_chars_unequal);
1178 #else
1179  hamming_distance[0] = num_chars_unequal;
1180 #endif
1181  return 1;
1182 }
1183 
1184 // clang-format off
1185 /*
1186  UDTF: ct_get_string_chars__template(Column<T>, TextEncodingNone, RowMultiplier) -> Column<int32_t> idx, Column<int8_t> char_bytes, T=[int16_t, int32_t]
1187 */
1188 // clang-format on
1189 template <typename T>
1190 TEMPLATE_NOINLINE int32_t ct_get_string_chars__template(const Column<T>& indices,
1191  const TextEncodingNone& str,
1192  const int32_t multiplier,
1193  Column<int32_t>& idx,
1194  Column<int8_t>& char_bytes) {
1195  const int32_t str_len = str.size();
1196  // Note: we assume RowMultiplier is 1 for this test, was to make running on
1197  // GPU easy Todo: Provide Constant RowMultiplier interface
1198  if (multiplier != 1) {
1199  return 0;
1200  }
1201  const int32_t num_input_rows = indices.size();
1202  const int32_t num_output_rows = num_input_rows * multiplier;
1203 
1204 #ifdef __CUDACC__
1205  const int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
1206  const int32_t step = blockDim.x * gridDim.x;
1207 #else
1208  const int32_t start = 0;
1209  const int32_t step = 1;
1210 #endif
1211 
1212  for (int32_t i = start; i < num_output_rows; i += step) {
1213  idx[i] = indices[i % num_output_rows];
1214  char_bytes[i] = str[i % str_len]; // index < str_len ? str[i] : 0;
1215  }
1216  return num_output_rows;
1217 }
1218 
1219 #ifndef __CUDACC__
1220 
1221 #include <iostream>
1222 #include <string>
1223 
1224 // clang-format off
1225 /*
1226  UDTF: ct_string_to_chars__cpu_(TextEncodingNone) -> Column<int32_t> char_idx, Column<int8_t> char_bytes
1227 */
1228 // clang-format on
1229 
1230 EXTENSION_NOINLINE_HOST int32_t ct_string_to_chars__cpu_(const TextEncodingNone& input,
1231  Column<int32_t>& char_idx,
1232  Column<int8_t>& char_bytes) {
1233  const std::string str{input.getString()};
1234  const int64_t str_size(str.size());
1235  set_output_row_size(str_size);
1236  for (int32_t i = 0; i < str_size; ++i) {
1237  char_idx[i] = i;
1238  char_bytes[i] = str[i];
1239  }
1240  return str_size;
1241 }
1242 
1243 // clang-format off
1244 /*
1245  The purpose of ct_sleep1 and ct_sleep2 is to test parallel execution
1246  of UDTFs (use --num-executors=..). For instance, ct_sleep1 output
1247  column buffers are managed by a global manager, hence, ct_sleep1 can
1248  be run only sequentially. However, ct_sleep2 output column buffers
1249  are managed with a thread-safe manager instance, hence, ct_sleep2
1250  can be run in parallel.
1251 
1252  UDTF: ct_sleep1__cpu_(int32_t seconds, int32_t mode) -> Column<int32_t> output
1253  UDTF: ct_sleep2(TableFunctionManager, int32_t seconds, int32_t mode) -> Column<int32_t> output
1254 
1255  Here mode argument is used to test various approaches of accessing
1256  the table function manager:
1257 
1258  - mode == 0
1259  ct_sleep1 uses global set_output_row_size function
1260  ct_sleep2 uses thread-safe set_output_row_size method
1261 
1262  - mode == 1
1263  ct_sleep1 retrieves global singleton manager and uses its set_output_row_size method
1264  ct_sleep2 same as in mode == 1
1265 
1266  - mode == 2
1267  ct_sleep1 does not call set_output_row_size function, expect error return
1268  ct_sleep2 does not call set_output_row_size method, expect error return
1269 
1270  - mode == 3
1271  ct_sleep1 same as mode == 2
1272  ct_sleep2 calls global set_output_row_size function, expect error return
1273 */
1274 // clang-format on
1275 EXTENSION_NOINLINE int32_t ct_sleep_worker(int32_t seconds, Column<int32_t>& output) {
1276  // save entering time
1277  output[0] = std::chrono::duration_cast<std::chrono::milliseconds>(
1278  std::chrono::system_clock::now().time_since_epoch())
1279  .count() &
1280  0xffffff;
1281  // store thread id info
1282  output[2] = std::hash<std::thread::id>()(std::this_thread::get_id()) & 0xffff;
1283  // do "computations" for given seconds
1284  std::this_thread::sleep_for(std::chrono::seconds(seconds));
1285  // save leaving time
1286  output[1] = std::chrono::duration_cast<std::chrono::milliseconds>(
1287  std::chrono::system_clock::now().time_since_epoch())
1288  .count() &
1289  0xffffff;
1290  return 3;
1291 }
1292 
1293 EXTENSION_NOINLINE_HOST int32_t ct_sleep1__cpu_(int32_t seconds,
1294  int32_t mode,
1295  Column<int32_t>& output) {
1296  switch (mode) {
1297  case 0: {
1298  set_output_row_size(3); // uses global singleton of TableFunctionManager
1299  break;
1300  }
1301  case 1: {
1302  auto* mgr = TableFunctionManager::get_singleton();
1303  mgr->set_output_row_size(3);
1304  break;
1305  }
1306  case 2:
1307  case 3: {
1308  break;
1309  }
1310  default:
1311  return TABLE_FUNCTION_ERROR("unexpected mode");
1312  }
1313  if (output.size() == 0) {
1314  return TABLE_FUNCTION_ERROR("unspecified output columns row size");
1315  }
1316  return ct_sleep_worker(seconds, output);
1317 }
1318 
1319 EXTENSION_NOINLINE_HOST int32_t ct_sleep2(TableFunctionManager& mgr,
1320  int32_t seconds,
1321  int32_t mode,
1322  Column<int32_t>& output) {
1323  switch (mode) {
1324  case 0:
1325  case 1: {
1326  mgr.set_output_row_size(3); // uses thread-safe TableFunctionManager instance
1327  break;
1328  }
1329  case 2: {
1330  break;
1331  }
1332  case 3: {
1333  try {
1334  auto* mgr0 = TableFunctionManager::get_singleton(); // it may throw "singleton is
1335  // not initialized"
1336  mgr0->set_output_row_size(3);
1337  } catch (std::exception& e) {
1338  return mgr.ERROR_MESSAGE(e.what());
1339  }
1340  break;
1341  }
1342  default:
1343  return mgr.ERROR_MESSAGE("unexpected mode");
1344  }
1345  if (output.size() == 0) {
1346  return mgr.ERROR_MESSAGE("unspecified output columns row size");
1347  }
1348  return ct_sleep_worker(seconds, output);
1349 }
1350 
1351 // clang-format off
1352 /*
1353  UDTF: ct_throw_if_gt_100__cpu_template(TableFunctionManager, Column<T>) -> Column<T> val, T=[float, double]
1354 */
1355 // clang-format on
1356 
1357 template <typename T>
1358 NEVER_INLINE HOST int32_t ct_throw_if_gt_100__cpu_template(TableFunctionManager& mgr,
1359  const Column<T>& input,
1360  Column<T>& output) {
1361  int64_t num_rows = input.size();
1362  mgr.set_output_row_size(num_rows);
1363  for (int64_t r = 0; r < num_rows; ++r) {
1364  if (input[r] > 100) {
1365  return mgr.ERROR_MESSAGE("Values greater than 100 not allowed");
1366  }
1367  output[r] = input[r];
1368  }
1369  return num_rows;
1370 }
1371 
1372 // clang-format off
1373 /*
1374  The following UDTFs are used to test an optimization rule that moves
1375  filters on UDTF outputs to the inputs when the names of outputs and
1376  input arguments match in the UDTF signatures. This optimization
1377  makes sense only if filters and table functions are commutative with
1378  respect to the corresponding input and output arguments:
1379 
1380  filter(udtf(..., input[j], ...)[i]) == udtf(..., filter(input[j]), ...)[i]
1381 
1382  The UDTFs below invalidate this requirement for the purpose of
1383  testing the feature: the result will depend on whether the
1384  optimization is enabled or not.
1385 
1386  UDTF: ct_copy_and_add_size(TableFunctionManager, Cursor<Column<int32_t> x>) | filter_table_function_transpose=on -> Column<int32_t> x
1387  UDTF: ct_add_size_and_mul_alpha(TableFunctionManager, Cursor<Column<int32_t>, Column<int32_t>> | fields=[x, x2], int32_t alpha) | filter_table_function_transpose=on -> Column<int32_t> x, Column<int32_t> x2
1388 
1389  UDTF: ct_sparse_add(TableFunctionManager, Cursor<Column<int32_t> x, Column<int32_t> d1>, int32_t f1, Cursor<Column<int32_t> x, Column<int32_t> d2>, int32_t f2) | filter_table_function_transpose=on -> Column<int32_t> x, Column<int32_t> d
1390 */
1391 // clang-format on
1392 
1393 EXTENSION_NOINLINE_HOST int32_t ct_copy_and_add_size(TableFunctionManager& mgr,
1394  const Column<int32_t>& input,
1395  Column<int32_t>& output) {
1396  mgr.set_output_row_size(input.size());
1397  for (int32_t i = 0; i < input.size(); i++) {
1398  output[i] = input[i] + input.size();
1399  }
1400  return output.size();
1401 }
1402 
1403 EXTENSION_NOINLINE_HOST int32_t ct_add_size_and_mul_alpha(TableFunctionManager& mgr,
1404  const Column<int32_t>& input1,
1405  const Column<int32_t>& input2,
1406  int32_t alpha,
1407  Column<int32_t>& output1,
1408  Column<int32_t>& output2) {
1409  auto size = input1.size();
1410  mgr.set_output_row_size(size);
1411  for (int32_t i = 0; i < size; i++) {
1412  output1[i] = input1[i] + size;
1413  output2[i] = input2[i] * alpha;
1414  }
1415  return size;
1416 }
1417 
1418 /*
1419  Add two sparse graphs given by pairs of coordinates and the
1420  corresponding values and multiply with the size of output
1421  columns. Unspecified points are assumed to have the specified fill
1422  value.
1423 */
1424 
1425 EXTENSION_NOINLINE_HOST int32_t ct_sparse_add(TableFunctionManager& mgr,
1426  const Column<int32_t>& x1,
1427  const Column<int32_t>& d1,
1428  int32_t f1,
1429  const Column<int32_t>& x2,
1430  const Column<int32_t>& d2,
1431  int32_t f2,
1432  Column<int32_t>& x,
1433  Column<int32_t>& d) {
1434  // sorted set of common coordinates:
1435  std::set<int32_t, std::less<int32_t>> x12;
1436  // inverse map of coordinates and indices, keys are sorted:
1437  std::map<int32_t, int32_t, std::less<int32_t>> i1, i2;
1438 
1439  for (int32_t i = 0; i < x1.size(); i++) {
1440  i1[x1[i]] = i;
1441  x12.insert(x1[i]);
1442  }
1443  for (int32_t i = 0; i < x2.size(); i++) {
1444  i2[x2[i]] = i;
1445  x12.insert(x2[i]);
1446  }
1447  auto size = x12.size();
1448 
1449  mgr.set_output_row_size(size);
1450  int32_t k = 0;
1451  for (auto x_ : x12) {
1452  x[k] = x_;
1453  auto i1_ = i1.find(x_);
1454  auto i2_ = i2.find(x_);
1455  if (i1_ != i1.end()) {
1456  if (i2_ != i2.end()) {
1457  d[k] = d1[i1_->second] + d2[i2_->second];
1458  } else {
1459  d[k] = d1[i1_->second] + f2;
1460  }
1461  } else if (i2_ != i2.end()) {
1462  d[k] = f1 + d2[i2_->second];
1463  } else {
1464  d[k] = f1 + f2;
1465  }
1466  d[k] *= size;
1467  k++;
1468  }
1469  return size;
1470 }
1471 
1472 #endif // #ifndef __CUDACC__
1473 
1474 enum TFAggType { MIN, MAX };
1475 
1476 template <typename T>
1477 TEMPLATE_INLINE T get_min_or_max(const Column<T>& col, const TFAggType min_or_max) {
1478  const auto input_min_max = get_column_min_max(col);
1479  if (min_or_max == TFAggType::MIN) {
1480  return input_min_max.first;
1481  }
1482  return input_min_max.second;
1483 }
1484 
1485 template <typename T>
1486 TEMPLATE_INLINE T get_min_or_max_union(const Column<T>& col1,
1487  const Column<T>& col2,
1488  const TFAggType min_or_max) {
1489  const auto input1_min_max = get_column_min_max(col1);
1490  const auto input2_min_max = get_column_min_max(col2);
1491  if (min_or_max == TFAggType::MIN) {
1492  return input1_min_max.first < input2_min_max.first ? input1_min_max.first
1493  : input2_min_max.first;
1494  }
1495  return input1_min_max.second > input2_min_max.second ? input1_min_max.second
1496  : input2_min_max.second;
1497 }
1498 
1499 // clang-format off
1500 /*
1501  UDTF: ct_pushdown_stats__cpu_template(TableFunctionManager, TextEncodingNone agg_type, Cursor<Column<K> id, Column<T> x, Column<T> y, Column<Z> z>) | filter_table_function_transpose=on -> Column<int32_t> row_count, Column<K> id | input_id=args<0>, Column<T> x, Column<T> y, Column<Z> z, K=[int32_t, int64_t, TextEncodingDict], T=[int32_t, int64_t, float, double], Z=[int32_t, int64_t, float, double]
1502 */
1503 // clang-format on
1504 
1505 #ifndef __CUDACC__
1506 
1507 template <typename K, typename T, typename Z>
1508 NEVER_INLINE HOST int32_t
1509 ct_pushdown_stats__cpu_template(TableFunctionManager& mgr,
1510  const TextEncodingNone& agg_type,
1511  const Column<K>& input_id,
1512  const Column<T>& input_x,
1513  const Column<T>& input_y,
1514  const Column<Z>& input_z,
1515  Column<int32_t>& output_row_count,
1516  Column<K>& output_id,
1517  Column<T>& output_x,
1518  Column<T>& output_y,
1519  Column<Z>& output_z) {
1520  const std::string agg_type_str = agg_type.getString();
1521  const TFAggType min_or_max = agg_type_str == "MIN" ? TFAggType::MIN : TFAggType::MAX;
1522  mgr.set_output_row_size(1);
1523  output_row_count[0] = input_id.size();
1524  output_id[0] = get_min_or_max(input_id, min_or_max);
1525  output_x[0] = get_min_or_max(input_x, min_or_max);
1526  output_y[0] = get_min_or_max(input_y, min_or_max);
1527  output_z[0] = get_min_or_max(input_z, min_or_max);
1528  return 1;
1529 }
1530 
1531 #endif // #ifndef __CUDACC__
1532 
1533 // clang-format off
1534 /*
1535  UDTF: ct_pushdown_projection__cpu_template(TableFunctionManager, Cursor<Column<K> id, Column<T> x, Column<T> y, Column<Z> z>) | filter_table_function_transpose=on -> Column<K> id | input_id=args<0>, Column<T> x, Column<T> y, Column<Z> z, K=[int32_t, int64_t, TextEncodingDict], T=[int32_t, int64_t, float, double], Z=[int32_t, int64_t, float, double]
1536 */
1537 // clang-format on
1538 
1539 #ifndef __CUDACC__
1540 
1541 template <typename K, typename T, typename Z>
1542 NEVER_INLINE HOST int32_t ct_pushdown_projection__cpu_template(TableFunctionManager& mgr,
1543  const Column<K>& input_id,
1544  const Column<T>& input_x,
1545  const Column<T>& input_y,
1546  const Column<Z>& input_z,
1547  Column<K>& output_id,
1548  Column<T>& output_x,
1549  Column<T>& output_y,
1550  Column<Z>& output_z) {
1551  const int64_t input_size = input_id.size();
1552  mgr.set_output_row_size(input_size);
1553  for (int64_t input_idx = 0; input_idx < input_size; ++input_idx) {
1554  output_id[input_idx] = input_id[input_idx];
1555  output_x[input_idx] = input_x[input_idx];
1556  output_y[input_idx] = input_y[input_idx];
1557  output_z[input_idx] = input_z[input_idx];
1558  }
1559  return input_size;
1560 }
1561 
1562 #endif // #ifndef __CUDACC__
1563 
1564 // clang-format off
1565 /*
1566  UDTF: ct_union_pushdown_stats__cpu_template(TableFunctionManager, TextEncodingNone agg_type, Cursor<Column<K> id, Column<T> x, Column<T> y, Column<Z> z>, Cursor<Column<K> id, Column<T> x, Column<T> y, Column<Z> z, Column<T> w>) | filter_table_function_transpose=on -> Column<int32_t> row_count, Column<K> id | input_id=args<0, 0>, Column<T> x, Column<T> y, Column<Z> z, Column<T> w, K=[int32_t, int64_t, TextEncodingDict], T=[int32_t, int64_t, float, double], Z=[int32_t, int64_t, float, double]
1567 */
1568 // clang-format on
1569 
1570 #ifndef __CUDACC__
1571 
1572 template <typename K, typename T, typename Z>
1573 NEVER_INLINE HOST int32_t
1574 ct_union_pushdown_stats__cpu_template(TableFunctionManager& mgr,
1575  const TextEncodingNone& agg_type,
1576  const Column<K>& input1_id,
1577  const Column<T>& input1_x,
1578  const Column<T>& input1_y,
1579  const Column<Z>& input1_z,
1580  const Column<K>& input2_id,
1581  const Column<T>& input2_x,
1582  const Column<T>& input2_y,
1583  const Column<Z>& input2_z,
1584  const Column<T>& input2_w,
1585  Column<int32_t>& output_row_count,
1586  Column<K>& output_id,
1587  Column<T>& output_x,
1588  Column<T>& output_y,
1589  Column<Z>& output_z,
1590  Column<T>& output_w) {
1591  mgr.set_output_row_size(1);
1592  const std::string agg_type_str = agg_type.getString();
1593  const TFAggType min_or_max = agg_type_str == "MIN" ? TFAggType::MIN : TFAggType::MAX;
1594  output_row_count[0] = input1_id.size() + input2_id.size();
1595  output_id[0] = get_min_or_max_union(input1_id, input2_id, min_or_max);
1596  output_x[0] = get_min_or_max_union(input1_x, input2_x, min_or_max);
1597  output_y[0] = get_min_or_max_union(input1_y, input2_y, min_or_max);
1598  output_z[0] = get_min_or_max_union(input1_z, input2_z, min_or_max);
1599  if (input2_w.size() > 0) {
1600  const auto w_min_max = get_column_min_max(input2_w);
1601  output_w[0] = agg_type_str == "MIN" ? w_min_max.first : w_min_max.second;
1602  } else {
1603  output_w.setNull(0);
1604  }
1605  return 1;
1606 }
1607 
1608 #endif // #ifndef __CUDACC__
1609 
1610 // clang-format off
1611 /*
1612  UDTF: ct_union_pushdown_projection__cpu_template(TableFunctionManager, Cursor<Column<K> id, Column<T> x, Column<T> y, Column<Z> z>, Cursor<Column<K> id, Column<T> x, Column<T> y, Column<Z> z, Column<T> w>) | filter_table_function_transpose=on -> Column<K> id | input_id=args<0, 0>, Column<T> x, Column<T> y, Column<Z> z, Column<T> w, K=[int32_t, int64_t, TextEncodingDict], T=[int32_t, int64_t, float, double], Z=[int32_t, int64_t, float, double]
1613 */
1614 // clang-format on
1615 
1616 #ifndef __CUDACC__
1617 
1618 template <typename K, typename T, typename Z>
1619 NEVER_INLINE HOST int32_t
1620 ct_union_pushdown_projection__cpu_template(TableFunctionManager& mgr,
1621  const Column<K>& input1_id,
1622  const Column<T>& input1_x,
1623  const Column<T>& input1_y,
1624  const Column<Z>& input1_z,
1625  const Column<K>& input2_id,
1626  const Column<T>& input2_x,
1627  const Column<T>& input2_y,
1628  const Column<Z>& input2_z,
1629  const Column<T>& input2_w,
1630  Column<K>& output_id,
1631  Column<T>& output_x,
1632  Column<T>& output_y,
1633  Column<Z>& output_z,
1634  Column<T>& output_w) {
1635  const int64_t input1_size = input1_id.size();
1636  const int64_t input2_size = input2_id.size();
1637  int64_t output_size = input1_size + input2_size;
1638  mgr.set_output_row_size(output_size);
1639  for (int64_t input1_idx = 0; input1_idx < input1_size; ++input1_idx) {
1640  output_id[input1_idx] = input1_id[input1_idx];
1641  output_x[input1_idx] = input1_x[input1_idx];
1642  output_y[input1_idx] = input1_y[input1_idx];
1643  output_z[input1_idx] = input1_z[input1_idx];
1644  output_w.setNull(input1_idx);
1645  }
1646  for (int64_t input2_idx = 0; input2_idx < input2_size; ++input2_idx) {
1647  output_id[input1_size + input2_idx] = input2_id[input2_idx];
1648  output_x[input1_size + input2_idx] = input2_x[input2_idx];
1649  output_y[input1_size + input2_idx] = input2_y[input2_idx];
1650  output_z[input1_size + input2_idx] = input2_z[input2_idx];
1651  output_w[input1_size + input2_idx] = input2_w[input2_idx];
1652  }
1653  return output_size;
1654 }
1655 
1656 #endif // #ifndef __CUDACC__
1657 
1658 // clang-format off
1659 /*
1660  UDTF: ct_require__cpu_(Column<int32_t>, int | name=i | require="i > 0") -> Column<int32_t>
1661  UDTF: ct_require_mgr(TableFunctionManager, Column<int32_t>, int i | require="i > 1" | require="i < 5") -> Column<int32_t>
1662  UDTF: ct_require_str__cpu_(Column<int32_t>, TextEncodingNone s | require="s == \"hello\"") -> Column<int32_t>
1663  UDTF: ct_require_templating__cpu_template(Column<T>, int i | require="i > 0") -> Column<K>, T=[int, double], K=[int]
1664  UDTF: ct_require_and__cpu_(Column<int>, int i | require="i > 0 && i < 5") -> Column<int>
1665  UDTF: ct_require_or_str__cpu_(Column<int>, TextEncodingNone i | require="i == \"MAX\" || i == \"MIN\"") -> Column<int>
1666  UDTF: ct_require_str_diff__cpu_(Column<int>, TextEncodingNone i | require="i != \"MAX\"") -> Column<int>
1667  UDTF: ct_require_text_enc_dict__cpu_(Cursor<Column<TextEncodingDict>>, int64_t x | require="x >= 1") -> Column<int64_t>
1668 */
1669 // clang-format on
1670 
1671 #ifndef __CUDACC__
1672 
1673 EXTENSION_NOINLINE_HOST int32_t ct_require__cpu_(const Column<int32_t>& input1,
1674  const int32_t i,
1675  Column<int32_t>& out) {
1676  set_output_row_size(1);
1677  out[0] = 3;
1678  return 1;
1679 }
1680 
1681 EXTENSION_NOINLINE_HOST int32_t ct_require_str__cpu_(const Column<int32_t>& input1,
1682  const TextEncodingNone& s,
1683  Column<int32_t>& out) {
1684  set_output_row_size(1);
1685  out[0] = 3;
1686  return 1;
1687 }
1688 
1689 EXTENSION_NOINLINE_HOST int32_t ct_require_mgr(TableFunctionManager& mgr,
1690  const Column<int32_t>& input1,
1691  const int32_t i,
1692  Column<int32_t>& out) {
1693  set_output_row_size(1);
1694  out[0] = 4;
1695  return 1;
1696 }
1697 
1698 template <typename T, typename K>
1699 NEVER_INLINE HOST int32_t ct_require_templating__cpu_template(const Column<T>& input1,
1700  const int32_t i,
1701  Column<K>& out) {
1702  set_output_row_size(1);
1703  if constexpr (std::is_same<T, int32_t>::value) {
1704  out[0] = 5;
1705  } else if constexpr (std::is_same<T, double>::value) {
1706  out[0] = 6.0;
1707  }
1708  return 1;
1709 }
1710 
1711 EXTENSION_NOINLINE_HOST int32_t ct_require_and__cpu_(const Column<int32_t>& input1,
1712  const int32_t i,
1713  Column<int32_t>& out) {
1714  set_output_row_size(1);
1715  out[0] = 7;
1716  return 1;
1717 }
1718 
1719 EXTENSION_NOINLINE_HOST int32_t ct_require_or_str__cpu_(const Column<int32_t>& input1,
1720  const TextEncodingNone& i,
1721  Column<int32_t>& out) {
1722  set_output_row_size(1);
1723  out[0] = 8;
1724  return 1;
1725 }
1726 
1727 EXTENSION_NOINLINE_HOST int32_t ct_require_str_diff__cpu_(const Column<int32_t>& input1,
1728  const TextEncodingNone& i,
1729  Column<int32_t>& out) {
1730  set_output_row_size(1);
1731  out[0] = 9;
1732  return 1;
1733 }
1734 
1735 EXTENSION_NOINLINE_HOST int32_t
1736 ct_require_text_enc_dict__cpu_(const Column<TextEncodingDict>& input,
1737  const int64_t x,
1738  Column<int64_t>& out) {
1739  set_output_row_size(1);
1740  out[0] = 10;
1741  return 1;
1742 }
1743 
1744 #endif // #ifndef __CUDACC__
1745 
1746 #ifdef __CUDACC__
1747 
1748 // clang-format off
1749 /*
1750  UDTF: ct_require_device_cuda__gpu_(Column<int32_t>, Constant<1>, int | name=i | require="i > 0") -> Column<int32_t>
1751 */
1752 // clang-format on
1753 
1754 EXTENSION_NOINLINE int32_t ct_require_device_cuda__gpu_(const Column<int32_t>& input1,
1755  const int32_t i,
1756  Column<int32_t>& out) {
1757  out[0] = (i > 0 ? 12345 : 54321);
1758  return 1;
1759 }
1760 
1761 // clang-format off
1762 /*
1763  UDTF: ct_cuda_enumerate_threads__gpu_(ConstantParameter output_size) -> Column<int32_t> local_thread_id, Column<int32_t> block_id, Column<int32_t> global_thread_id
1764 */
1765 // clang-format on
1766 
1767 EXTENSION_NOINLINE int32_t
1768 ct_cuda_enumerate_threads__gpu_(const int32_t output_size,
1769  Column<int32_t>& out_local_thread_id,
1770  Column<int32_t>& out_block_id,
1771  Column<int32_t>& out_global_thread_id) {
1772  int32_t local_thread_id = threadIdx.x;
1773  int32_t block_id = blockIdx.x;
1774  int32_t global_thread_id = threadIdx.x + blockDim.x * blockIdx.x;
1775  out_local_thread_id[global_thread_id] = local_thread_id;
1776  out_block_id[global_thread_id] = block_id;
1777  out_global_thread_id[global_thread_id] = global_thread_id;
1778  return output_size;
1779 }
1780 
1781 #endif //__CUDACC__
1782 
1783 // clang-format off
1784 /*
1785  UDTF: ct_test_nullable(Column<int32_t>, RowMultiplier) -> Column<int32_t>
1786 */
1787 // clang-format on
1788 
1789 EXTENSION_NOINLINE int32_t ct_test_nullable(const Column<int32_t>& input,
1790  const int32_t i,
1791  Column<int32_t>& out) {
1792  for (int i = 0; i < input.size(); i++) {
1793  if (i % 2 == 0) {
1794  out.setNull(i);
1795  } else {
1796  out[i] = input[i];
1797  }
1798  }
1799  return input.size();
1800 }
1801 
1802 // clang-format off
1803 /*
1804  UDTF: ct_test_preflight_sizer(Column<int32_t> col, int i, int j) -> Column<int32_t> | output_row_size="i + j"
1805  UDTF: ct_test_preflight_sizer_const(Column<int32_t> col) -> Column<int32_t> | output_row_size=2
1806 */
1807 // clang-format on
1808 
1809 EXTENSION_NOINLINE int32_t ct_test_preflight_sizer(const Column<int32_t>& input,
1810  const int32_t i,
1811  const int32_t j,
1812  Column<int32_t>& out) {
1813  out[0] = 123;
1814  out[1] = 456;
1815  return out.size();
1816 }
1817 
1818 EXTENSION_NOINLINE int32_t ct_test_preflight_sizer_const(const Column<int32_t>& input,
1819  Column<int32_t>& out) {
1820  out[0] = 789;
1821  out[1] = 321;
1822  return out.size();
1823 }
1824 
1825 #ifndef __CUDACC__
1826 
1827 // clang-format off
1828 /*
1829  UDTF: ct_test_preflight_singlecursor_qe227__cpu_(TableFunctionManager,
1830  Cursor<Column<int32_t> col, ColumnList<int32_t> lst>,
1831  int32_t x, int32_t y | require="x > 0" | require="y > 0") ->
1832  Column<int32_t> out
1833  */
1834 // clang-format on
1835 
1836 EXTENSION_NOINLINE int32_t
1837 ct_test_preflight_singlecursor_qe227__cpu_(TableFunctionManager& mgr,
1838  const Column<int32_t>& col,
1839  const ColumnList<int32_t>& lst,
1840  const int x,
1841  const int y,
1842  Column<int32_t>& out) {
1843  mgr.set_output_row_size(lst.numCols() + 1);
1844  out[0] = col[0];
1845  for (int i = 0; i < lst.numCols(); i++) {
1846  out[i + 1] = lst[i][0];
1847  }
1848  return out.size();
1849 }
1850 
1851 // clang-format off
1852 /*
1853  UDTF: ct_test_preflight_multicursor_qe227__cpu_(TableFunctionManager,
1854  Column<int32_t> col, ColumnList<int32_t> lst,
1855  int32_t x, int32_t y | require="x > 0" | require="y > 0") ->
1856  Column<int32_t> out
1857  */
1858 // clang-format on
1859 
1860 EXTENSION_NOINLINE int32_t
1861 ct_test_preflight_multicursor_qe227__cpu_(TableFunctionManager& mgr,
1862  const Column<int32_t>& col,
1863  const ColumnList<int32_t>& lst,
1864  const int x,
1865  const int y,
1866  Column<int32_t>& out) {
1867  mgr.set_output_row_size(lst.numCols() + 1);
1868  out[0] = col[1];
1869  for (int i = 0; i < lst.numCols(); i++) {
1870  out[i + 1] = lst[i][1];
1871  }
1872  return out.size();
1873 }
1874 
1875 // clang-format off
1876 /*
1877  UDTF: ct_scalar_named_args__cpu_(TableFunctionManager, int32_t arg1, int32_t arg2) ->
1878  Column<int32_t> out1, Column<int32_t> out2
1879 */
1880 
1881 EXTENSION_NOINLINE_HOST int32_t
1882 ct_scalar_named_args__cpu_(TableFunctionManager& mgr, const int32_t arg1,
1883  const int32_t arg2, Column<int32_t>& out1, Column<int32_t>& out2) {
1884  mgr.set_output_row_size(1);
1885  out1[0] = arg1;
1886  out2[0] = arg2;
1887  return 1;
1888  }
1889 
1890 // clang-format off
1891 /*
1892  UDTF: ct_cursor_named_args__cpu_(TableFunctionManager, Cursor<Column<int32_t> input_table_arg1,
1893  Column<int32_t> input_table_arg2> input_table, int32_t arg1, int32_t arg2) ->
1894  Column<int32_t> out1, Column<int32_t> out2
1895 */
1896 
1897 EXTENSION_NOINLINE_HOST int32_t
1898 ct_cursor_named_args__cpu_(TableFunctionManager& mgr, const Column<int32_t>& input_arg1,
1899 const Column<int32_t>& input_arg2, const int32_t arg1, const int32_t arg2,
1900  Column<int32_t>& out1, Column<int32_t>& out2) {
1901  const int32_t num_rows = input_arg1.size();
1902  mgr.set_output_row_size(num_rows);
1903  for (int32_t r = 0; r < num_rows; ++r) {
1904  out1[r] = input_arg1[r] + arg1;
1905  out2[r] = input_arg2[r] + arg2;
1906  }
1907  return num_rows;
1908 }
1909 
1910 #endif
1911 
1912 #ifndef __CUDACC__
1913 
1914 // clang-format off
1915 /*
1916  UDTF: ct_timestamp_extract(TableFunctionManager, Column<Timestamp>) -> Column<int64_t> ns, Column<int64_t> us, Column<int64_t> ms, Column<int64_t> s, Column<int64_t> m, Column<int64_t> h, Column<int64_t> d, Column<int64_t> mo, Column<int64_t> y
1917  UDTF: ct_timestamp_add_offset(TableFunctionManager, Column<Timestamp>, Timestamp) -> Column<Timestamp>
1918  UDTF: ct_timestamp_test_columns_and_scalars__cpu(Column<Timestamp>, int64_t, RowMultiplier, Column<Timestamp>) -> Column<Timestamp>
1919  UDTF: ct_timestamp_column_list_input(TableFunctionManager, ColumnList<int64_t>, Column<Timestamp>) -> Column<Timestamp>
1920  UDTF: ct_timestamp_truncate(TableFunctionManager, Column<Timestamp>) -> Column<Timestamp> y, Column<Timestamp> mo, Column<Timestamp> d, Column<Timestamp> h, Column<Timestamp> m, Column<Timestamp> s, Column<Timestamp> ms, Column<Timestamp> us
1921  UDTF: ct_timestamp_add_interval__template(TableFunctionManager, Column<Timestamp>, T) -> Column<Timestamp>, T=[YearMonthTimeInterval, DayTimeInterval]
1922 */
1923 // clang-format on
1924 
1925 // Test table functions with Timestamp Column inputs
1926 // and Timestamp type helper functions
1927 EXTENSION_NOINLINE_HOST int32_t ct_timestamp_extract(TableFunctionManager& mgr,
1928  const Column<Timestamp>& input,
1929  Column<int64_t>& ns,
1930  Column<int64_t>& us,
1931  Column<int64_t>& ms,
1932  Column<int64_t>& s,
1933  Column<int64_t>& m,
1934  Column<int64_t>& h,
1935  Column<int64_t>& d,
1936  Column<int64_t>& mo,
1937  Column<int64_t>& y) {
1938  int size = input.size();
1939  mgr.set_output_row_size(size);
1940  for (int i = 0; i < size; ++i) {
1941  if (input.isNull(i)) {
1942  ns.setNull(i);
1943  us.setNull(i);
1944  ms.setNull(i);
1945  s.setNull(i);
1946  m.setNull(i);
1947  h.setNull(i);
1948  d.setNull(i);
1949  mo.setNull(i);
1950  y.setNull(i);
1951  } else {
1952  ns[i] = input[i].getNanoseconds();
1953  us[i] = input[i].getMicroseconds();
1954  ms[i] = input[i].getMilliseconds();
1955  s[i] = input[i].getSeconds();
1956  m[i] = input[i].getMinutes();
1957  h[i] = input[i].getHours();
1958  d[i] = input[i].getDay();
1959  mo[i] = input[i].getMonth();
1960  y[i] = input[i].getYear();
1961  }
1962  }
1963  return size;
1964 }
1965 
1966 // Test table functions with scalar Timestamp inputs
1967 EXTENSION_NOINLINE_HOST int32_t ct_timestamp_add_offset(TableFunctionManager& mgr,
1968  const Column<Timestamp>& input,
1969  const Timestamp offset,
1970  Column<Timestamp>& out) {
1971  int size = input.size();
1972  mgr.set_output_row_size(size);
1973  for (int i = 0; i < size; ++i) {
1974  if (input.isNull(i)) {
1975  out.setNull(i);
1976  } else {
1977  out[i] = input[i] + offset;
1978  }
1979  }
1980  return size;
1981 }
1982 
1983 // Test table function with sizer argument, and mix of scalar/column inputs.
1984 EXTENSION_NOINLINE int32_t
1985 ct_timestamp_test_columns_and_scalars__cpu(const Column<Timestamp>& input,
1986  const int64_t dummy,
1987  const int32_t multiplier,
1988  const Column<Timestamp>& input2,
1989  Column<Timestamp>& out) {
1990  int size = input.size();
1991  for (int i = 0; i < size; ++i) {
1992  if (input.isNull(i)) {
1993  out.setNull(i);
1994  } else {
1995  out[i] = input[i] + input2[i] + Timestamp(dummy);
1996  }
1997  }
1998  return size;
1999 }
2000 
2001 // Dummy test for ColumnList inputs + Column Timestamp input
2002 EXTENSION_NOINLINE_HOST int32_t
2003 ct_timestamp_column_list_input(TableFunctionManager& mgr,
2004  const ColumnList<int64_t>& input,
2005  const Column<Timestamp>& input2,
2006  Column<int64_t>& out) {
2007  mgr.set_output_row_size(1);
2008  out[0] = 1;
2009  return 1;
2010 }
2011 
2012 EXTENSION_NOINLINE_HOST int32_t ct_timestamp_truncate(TableFunctionManager& mgr,
2013  const Column<Timestamp>& input,
2014  Column<Timestamp>& y,
2015  Column<Timestamp>& mo,
2016  Column<Timestamp>& d,
2017  Column<Timestamp>& h,
2018  Column<Timestamp>& m,
2019  Column<Timestamp>& s,
2020  Column<Timestamp>& ms,
2021  Column<Timestamp>& us) {
2022  int size = input.size();
2023  mgr.set_output_row_size(size);
2024  for (int i = 0; i < size; ++i) {
2025  y[i] = input[i].truncateToYear();
2026  mo[i] = input[i].truncateToMonth();
2027  d[i] = input[i].truncateToDay();
2028  h[i] = input[i].truncateToHours();
2029  m[i] = input[i].truncateToMinutes();
2030  s[i] = input[i].truncateToSeconds();
2031  ms[i] = input[i].truncateToMilliseconds();
2032  us[i] = input[i].truncateToMicroseconds();
2033  }
2034 
2035  return size;
2036 }
2037 
2038 template <typename T>
2039 NEVER_INLINE HOST int32_t
2040 ct_timestamp_add_interval__template(TableFunctionManager& mgr,
2041  const Column<Timestamp>& input,
2042  const T inter,
2043  Column<Timestamp>& out) {
2044  int size = input.size();
2045  mgr.set_output_row_size(size);
2046  for (int i = 0; i < size; ++i) {
2047  out[i] = inter + input[i];
2048  }
2049  return size;
2050 }
2051 
2052 // clang-format off
2053 /*
2054  UDTF: sum_along_row__cpu_template(Column<Array<T>> input) -> Column<T>,
2055  T=[float, double, int8_t, int16_t, int32_t, int64_t, bool, TextEncodingDict] | output_row_size="input.size()" | input_id=args<0>
2056 */
2057 // clang-format on
2058 template <typename T>
2059 NEVER_INLINE HOST int32_t sum_along_row__cpu_template(const Column<Array<T>>& input,
2060  Column<T>& output) {
2061  int size = input.size();
2062  for (int i = 0; i < size; i++) {
2063  const Array<T> arr = input[i];
2064  if (arr.isNull()) {
2065  output.setNull(i);
2066  } else {
2067  if constexpr (std::is_same<T, TextEncodingDict>::value) {
2068  auto* mgr = TableFunctionManager::get_singleton();
2069  int32_t input_dict_id = input.getDictId();
2070  int32_t output_dict_id = output.getDictId();
2071  std::string acc = "";
2072  for (auto j = 0; j < arr.getSize(); j++) {
2073  if (!arr.isNull(j)) {
2074  acc += mgr->getString(input_dict_id, arr[j]);
2075  }
2076  }
2077  int32_t out_string_id = mgr->getOrAddTransient(output_dict_id, acc);
2078  output[i] = out_string_id;
2079  } else {
2080  T acc{0};
2081  for (auto j = 0; j < arr.getSize(); j++) {
2082  if constexpr (std::is_same_v<T, bool>) {
2083  // todo: arr.isNull(i) returns arr[i] because bool does not
2084  // have null value, we should introduce 8-bit boolean type
2085  // for Arrays
2086  acc |= arr[j];
2087  } else {
2088  if (!arr.isNull(j)) {
2089  acc += arr[j];
2090  }
2091  }
2092  }
2093  output[i] = acc;
2094  }
2095  }
2096  }
2097  return size;
2098 }
2099 
2100 // clang-format off
2101 /*
2102  UDTF: array_copier__cpu_template(TableFunctionManager mgr, Column<Array<T>> input) -> Column<Array<T>>,
2103  T=[float, double, int8_t, int16_t, int32_t, int64_t, bool]
2104  UDTF: array_copier__cpu_template(TableFunctionManager mgr, Column<Array<TextEncodingDict>> input) -> Column<Array<TextEncodingDict>> | input_id=args<0>
2105 */
2106 // clang-format on
2107 template <typename T>
2108 NEVER_INLINE HOST int32_t array_copier__cpu_template(TableFunctionManager& mgr,
2109  const Column<Array<T>>& input,
2110  Column<Array<T>>& output) {
2111  int size = input.size();
2112 
2113  // count the number of items in all input arrays:
2114  int output_values_size = 0;
2115  for (int i = 0; i < size; i++) {
2116  output_values_size += input[i].getSize();
2117  }
2118 
2119  // set the size and allocate the output columns buffers:
2120  mgr.set_output_array_values_total_number(
2121  /*output column index=*/0,
2122  /*upper bound to the number of items in all output arrays=*/output_values_size);
2123  mgr.set_output_row_size(size);
2124 
2125  // set the items of output colums:
2126  for (int i = 0; i < size; i++) {
2127  if (input.isNull(i)) {
2128  output.setNull(i);
2129  } else {
2130  output.setItem(i, input[i]);
2131  }
2132  }
2133 
2134  return size;
2135 }
2136 
2137 // clang-format off
2138 /*
2139  UDTF: array_concat__cpu_template(TableFunctionManager mgr, ColumnList<Array<T>> input) -> Column<Array<T>> | input_id=args<0>,
2140  T=[float, double, int8_t, int16_t, int32_t, int64_t, bool, TextEncodingDict]
2141 */
2142 // clang-format on
2143 template <typename T>
2144 NEVER_INLINE HOST int32_t array_concat__cpu_template(TableFunctionManager& mgr,
2145  const ColumnList<Array<T>>& inputs,
2146  Column<Array<T>>& output) {
2147  int size = inputs.size();
2148 
2149  int output_values_size = 0;
2150  for (int j = 0; j < inputs.numCols(); j++) {
2151  for (int i = 0; i < size; i++) {
2152  output_values_size += inputs[j][i].getSize();
2153  }
2154  }
2155  mgr.set_output_array_values_total_number(
2156  /*output column index=*/0,
2157  /*upper bound to the number of items in all output arrays=*/output_values_size);
2158 
2159  mgr.set_output_row_size(size);
2160 
2161  for (int i = 0; i < size; i++) {
2162  for (int j = 0; j < inputs.numCols(); j++) {
2163  Column<Array<T>> col = inputs[j];
2164  Array<T> arr = col[i];
2165  if constexpr (std::is_same<T, TextEncodingDict>::value) {
2166  auto input_dict_id = col.getDictId();
2167  auto output_dict_id = output.getDictId();
2168  if (input_dict_id == output_dict_id) {
2169  output.concatItem(i, arr);
2170  } else {
2171  throw std::runtime_error(
2172  "concat of text encoding dict arrays with different dictionary ids is not "
2173  "implemented");
2174  }
2175  } else {
2176  output.concatItem(i,
2177  arr); // works only if i is the last row set, otherwise throws
2178  }
2179  }
2180  }
2181  return size;
2182 }
2183 
2184 // clang-format off
2185 /*
2186  UDTF: array_asarray__cpu_template(TableFunctionManager mgr, Column<T> input) -> Column<Array<T>> | input_id=args<>,
2187  T=[int64_t, TextEncodingDict]
2188 */
2189 // clang-format on
2190 template <typename T>
2191 NEVER_INLINE HOST int32_t array_asarray__cpu_template(TableFunctionManager& mgr,
2192  const Column<T>& input,
2193  Column<Array<T>>& output) {
2194  int size = input.size();
2195  int output_values_size = 0;
2196  for (int i = 0; i < size; i++) {
2197  output_values_size += (input.isNull(i) ? 0 : 1);
2198  }
2199  mgr.set_output_array_values_total_number(
2200  /*output column index=*/0,
2201  /*upper bound to the number of items in all output arrays=*/output_values_size);
2202  mgr.set_output_row_size(size);
2203 
2204  if constexpr (std::is_same<T, TextEncodingDict>::value) {
2205  int32_t input_dict_id = input.getDictId();
2206  int32_t output_dict_id = mgr.getNewDictId();
2207  for (int i = 0; i < size; i++) {
2208  if (input.isNull(i)) {
2209  output.setNull(i);
2210  } else {
2211  Array<T> arr = output.getItem(i, 1);
2212  arr[0] =
2213  mgr.getOrAddTransient(output_dict_id, mgr.getString(input_dict_id, input[i]));
2214  }
2215  }
2216  } else {
2217  for (int i = 0; i < size; i++) {
2218  if (input.isNull(i)) {
2219  output.setNull(i);
2220  } else {
2221  Array<T> arr = output.getItem(i, 1);
2222  arr[0] = input[i];
2223  }
2224  }
2225  }
2226  return size;
2227 }
2228 
2229 // clang-format off
2230 /*
2231  UDTF: array_split__cpu_template(TableFunctionManager mgr, Column<Array<T>> input) ->
2232  Column<Array<T>> | input_id=args<0>, Column<Array<T>> | input_id=args<0>,
2233  T=[float, double, int8_t, int16_t, int32_t, int64_t, bool, TextEncodingDict]
2234 */
2235 // clang-format on
2236 template <typename T>
2237 NEVER_INLINE HOST int32_t array_split__cpu_template(TableFunctionManager& mgr,
2238  const Column<Array<T>>& input,
2239  Column<Array<T>>& first,
2240  Column<Array<T>>& second) {
2241  int size = input.size();
2242  int first_values_size = 0;
2243  int second_values_size = 0;
2244  for (int i = 0; i < size; i++) {
2245  if (!input.isNull(i)) {
2246  int64_t sz = input[i].getSize();
2247  first_values_size += sz / 2;
2248  second_values_size += sz - sz / 2;
2249  }
2250  }
2251  mgr.set_output_array_values_total_number(0, first_values_size);
2252  mgr.set_output_array_values_total_number(1, second_values_size);
2253  mgr.set_output_row_size(size);
2254 
2255  for (int i = 0; i < size; i++) {
2256  if (input.isNull(i)) {
2257  first.setNull(i);
2258  second.setNull(i);
2259  } else {
2260  Array<T> arr = input[i];
2261  int64_t sz = arr.getSize();
2262  Array<T> arr1 = first.getItem(i, sz / 2);
2263  Array<T> arr2 = second.getItem(i, sz - sz / 2);
2264  for (int64_t j = 0; j < sz; j++) {
2265  if (j < sz / 2) {
2266  arr1[j] = arr[j];
2267  } else {
2268  arr2[j - sz / 2] = arr[j];
2269  }
2270  }
2271  }
2272  }
2273  return size;
2274 }
2275 
2276 // clang-format off
2277 /*
2278  UDTF: tf_metadata_setter__cpu_template(TableFunctionManager) -> Column<bool> success
2279 */
2280 // clang-format on
2281 
2282 NEVER_INLINE HOST int32_t tf_metadata_setter__cpu_template(TableFunctionManager& mgr,
2283  Column<bool>& success) {
2284  // set one of each type
2285  mgr.set_metadata("test_int8_t", int8_t(1));
2286  mgr.set_metadata("test_int16_t", int16_t(2));
2287  mgr.set_metadata("test_int32_t", int32_t(3));
2288  mgr.set_metadata("test_int64_t", int64_t(4));
2289  mgr.set_metadata("test_float", 5.0f);
2290  mgr.set_metadata("test_double", 6.0);
2291  mgr.set_metadata("test_bool", true);
2292 
2293  mgr.set_output_row_size(1);
2294  success[0] = true;
2295  return 1;
2296 }
2297 
2298 // clang-format off
2299 /*
2300  UDTF: tf_metadata_setter_repeated__cpu_template(TableFunctionManager) -> Column<bool> success
2301 */
2302 // clang-format on
2303 
2304 NEVER_INLINE HOST int32_t
2305 tf_metadata_setter_repeated__cpu_template(TableFunctionManager& mgr,
2306  Column<bool>& success) {
2307  // set the same name twice
2308  mgr.set_metadata("test_int8_t", int8_t(1));
2309  mgr.set_metadata("test_int8_t", int8_t(2));
2310 
2311  mgr.set_output_row_size(1);
2312  success[0] = true;
2313  return 1;
2314 }
2315 
2316 // clang-format off
2317 /*
2318  UDTF: tf_metadata_setter_size_mismatch__cpu_template(TableFunctionManager) -> Column<bool> success
2319 */
2320 // clang-format on
2321 
2322 NEVER_INLINE HOST int32_t
2323 tf_metadata_setter_size_mismatch__cpu_template(TableFunctionManager& mgr,
2324  Column<bool>& success) {
2325  // set the same name twice
2326  mgr.set_metadata("test_int8_t", int8_t(1));
2327  mgr.set_metadata("test_int8_t", int16_t(2));
2328 
2329  mgr.set_output_row_size(1);
2330  success[0] = true;
2331  return 1;
2332 }
2333 
2334 // clang-format off
2335 /*
2336  UDTF: tf_metadata_getter__cpu_template(TableFunctionManager, Column<bool>) -> Column<bool> success
2337 */
2338 // clang-format on
2339 
2340 NEVER_INLINE HOST int32_t tf_metadata_getter__cpu_template(TableFunctionManager& mgr,
2341  const Column<bool>& input,
2342  Column<bool>& success) {
2343  // get them all back and check values
2344  int8_t i8{};
2345  int16_t i16{};
2346  int32_t i32{};
2347  int64_t i64{};
2348  float f{};
2349  double d{};
2350  bool b{};
2351 
2352  try {
2353  mgr.get_metadata("test_int8_t", i8);
2354  mgr.get_metadata("test_int16_t", i16);
2355  mgr.get_metadata("test_int32_t", i32);
2356  mgr.get_metadata("test_int64_t", i64);
2357  mgr.get_metadata("test_float", f);
2358  mgr.get_metadata("test_double", d);
2359  mgr.get_metadata("test_bool", b);
2360  } catch (const std::runtime_error& ex) {
2361  return mgr.ERROR_MESSAGE(ex.what());
2362  }
2363 
2364  // return value indicates values were correct
2365  // types are implicitly correct by this point, or the above would have thrown
2366  bool result = (i8 == 1) && (i16 == 2) && (i32 == 3) && (i64 == 4) && (f == 5.0f) &&
2367  (d == 6.0) && b;
2368  if (!result) {
2369  return mgr.ERROR_MESSAGE("Metadata return values are incorrect");
2370  }
2371 
2372  mgr.set_output_row_size(1);
2373  success[0] = true;
2374  return 1;
2375 }
2376 
2377 // clang-format off
2378 /*
2379  UDTF: tf_metadata_getter_bad__cpu_template(TableFunctionManager, Column<bool>) -> Column<bool> success
2380 */
2381 // clang-format on
2382 
2383 NEVER_INLINE HOST int32_t tf_metadata_getter_bad__cpu_template(TableFunctionManager& mgr,
2384  const Column<bool>& input,
2385  Column<bool>& success) {
2386  // get one back as the wrong type
2387  // this should throw
2388  float f{};
2389  try {
2390  mgr.get_metadata("test_double", f);
2391  } catch (const std::runtime_error& ex) {
2392  return mgr.ERROR_MESSAGE(ex.what());
2393  }
2394 
2395  mgr.set_output_row_size(1);
2396  success[0] = true;
2397  return 1;
2398 }
2399 
2400 // clang-format off
2401 /*
2402  UDTF: ct_overload_scalar_test__cpu_template(T scalar) -> Column<T>, T=[Timestamp, int64_t]
2403  UDTF: ct_overload_column_test__cpu_template(Column<T>) -> Column<T>, T=[Timestamp, TextEncodingDict, int64_t]
2404  UDTF: ct_overload_column_test__cpu_template(Column<Array<T>>) -> Column<Array<T>>, T=[TextEncodingDict, int64_t]
2405  UDTF: ct_overload_column_list_test__cpu_template(Cursor<Column<K> first_col, ColumnList<T> col_list, Column<K> last_col>) -> Column<K>, K=[int64_t], T=[int64_t, double]
2406  UDTF: ct_overload_column_list_test2__cpu_template(Cursor<Column<K> first_col, ColumnList<K> col_list1, ColumnList<T> col_list2, Column<T> last_col>) -> Column<K>, K=[int64_t], T=[int64_t, double]
2407 */
2408 // clang-format on
2409 
2410 // Test table functions overloaded on scalar types
2411 // Calcite should pick the proper overloaded operator for each templated table function
2412 template <typename T>
2413 NEVER_INLINE HOST int32_t ct_overload_scalar_test__cpu_template(const T scalar,
2414  Column<T>& out) {
2415  set_output_row_size(1);
2416  if constexpr (std::is_same<T, int64_t>::value) {
2417  out[0] = scalar;
2418  } else if constexpr (std::is_same<T, Timestamp>::value) {
2419  out[0] = scalar.time;
2420  }
2421  return 1;
2422 }
2423 
2424 // Test table functions overloaded on column types
2425 // Calcite should pick the proper overloaded operator for each templated table function
2426 template <typename T>
2427 NEVER_INLINE HOST int32_t ct_overload_column_test__cpu_template(const Column<T>& input,
2428  Column<T>& out) {
2429  int64_t size = input.size();
2430  set_output_row_size(size);
2431  for (int64_t i = 0; i < size; ++i) {
2432  if (input.isNull(i)) {
2433  out.setNull(i);
2434  } else {
2435  out[i] = input[i];
2436  }
2437  }
2438  return size;
2439 }
2440 
2441 // Test Calcite overload resolution for table functions with ColumnList arguments
2442 // Calcite should pick the proper overloaded operator for each templated table function
2443 template <typename T, typename K>
2444 NEVER_INLINE HOST int32_t
2445 ct_overload_column_list_test__cpu_template(const Column<K>& first_col,
2446  const ColumnList<T>& col_list,
2447  const Column<K>& last_col,
2448  Column<K>& out) {
2449  set_output_row_size(1);
2450  int64_t num_cols = col_list.numCols();
2451  T sum = 0;
2452  for (int64_t i = 0; i < num_cols; ++i) {
2453  const Column<T>& col = col_list[i];
2454  for (int64_t j = 0; j < col.size(); ++j) {
2455  sum += col[j];
2456  }
2457  }
2458  if (sum > 0) {
2459  out[0] = first_col[0];
2460  } else {
2461  out[0] = last_col[0];
2462  }
2463  return 1;
2464 }
2465 
2466 // Test Calcite overload resolution for table functions with multiple ColumnList arguments
2467 // Calcite should pick the proper overloaded operator for each templated table function
2468 template <typename T, typename K>
2469 NEVER_INLINE HOST int32_t
2470 ct_overload_column_list_test2__cpu_template(const Column<K>& first_col,
2471  const ColumnList<K>& col_list1,
2472  const ColumnList<T>& col_list2,
2473  const Column<T>& last_col,
2474  Column<K>& out) {
2475  set_output_row_size(1);
2476  int64_t num_cols = col_list1.numCols();
2477  K sum = 0;
2478  for (int64_t i = 0; i < num_cols; ++i) {
2479  const Column<K>& col = col_list1[i];
2480  for (int64_t j = 0; j < col.size(); ++j) {
2481  sum += col[j];
2482  }
2483  }
2484 
2485  int64_t num_cols2 = col_list2.numCols();
2486  T sum2 = 0;
2487  for (int64_t i = 0; i < num_cols2; ++i) {
2488  const Column<T>& col = col_list2[i];
2489  for (int64_t j = 0; j < col.size(); ++j) {
2490  sum2 += col[j];
2491  }
2492  }
2493 
2494  if (sum + sum2 > 0) {
2495  out[0] = first_col[0];
2496  } else {
2497  out[0] = last_col[0];
2498  }
2499  return 1;
2500 }
2501 
2502 #endif // ifndef __CUDACC__
2503 
2504 // clang-format off
2505 /*
2506  UDTF: ct_require_range__cpu_(Column<int32_t>, int x | range=[1, 5], RowMultiplier) -> Column<int32_t>
2507 */
2508 // clang-format on
2509 
2510 EXTENSION_NOINLINE int32_t ct_require_range__cpu_(const Column<int32_t>& input1,
2511  const int32_t x,
2512  const int32_t multiplier,
2513  Column<int32_t>& out) {
2514  out[0] = 0;
2515  return 1;
2516 }
ct_require_text_enc_dict__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_require_text_enc_dict__cpu_(const Column< TextEncodingDict > &input, const int64_t x, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:1736
ct_udtf_default_sizer3a__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer3a__cpu_1(const Column< int32_t > &input1, const int32_t multiplier, const int32_t x, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:397
Column< TextEncodingDict >::getString
DEVICE const std::string getString(int64_t index) const
Definition: heavydbTypes.h:926
TableFunctionManager::set_output_row_size
void set_output_row_size(int64_t num_rows)
Definition: heavydbTypes.h:1181
ct_substr__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_substr__cpu_(TableFunctionManager &mgr, const Column< TextEncodingDict > &input_str, const Column< int > &pos, const Column< int > &len, Column< TextEncodingDict > &output_substr)
Definition: TableFunctionsTesting.hpp:680
array_copier__cpu_template
NEVER_INLINE HOST int32_t array_copier__cpu_template(TableFunctionManager &mgr, const Column< Array< T >> &input, Column< Array< T >> &output)
Definition: TableFunctionsTesting.hpp:2108
ct_binding_dict_encoded6__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded6__cpu_1(const ColumnList< TextEncodingDict > &input, Column< TextEncodingDict > &out0, Column< TextEncodingDict > &out1)
Definition: TableFunctionsTesting.hpp:505
SortDesc::null_value_mapped_
const T null_value_mapped_
Definition: TableFunctionsTesting.hpp:782
ct_udtf_default_sizer3b__cpu_2
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer3b__cpu_2(const Column< int32_t > &input1, const int32_t x, const Column< int32_t > &input2, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:405
ct_timestamp_test_columns_and_scalars__cpu
EXTENSION_NOINLINE int32_t ct_timestamp_test_columns_and_scalars__cpu(const Column< Timestamp > &input, const int64_t dummy, const int32_t multiplier, const Column< Timestamp > &input2, Column< Timestamp > &out)
Definition: TableFunctionsTesting.hpp:1985
ct_scalar_1_arg_runtime_sizing__cpu_template
NEVER_INLINE HOST int32_t ct_scalar_1_arg_runtime_sizing__cpu_template(const T num, Column< T > &answer)
Definition: TableFunctionsTesting.hpp:972
TableFunctionManager::set_output_array_values_total_number
void set_output_array_values_total_number(int32_t index, int64_t output_array_values_total_number)
Definition: heavydbTypes.h:1175
ct_binding_udtf_constant__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_1(const Column< int32_t > &input1, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:129
tf_metadata_getter_bad__cpu_template
NEVER_INLINE HOST int32_t tf_metadata_getter_bad__cpu_template(TableFunctionManager &mgr, const Column< bool > &input, Column< bool > &success)
Definition: TableFunctionsTesting.hpp:2383
MIN
Definition: TableFunctionsTesting.hpp:1474
ct_test_preflight_sizer
EXTENSION_NOINLINE int32_t ct_test_preflight_sizer(const Column< int32_t > &input, const int32_t i, const int32_t j, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1809
ct_string_concat__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_string_concat__cpu_(TableFunctionManager &mgr, const ColumnList< TextEncodingDict > &input_strings, const TextEncodingNone &separator, Column< TextEncodingDict > &concatted_string)
Definition: TableFunctionsTesting.hpp:702
ct_named_output__cpu_template
NEVER_INLINE HOST int32_t ct_named_output__cpu_template(const Column< T > &input, Column< T > &out)
Definition: TableFunctionsTesting.hpp:869
set_output_row_size
EXTENSION_NOINLINE_HOST void set_output_row_size(int64_t num_rows)
EXTENSION_NOINLINE
#define EXTENSION_NOINLINE
Definition: heavydbTypes.h:52
ct_require_range__cpu_
EXTENSION_NOINLINE int32_t ct_require_range__cpu_(const Column< int32_t > &input1, const int32_t x, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:2510
ct_require__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_require__cpu_(const Column< int32_t > &input1, const int32_t i, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1673
SortAsc::map_null_value
static T map_null_value(const bool nulls_last)
Definition: TableFunctionsTesting.hpp:756
SortDesc::mapValue
T mapValue(const T &val)
Definition: TableFunctionsTesting.hpp:776
TableFunctionManager::get_metadata
void get_metadata(const std::string &key, T &value)
Definition: heavydbTypes.h:1205
ct_binding_udtf__cpu_15
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_15(const Column< int64_t > &input1, const Column< int64_t > &input2, const Column< int32_t > &input3, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:231
ct_binding_udtf_constant__cpu_9
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_9(const ColumnList< int32_t > &input1, const ColumnList< int64_t > &input2, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:187
TextEncodingNone::getString
std::string getString() const
Definition: heavydbTypes.h:286
get_column_min_max
NEVER_INLINE HOST std::pair< T, T > get_column_min_max(const Column< T > &col)
Definition: TableFunctionsCommon.cpp:32
ct_binding_udtf__cpu_11
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_11(const Column< int32_t > &input1, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:202
Column::size
DEVICE int64_t size() const
Definition: heavydbTypes.h:726
sort_column_limit__cpu_template
NEVER_INLINE HOST int32_t sort_column_limit__cpu_template(const Column< T > &input, const int32_t limit, const bool sort_ascending, const bool nulls_last, Column< T > &output)
Definition: TableFunctionsTesting.hpp:797
ct_synthesize_new_dict__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_synthesize_new_dict__cpu_(TableFunctionManager &mgr, const int64_t num_strings, Column< TextEncodingDict > &new_dict_col)
Definition: TableFunctionsTesting.hpp:733
ct_cursor_named_args__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_cursor_named_args__cpu_(TableFunctionManager &mgr, const Column< int32_t > &input_arg1, const Column< int32_t > &input_arg2, const int32_t arg1, const int32_t arg2, Column< int32_t > &out1, Column< int32_t > &out2)
Definition: TableFunctionsTesting.hpp:1898
ct_binding_str_equals__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_binding_str_equals__cpu_(const ColumnList< TextEncodingDict > &input_strings, Column< TextEncodingDict > &string_if_equal, Column< bool > &strings_are_equal)
Definition: TableFunctionsTesting.hpp:646
ct_udtf_default_sizer2a__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer2a__cpu_1(const Column< int32_t > &input1, const int32_t x, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:373
ct_binding_dict_encoded2__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded2__cpu_1(const Column< TextEncodingDict > &input1, const Column< TextEncodingDict > &input2, Column< TextEncodingDict > &out1, Column< TextEncodingDict > &out2)
Definition: TableFunctionsTesting.hpp:457
TableFunctionManager::getString
std::string getString(int32_t dict_id, int32_t string_id)
Definition: heavydbTypes.h:1222
ColumnList::numCols
DEVICE int64_t numCols() const
Definition: heavydbTypes.h:997
ct_binding_udtf__cpu_20
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_20(const Column< int64_t > &input1, const ColumnList< int64_t > &input2, const Column< int64_t > &input3, const int32_t multiplier, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:268
ct_binding_udtf5__cpu_24
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf5__cpu_24(const ColumnList< int32_t > &input1, const int32_t input2, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:299
gpu_enabled::sort
DEVICE void sort(ARGS &&...args)
Definition: gpu_enabled.h:105
Column::ptr_
T * ptr_
Definition: heavydbTypes.h:700
ct_sleep1__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_sleep1__cpu_(int32_t seconds, int32_t mode, Column< int32_t > &output)
Definition: TableFunctionsTesting.hpp:1293
ct_pushdown_projection__cpu_template
NEVER_INLINE HOST int32_t ct_pushdown_projection__cpu_template(TableFunctionManager &mgr, const Column< K > &input_id, const Column< T > &input_x, const Column< T > &input_y, const Column< Z > &input_z, Column< K > &output_id, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z)
Definition: TableFunctionsTesting.hpp:1542
ct_binding_udtf_constant__cpu_3
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_3(const Column< int32_t > &input1, const Column< int32_t > &input2, const Column< int32_t > &input3, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:141
ct_gpu_default_init__gpu_
EXTENSION_NOINLINE int32_t ct_gpu_default_init__gpu_(Column< int32_t > &output_buffer)
Definition: TableFunctionsTesting.hpp:1147
ct_binding_udtf__cpu_12
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_12(const Column< int32_t > &input1, const Column< int32_t > &input2, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:208
ColumnList< TextEncodingDict >::size
DEVICE int64_t size() const
Definition: heavydbTypes.h:1077
tf_metadata_setter__cpu_template
NEVER_INLINE HOST int32_t tf_metadata_setter__cpu_template(TableFunctionManager &mgr, Column< bool > &success)
Definition: TableFunctionsTesting.hpp:2282
SortAsc::SortAsc
SortAsc(const bool nulls_last)
Definition: TableFunctionsTesting.hpp:753
SortDesc::SortDesc
SortDesc(const bool nulls_last)
Definition: TableFunctionsTesting.hpp:769
Column< TextEncodingDict >::setNull
DEVICE void setNull(int64_t index)
Definition: heavydbTypes.h:921
ct_binding_udtf_constant__cpu_2
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_2(const Column< int32_t > &input1, const Column< int32_t > &input2, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:134
ct_overload_column_list_test__cpu_template
NEVER_INLINE HOST int32_t ct_overload_column_list_test__cpu_template(const Column< K > &first_col, const ColumnList< T > &col_list, const Column< K > &last_col, Column< K > &out)
Definition: TableFunctionsTesting.hpp:2445
ct_binding_udtf4__cpu_23
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf4__cpu_23(const ColumnList< int32_t > &input1, const int32_t multiplier, const int32_t input2, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:291
ct_named_const_output__cpu_template
NEVER_INLINE HOST int32_t ct_named_const_output__cpu_template(const Column< T > &input, Column< T > &out)
Definition: TableFunctionsTesting.hpp:881
ct_binding_udtf__cpu_16
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_16(const Column< int64_t > &input1, const Column< int32_t > &input2, const Column< int64_t > &input3, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:239
tf_metadata_setter_repeated__cpu_template
NEVER_INLINE HOST int32_t tf_metadata_setter_repeated__cpu_template(TableFunctionManager &mgr, Column< bool > &success)
Definition: TableFunctionsTesting.hpp:2305
TFAggType
TFAggType
Definition: TableFunctionsTesting.hpp:1474
ct_get_string_chars__template
TEMPLATE_NOINLINE int32_t ct_get_string_chars__template(const Column< T > &indices, const TextEncodingNone &str, const int32_t multiplier, Column< int32_t > &idx, Column< int8_t > &char_bytes)
Definition: TableFunctionsTesting.hpp:1190
ct_binding_dict_encoded1__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded1__cpu_1(const Column< TextEncodingDict > &input, const int32_t multiplier, Column< TextEncodingDict > &out)
Definition: TableFunctionsTesting.hpp:447
anonymous_namespace{Utm.h}::f
constexpr double f
Definition: Utm.h:31
to_string
std::string to_string(char const *&&v)
Definition: StringTransform.cpp:101
get_min_or_max_union
TEMPLATE_INLINE T get_min_or_max_union(const Column< T > &col1, const Column< T > &col2, const TFAggType min_or_max)
Definition: TableFunctionsTesting.hpp:1486
MAX
Definition: TableFunctionsTesting.hpp:1474
ct_require_and__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_require_and__cpu_(const Column< int32_t > &input1, const int32_t i, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1711
TextEncodingNone::size
DEVICE ALWAYS_INLINE int64_t size() const
Definition: heavydbTypes.h:309
ct_sleep2
EXTENSION_NOINLINE_HOST int32_t ct_sleep2(TableFunctionManager &mgr, int32_t seconds, int32_t mode, Column< int32_t > &output)
Definition: TableFunctionsTesting.hpp:1319
anonymous_namespace{Utm.h}::a
constexpr double a
Definition: Utm.h:32
CPU_DEVICE_CODE
#define CPU_DEVICE_CODE
Definition: TableFunctionsTesting.hpp:27
ct_overload_column_test__cpu_template
NEVER_INLINE HOST int32_t ct_overload_column_test__cpu_template(const Column< T > &input, Column< T > &out)
Definition: TableFunctionsTesting.hpp:2427
ct_binding_template__cpu_template
NEVER_INLINE HOST int32_t ct_binding_template__cpu_template(const Column< T > &input, Column< T > &out)
Definition: TableFunctionsTesting.hpp:530
HOST
#define HOST
Definition: funcannotations.h:26
ColumnList< TextEncodingDict >
Definition: heavydbTypes.h:1053
safe_addition
T safe_addition(T x, T y)
Definition: TableFunctionsTesting.hpp:1096
ct_overload_column_list_test2__cpu_template
NEVER_INLINE HOST int32_t ct_overload_column_list_test2__cpu_template(const Column< K > &first_col, const ColumnList< K > &col_list1, const ColumnList< T > &col_list2, const Column< T > &last_col, Column< K > &out)
Definition: TableFunctionsTesting.hpp:2470
ct_no_cursor_user_constant_sizer__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_no_cursor_user_constant_sizer__cpu_(const int32_t input_num, int32_t c, Column< int32_t > &output)
Definition: TableFunctionsTesting.hpp:1020
TextEncodingDict
Definition: heavydbTypes.h:125
ct_templated_no_cursor_user_constant_sizer__cpu_template
NEVER_INLINE HOST int32_t ct_templated_no_cursor_user_constant_sizer__cpu_template(const T input_num, int32_t c, Column< T > &output)
Definition: TableFunctionsTesting.hpp:1041
GPU_DEVICE_CODE
#define GPU_DEVICE_CODE
Definition: TableFunctionsTesting.hpp:28
ct_udtf_default_sizer4b__cpu_2
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer4b__cpu_2(const int32_t multiplier, const Column< int32_t > &input, const int32_t x, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:423
ct_named_user_const_output__cpu_template
NEVER_INLINE HOST int32_t ct_named_user_const_output__cpu_template(const Column< T > &input, int32_t c, Column< T > &out)
Definition: TableFunctionsTesting.hpp:897
ct_binding_udtf__cpu_17
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_17(const Column< int32_t > &input1, const ColumnList< int32_t > &input2, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:247
ct_pushdown_stats__cpu_template
NEVER_INLINE HOST int32_t ct_pushdown_stats__cpu_template(TableFunctionManager &mgr, const TextEncodingNone &agg_type, const Column< K > &input_id, const Column< T > &input_x, const Column< T > &input_y, const Column< Z > &input_z, Column< int32_t > &output_row_count, Column< K > &output_id, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z)
Definition: TableFunctionsTesting.hpp:1509
ct_overload_scalar_test__cpu_template
NEVER_INLINE HOST int32_t ct_overload_scalar_test__cpu_template(const T scalar, Column< T > &out)
Definition: TableFunctionsTesting.hpp:2413
ct_scalar_2_args_constant_sizing
EXTENSION_NOINLINE int32_t ct_scalar_2_args_constant_sizing(const int64_t num1, const int64_t num2, Column< int64_t > &answer1, Column< int64_t > &answer2)
Definition: TableFunctionsTesting.hpp:991
ct_timestamp_column_list_input
EXTENSION_NOINLINE_HOST int32_t ct_timestamp_column_list_input(TableFunctionManager &mgr, const ColumnList< int64_t > &input, const Column< Timestamp > &input2, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:2003
ct_binding_udtf__cpu_19
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_19(const ColumnList< int32_t > &input1, const ColumnList< int64_t > &input2, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:261
ct_binding_udtf_constant__cpu_8
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_8(const ColumnList< int32_t > &input1, const Column< int64_t > &input2, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:180
ct_udtf_default_sizer1c__cpu_3
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer1c__cpu_3(const Column< int32_t > &input1, const Column< int32_t > &input2, const Column< int32_t > &input3, const int32_t multiplier, const Column< int32_t > &input4, const int32_t x, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:354
ct_timestamp_truncate
EXTENSION_NOINLINE_HOST int32_t ct_timestamp_truncate(TableFunctionManager &mgr, const Column< Timestamp > &input, Column< Timestamp > &y, Column< Timestamp > &mo, Column< Timestamp > &d, Column< Timestamp > &h, Column< Timestamp > &m, Column< Timestamp > &s, Column< Timestamp > &ms, Column< Timestamp > &us)
Definition: TableFunctionsTesting.hpp:2012
Array::getSize
DEVICE int64_t getSize() const
Definition: heavydbTypes.h:231
EXTENSION_NOINLINE_HOST
#define EXTENSION_NOINLINE_HOST
Definition: heavydbTypes.h:49
generate_TableFunctionsFactory_init.separator
string separator
Definition: generate_TableFunctionsFactory_init.py:78
TableFunctionManager::getOrAddTransient
int32_t getOrAddTransient(int32_t dict_id, std::string str)
Definition: heavydbTypes.h:1230
ct_binding_dict_encoded5__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded5__cpu_1(const ColumnList< TextEncodingDict > &input, Column< TextEncodingDict > &out)
Definition: TableFunctionsTesting.hpp:494
ct_test_nullable
EXTENSION_NOINLINE int32_t ct_test_nullable(const Column< int32_t > &input, const int32_t i, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1789
TEMPLATE_INLINE
#define TEMPLATE_INLINE
Definition: heavydbTypes.h:53
ct_binding_udtf2__cpu_21
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf2__cpu_21(const int32_t multiplier, const Column< int32_t > &input1, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:277
ct_timestamp_add_offset
EXTENSION_NOINLINE_HOST int32_t ct_timestamp_add_offset(TableFunctionManager &mgr, const Column< Timestamp > &input, const Timestamp offset, Column< Timestamp > &out)
Definition: TableFunctionsTesting.hpp:1967
ct_binding_udtf_constant__cpu_7
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_7(const Column< int32_t > &input1, const ColumnList< int32_t > &input2, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:173
ct_udtf_default_sizer1a__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer1a__cpu_1(const Column< int32_t > &input1, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:339
ct_udtf_default_sizer2b__cpu_2
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer2b__cpu_2(const Column< int32_t > &input1, const int32_t multiplier, const Column< int32_t > &input2, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:381
ct_binding_dict_encoded3__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded3__cpu_1(const Column< TextEncodingDict > &input1, const Column< TextEncodingDict > &input2, Column< TextEncodingDict > &out1, Column< TextEncodingDict > &out2)
Definition: TableFunctionsTesting.hpp:470
ct_binding_udtf__cpu_14
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_14(const Column< int64_t > &input1, const Column< int32_t > &input2, const Column< int32_t > &input3, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:223
ct_require_str_diff__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_require_str_diff__cpu_(const Column< int32_t > &input1, const TextEncodingNone &i, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1727
ColumnList< TextEncodingDict >::numCols
DEVICE int64_t numCols() const
Definition: heavydbTypes.h:1078
SortAsc::mapValue
T mapValue(const T &val)
Definition: TableFunctionsTesting.hpp:759
column_list_safe_row_sum__cpu_template
NEVER_INLINE HOST int32_t column_list_safe_row_sum__cpu_template(const ColumnList< T > &input, Column< T > &out)
Definition: TableFunctionsTesting.hpp:1119
ct_binding_udtf_constant__cpu_5
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_5(const Column< int64_t > &input1, const Column< int64_t > &input2, const Column< int32_t > &input3, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:157
TextEncodingNone
Definition: heavydbTypes.h:263
ct_no_arg_constant_sizing
EXTENSION_NOINLINE int32_t ct_no_arg_constant_sizing(Column< int32_t > &answer)
Definition: TableFunctionsTesting.hpp:946
ct_union_pushdown_stats__cpu_template
NEVER_INLINE HOST int32_t ct_union_pushdown_stats__cpu_template(TableFunctionManager &mgr, const TextEncodingNone &agg_type, const Column< K > &input1_id, const Column< T > &input1_x, const Column< T > &input1_y, const Column< Z > &input1_z, const Column< K > &input2_id, const Column< T > &input2_x, const Column< T > &input2_y, const Column< Z > &input2_z, const Column< T > &input2_w, Column< int32_t > &output_row_count, Column< K > &output_id, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z, Column< T > &output_w)
Definition: TableFunctionsTesting.hpp:1574
SortAsc::operator()
bool operator()(const T &a, const T &b)
Definition: TableFunctionsTesting.hpp:762
ct_udtf_default_sizer4a__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer4a__cpu_1(const Column< int32_t > &input1, const int32_t multiplier, const Column< int32_t > &input2, const int32_t x, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:414
tf_metadata_getter__cpu_template
NEVER_INLINE HOST int32_t tf_metadata_getter__cpu_template(TableFunctionManager &mgr, const Column< bool > &input, Column< bool > &success)
Definition: TableFunctionsTesting.hpp:2340
Column::isNull
DEVICE bool isNull(int64_t index) const
Definition: heavydbTypes.h:729
ct_binding_udtf3__cpu_25
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf3__cpu_25(const Column< int32_t > &input1, const int32_t input2, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:306
Column::setNull
DEVICE void setNull(int64_t index)
Definition: heavydbTypes.h:730
ct_udtf_default_sizer1d__cpu_4
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer1d__cpu_4(const int32_t multiplier, const int32_t x, const Column< int32_t > &input1, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:365
ct_add_size_and_mul_alpha
EXTENSION_NOINLINE_HOST int32_t ct_add_size_and_mul_alpha(TableFunctionManager &mgr, const Column< int32_t > &input1, const Column< int32_t > &input2, int32_t alpha, Column< int32_t > &output1, Column< int32_t > &output2)
Definition: TableFunctionsTesting.hpp:1403
SortAsc::null_value_mapped_
const T null_value_mapped_
Definition: TableFunctionsTesting.hpp:764
array_concat__cpu_template
NEVER_INLINE HOST int32_t array_concat__cpu_template(TableFunctionManager &mgr, const ColumnList< Array< T >> &inputs, Column< Array< T >> &output)
Definition: TableFunctionsTesting.hpp:2144
ct_require_str__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_require_str__cpu_(const Column< int32_t > &input1, const TextEncodingNone &s, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1681
ct_binding_column__cpu_template
NEVER_INLINE HOST int32_t ct_binding_column__cpu_template(const Column< T > &input, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:581
tf_metadata_setter_size_mismatch__cpu_template
NEVER_INLINE HOST int32_t tf_metadata_setter_size_mismatch__cpu_template(TableFunctionManager &mgr, Column< bool > &success)
Definition: TableFunctionsTesting.hpp:2323
ct_binding_dict_encoded4__cpu_1
EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded4__cpu_1(const ColumnList< TextEncodingDict > &input, Column< TextEncodingDict > &out)
Definition: TableFunctionsTesting.hpp:483
ct_hamming_distance
EXTENSION_NOINLINE int32_t ct_hamming_distance(const TextEncodingNone &str1, const TextEncodingNone &str2, Column< int32_t > &hamming_distance)
Definition: TableFunctionsTesting.hpp:1158
ct_copy_and_add_size
EXTENSION_NOINLINE_HOST int32_t ct_copy_and_add_size(TableFunctionManager &mgr, const Column< int32_t > &input, Column< int32_t > &output)
Definition: TableFunctionsTesting.hpp:1393
ct_sleep_worker
EXTENSION_NOINLINE int32_t ct_sleep_worker(int32_t seconds, Column< int32_t > &output)
Definition: TableFunctionsTesting.hpp:1275
ct_device_selection_udtf_both__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_device_selection_udtf_both__cpu_(const Column< int32_t > &input, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:71
NEVER_INLINE
#define NEVER_INLINE
Definition: funcannotations.h:65
ct_throw_if_gt_100__cpu_template
NEVER_INLINE HOST int32_t ct_throw_if_gt_100__cpu_template(TableFunctionManager &mgr, const Column< T > &input, Column< T > &output)
Definition: TableFunctionsTesting.hpp:1358
ct_scalar_named_args__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_scalar_named_args__cpu_(TableFunctionManager &mgr, const int32_t arg1, const int32_t arg2, Column< int32_t > &out1, Column< int32_t > &out2)
Definition: TableFunctionsTesting.hpp:1882
SortDesc::map_null_value
static T map_null_value(const bool nulls_last)
Definition: TableFunctionsTesting.hpp:772
TableFunctionManager::set_metadata
void set_metadata(const std::string &key, const T &value)
Definition: heavydbTypes.h:1196
SortDesc::operator()
bool operator()(const T &a, const T &b)
Definition: TableFunctionsTesting.hpp:780
ct_device_selection_udtf_any
EXTENSION_NOINLINE int32_t ct_device_selection_udtf_any(const Column< int32_t > &input, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:41
get_min_or_max
TEMPLATE_INLINE T get_min_or_max(const Column< T > &col, const TFAggType min_or_max)
Definition: TableFunctionsTesting.hpp:1477
TABLE_FUNCTION_ERROR
#define TABLE_FUNCTION_ERROR(MSG)
Definition: heavydbTypes.h:68
ct_named_rowmul_output__cpu_template
NEVER_INLINE HOST int32_t ct_named_rowmul_output__cpu_template(const Column< T > &input, int32_t m, Column< T > &out)
Definition: TableFunctionsTesting.hpp:910
ct_test_preflight_multicursor_qe227__cpu_
EXTENSION_NOINLINE int32_t ct_test_preflight_multicursor_qe227__cpu_(TableFunctionManager &mgr, const Column< int32_t > &col, const ColumnList< int32_t > &lst, const int x, const int y, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1861
ct_require_templating__cpu_template
NEVER_INLINE HOST int32_t ct_require_templating__cpu_template(const Column< T > &input1, const int32_t i, Column< K > &out)
Definition: TableFunctionsTesting.hpp:1699
ct_device_selection_udtf_both__gpu_
EXTENSION_NOINLINE int32_t ct_device_selection_udtf_both__gpu_(const Column< int32_t > &input, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:80
ct_timestamp_extract
EXTENSION_NOINLINE_HOST int32_t ct_timestamp_extract(TableFunctionManager &mgr, const Column< Timestamp > &input, Column< int64_t > &ns, Column< int64_t > &us, Column< int64_t > &ms, Column< int64_t > &s, Column< int64_t > &m, Column< int64_t > &h, Column< int64_t > &d, Column< int64_t > &mo, Column< int64_t > &y)
Definition: TableFunctionsTesting.hpp:1927
Column< TextEncodingDict >::size
DEVICE int64_t size() const
Definition: heavydbTypes.h:916
ct_require_or_str__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_require_or_str__cpu_(const Column< int32_t > &input1, const TextEncodingNone &i, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1719
ct_udtf_default_sizer2c__cpu_3
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer2c__cpu_3(const int32_t x, const int32_t multiplier, const Column< int32_t > &input1, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:389
ct_require_mgr
EXTENSION_NOINLINE_HOST int32_t ct_require_mgr(TableFunctionManager &mgr, const Column< int32_t > &input1, const int32_t i, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1689
array_asarray__cpu_template
NEVER_INLINE HOST int32_t array_asarray__cpu_template(TableFunctionManager &mgr, const Column< T > &input, Column< Array< T >> &output)
Definition: TableFunctionsTesting.hpp:2191
ct_no_arg_runtime_sizing__cpu_template
NEVER_INLINE HOST int32_t ct_no_arg_runtime_sizing__cpu_template(Column< T > &answer)
Definition: TableFunctionsTesting.hpp:932
ct_device_selection_udtf_gpu__gpu_
EXTENSION_NOINLINE int32_t ct_device_selection_udtf_gpu__gpu_(const Column< int32_t > &input, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:62
Column< TextEncodingDict >::getOrAddTransient
DEVICE const TextEncodingDict getOrAddTransient(const std::string &str)
Definition: heavydbTypes.h:936
ct_device_selection_udtf_cpu__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_device_selection_udtf_cpu__cpu_(const Column< int32_t > &input, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:53
array_split__cpu_template
NEVER_INLINE HOST int32_t array_split__cpu_template(TableFunctionManager &mgr, const Column< Array< T >> &input, Column< Array< T >> &first, Column< Array< T >> &second)
Definition: TableFunctionsTesting.hpp:2237
ct_binding_udtf6__cpu_22
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf6__cpu_22(const Column< int32_t > &input1, const int32_t multiplier, const int32_t input2, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:283
ct_union_pushdown_projection__cpu_template
NEVER_INLINE HOST int32_t ct_union_pushdown_projection__cpu_template(TableFunctionManager &mgr, const Column< K > &input1_id, const Column< T > &input1_x, const Column< T > &input1_y, const Column< Z > &input1_z, const Column< K > &input2_id, const Column< T > &input2_x, const Column< T > &input2_y, const Column< Z > &input2_z, const Column< T > &input2_w, Column< K > &output_id, Column< T > &output_x, Column< T > &output_y, Column< Z > &output_z, Column< T > &output_w)
Definition: TableFunctionsTesting.hpp:1620
ct_binding_udtf_constant__cpu_6
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_6(const Column< int64_t > &input1, const Column< int32_t > &input2, const Column< int64_t > &input3, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:165
TableFunctionManager::get_singleton
static TableFunctionManager * get_singleton()
Definition: heavydbTypes.h:1171
Column< TextEncodingDict >
Definition: heavydbTypes.h:880
ct_binding_udtf_constant__cpu_10
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_10(const Column< int64_t > &input1, const ColumnList< int64_t > &input2, const Column< int64_t > &input3, Column< int64_t > &out)
Definition: TableFunctionsTesting.hpp:194
Array::isNull
DEVICE bool isNull() const
Definition: heavydbTypes.h:233
ct_test_preflight_singlecursor_qe227__cpu_
EXTENSION_NOINLINE int32_t ct_test_preflight_singlecursor_qe227__cpu_(TableFunctionManager &mgr, const Column< int32_t > &col, const ColumnList< int32_t > &lst, const int x, const int y, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1837
ct_binding_scalar_multiply__cpu_template
NEVER_INLINE HOST int32_t ct_binding_scalar_multiply__cpu_template(const Column< T > &input, const T multiplier, Column< T > &out)
Definition: TableFunctionsTesting.hpp:606
ct_udtf_default_sizer1b__cpu_2
EXTENSION_NOINLINE_HOST int32_t ct_udtf_default_sizer1b__cpu_2(const Column< int32_t > &input1, const Column< int32_t > &input2, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:346
ct_binding_udtf_constant__cpu_4
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_4(const Column< int64_t > &input1, const Column< int32_t > &input2, const Column< int32_t > &input3, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:149
ct_test_preflight_sizer_const
EXTENSION_NOINLINE int32_t ct_test_preflight_sizer_const(const Column< int32_t > &input, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:1818
ct_binding_udtf__cpu_13
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_13(const Column< int32_t > &input1, const Column< int32_t > &input2, const Column< int32_t > &input3, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:215
ct_sparse_add
EXTENSION_NOINLINE_HOST int32_t ct_sparse_add(TableFunctionManager &mgr, const Column< int32_t > &x1, const Column< int32_t > &d1, int32_t f1, const Column< int32_t > &x2, const Column< int32_t > &d2, int32_t f2, Column< int32_t > &x, Column< int32_t > &d)
Definition: TableFunctionsTesting.hpp:1425
ct_binding_column2__cpu_template
NEVER_INLINE HOST int32_t ct_binding_column2__cpu_template(const Column< T > &input1, const Column< U > &input2, Column< K > &out)
Definition: TableFunctionsTesting.hpp:828
TEMPLATE_NOINLINE
#define TEMPLATE_NOINLINE
Definition: heavydbTypes.h:54
ct_timestamp_add_interval__template
NEVER_INLINE HOST int32_t ct_timestamp_add_interval__template(TableFunctionManager &mgr, const Column< Timestamp > &input, const T inter, Column< Timestamp > &out)
Definition: TableFunctionsTesting.hpp:2040
ct_binding_udtf__cpu_18
EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_18(const ColumnList< int32_t > &input1, const Column< int64_t > &input2, const int32_t multiplier, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:254
substring
std::pair< std::string_view, const char * > substring(const std::string &str, size_t substr_length)
return substring of str with postfix if str.size() &gt; substr_length
Definition: StringTransform.cpp:110
ct_binding_columnlist__cpu_template
NEVER_INLINE HOST int32_t ct_binding_columnlist__cpu_template(const Column< T > &input1, const ColumnList< T > &input2, Column< int32_t > &out)
Definition: TableFunctionsTesting.hpp:553
run_benchmark_import.result
dictionary result
Definition: run_benchmark_import.py:441
ct_string_to_chars__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_string_to_chars__cpu_(const TextEncodingNone &input, Column< int32_t > &char_idx, Column< int8_t > &char_bytes)
Definition: TableFunctionsTesting.hpp:1230
sum_along_row__cpu_template
NEVER_INLINE HOST int32_t sum_along_row__cpu_template(const Column< Array< T >> &input, Column< T > &output)
Definition: TableFunctionsTesting.hpp:2059
ct_binding_str_length__cpu_
EXTENSION_NOINLINE_HOST int32_t ct_binding_str_length__cpu_(const Column< TextEncodingDict > &input_str, Column< TextEncodingDict > &out_str, Column< int64_t > &out_size)
Definition: TableFunctionsTesting.hpp:627