TableFunctionsTesting.hpp File Reference

#include "../../QueryEngine/TableFunctions/SystemFunctions/os/Shared/TableFunctionsCommon.hpp"
#include "../../QueryEngine/heavydbTypes.h"
#include <algorithm>
#include <iostream>
#include <string>

Include dependency graph for TableFunctionsTesting.hpp:

Go to the source code of this file.

Classes
struct	SortAsc< T >
struct	SortDesc< T >

Macros
#define	CPU_DEVICE_CODE   0x637075;
#define	GPU_DEVICE_CODE   0x677075;

Enumerations
enum	TFAggType { MIN, MAX }

Functions
EXTENSION_NOINLINE int32_t	ct_device_selection_udtf_any (const Column< int32_t > &input, Column< int64_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_device_selection_udtf_cpu__cpu_ (const Column< int32_t > &input, Column< int64_t > &out)
EXTENSION_NOINLINE int32_t	ct_device_selection_udtf_gpu__gpu_ (const Column< int32_t > &input, Column< int64_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_device_selection_udtf_both__cpu_ (const Column< int32_t > &input, Column< int64_t > &out)
EXTENSION_NOINLINE int32_t	ct_device_selection_udtf_both__gpu_ (const Column< int32_t > &input, Column< int64_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_binding_udtf_constant__cpu_1 (const Column< int32_t > &input1, Column< int32_t > &out)
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)
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)
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)
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)
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)
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)
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)
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)
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)
EXTENSION_NOINLINE_HOST int32_t	ct_binding_udtf__cpu_11 (const Column< int32_t > &input1, const int32_t multiplier, Column< int32_t > &out)
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)
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)
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)
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)
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)
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)
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)
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)
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)
EXTENSION_NOINLINE_HOST int32_t	ct_binding_udtf2__cpu_21 (const int32_t multiplier, const Column< int32_t > &input1, Column< int32_t > &out)
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)
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)
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)
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)
EXTENSION_NOINLINE_HOST int32_t	ct_udtf_default_sizer1a__cpu_1 (const Column< int32_t > &input1, const int32_t multiplier, Column< int32_t > &out)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
EXTENSION_NOINLINE_HOST int32_t	ct_binding_dict_encoded1__cpu_1 (const Column< TextEncodingDict > &input, const int32_t multiplier, Column< TextEncodingDict > &out)
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)
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)
EXTENSION_NOINLINE_HOST int32_t	ct_binding_dict_encoded4__cpu_1 (const ColumnList< TextEncodingDict > &input, Column< TextEncodingDict > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_binding_dict_encoded5__cpu_1 (const ColumnList< TextEncodingDict > &input, Column< TextEncodingDict > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_binding_dict_encoded6__cpu_1 (const ColumnList< TextEncodingDict > &input, Column< TextEncodingDict > &out0, Column< TextEncodingDict > &out1)
template<typename T >
NEVER_INLINE HOST int32_t	ct_binding_template__cpu_template (const Column< T > &input, Column< T > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_binding_columnlist__cpu_template (const Column< T > &input1, const ColumnList< T > &input2, Column< int32_t > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_binding_column__cpu_template (const Column< T > &input, Column< int32_t > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_binding_scalar_multiply__cpu_template (const Column< T > &input, const T multiplier, Column< T > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_binding_str_length__cpu_ (const Column< TextEncodingDict > &input_str, Column< TextEncodingDict > &out_str, Column< int64_t > &out_size)
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)
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)
EXTENSION_NOINLINE_HOST int32_t	ct_string_concat__cpu_ (TableFunctionManager &mgr, const ColumnList< TextEncodingDict > &input_strings, const TextEncodingNone &separator, Column< TextEncodingDict > &concatted_string)
EXTENSION_NOINLINE_HOST int32_t	ct_synthesize_new_dict__cpu_ (TableFunctionManager &mgr, const int64_t num_strings, Column< TextEncodingDict > &new_dict_col)
template<typename T >
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)
template<typename T , typename U , typename K >
NEVER_INLINE HOST int32_t	ct_binding_column2__cpu_template (const Column< T > &input1, const Column< U > &input2, Column< K > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_named_output__cpu_template (const Column< T > &input, Column< T > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_named_const_output__cpu_template (const Column< T > &input, Column< T > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_named_user_const_output__cpu_template (const Column< T > &input, int32_t c, Column< T > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_named_rowmul_output__cpu_template (const Column< T > &input, int32_t m, Column< T > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_no_arg_runtime_sizing__cpu_template (Column< T > &answer)
EXTENSION_NOINLINE int32_t	ct_no_arg_constant_sizing (Column< int32_t > &answer)
template<typename T >
NEVER_INLINE HOST int32_t	ct_scalar_1_arg_runtime_sizing__cpu_template (const T num, Column< T > &answer)
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)
EXTENSION_NOINLINE_HOST int32_t	ct_no_cursor_user_constant_sizer__cpu_ (const int32_t input_num, int32_t c, Column< int32_t > &output)
template<typename T >
NEVER_INLINE HOST int32_t	ct_templated_no_cursor_user_constant_sizer__cpu_template (const T input_num, int32_t c, Column< T > &output)
template<typename T >
T	safe_addition (T x, T y)
template<typename T >
NEVER_INLINE HOST int32_t	column_list_safe_row_sum__cpu_template (const ColumnList< T > &input, Column< T > &out)
EXTENSION_NOINLINE int32_t	ct_gpu_default_init__gpu_ (Column< int32_t > &output_buffer)
EXTENSION_NOINLINE int32_t	ct_hamming_distance (const TextEncodingNone &str1, const TextEncodingNone &str2, Column< int32_t > &hamming_distance)
template<typename T >
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)
EXTENSION_NOINLINE_HOST int32_t	ct_string_to_chars__cpu_ (const TextEncodingNone &input, Column< int32_t > &char_idx, Column< int8_t > &char_bytes)
EXTENSION_NOINLINE int32_t	ct_sleep_worker (int32_t seconds, Column< int32_t > &output)
EXTENSION_NOINLINE_HOST int32_t	ct_sleep1__cpu_ (int32_t seconds, int32_t mode, Column< int32_t > &output)
EXTENSION_NOINLINE_HOST int32_t	ct_sleep2 (TableFunctionManager &mgr, int32_t seconds, int32_t mode, Column< int32_t > &output)
template<typename T >
NEVER_INLINE HOST int32_t	ct_throw_if_gt_100__cpu_template (TableFunctionManager &mgr, const Column< T > &input, Column< T > &output)
EXTENSION_NOINLINE_HOST int32_t	ct_copy_and_add_size (TableFunctionManager &mgr, const Column< int32_t > &input, Column< int32_t > &output)
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)
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)
template<typename T >
TEMPLATE_INLINE T	get_min_or_max (const Column< T > &col, const TFAggType min_or_max)
template<typename T >
TEMPLATE_INLINE T	get_min_or_max_union (const Column< T > &col1, const Column< T > &col2, const TFAggType min_or_max)
template<typename K , typename T , typename Z >
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)
template<typename K , typename T , typename Z >
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)
template<typename K , typename T , typename Z >
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)
template<typename K , typename T , typename Z >
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)
EXTENSION_NOINLINE_HOST int32_t	ct_require__cpu_ (const Column< int32_t > &input1, const int32_t i, Column< int32_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_require_str__cpu_ (const Column< int32_t > &input1, const TextEncodingNone &s, Column< int32_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_require_mgr (TableFunctionManager &mgr, const Column< int32_t > &input1, const int32_t i, Column< int32_t > &out)
template<typename T , typename K >
NEVER_INLINE HOST int32_t	ct_require_templating__cpu_template (const Column< T > &input1, const int32_t i, Column< K > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_require_and__cpu_ (const Column< int32_t > &input1, const int32_t i, Column< int32_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_require_or_str__cpu_ (const Column< int32_t > &input1, const TextEncodingNone &i, Column< int32_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_require_str_diff__cpu_ (const Column< int32_t > &input1, const TextEncodingNone &i, Column< int32_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_require_text_enc_dict__cpu_ (const Column< TextEncodingDict > &input, const int64_t x, Column< int64_t > &out)
EXTENSION_NOINLINE int32_t	ct_test_nullable (const Column< int32_t > &input, const int32_t i, Column< int32_t > &out)
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)
EXTENSION_NOINLINE int32_t	ct_test_preflight_sizer_const (const Column< int32_t > &input, Column< int32_t > &out)
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)
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)
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)
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)
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)
EXTENSION_NOINLINE_HOST int32_t	ct_timestamp_add_offset (TableFunctionManager &mgr, const Column< Timestamp > &input, const Timestamp offset, Column< Timestamp > &out)
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)
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)
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)
template<typename T >
NEVER_INLINE HOST int32_t	ct_timestamp_add_interval__template (TableFunctionManager &mgr, const Column< Timestamp > &input, const T inter, Column< Timestamp > &out)
template<typename T >
NEVER_INLINE HOST int32_t	sum_along_row__cpu_template (const Column< Array< T >> &input, Column< T > &output)
template<typename T >
NEVER_INLINE HOST int32_t	array_copier__cpu_template (TableFunctionManager &mgr, const Column< Array< T >> &input, Column< Array< T >> &output)
template<typename T >
NEVER_INLINE HOST int32_t	array_concat__cpu_template (TableFunctionManager &mgr, const ColumnList< Array< T >> &inputs, Column< Array< T >> &output)
template<typename T >
NEVER_INLINE HOST int32_t	array_asarray__cpu_template (TableFunctionManager &mgr, const Column< T > &input, Column< Array< T >> &output)
template<typename T >
NEVER_INLINE HOST int32_t	array_split__cpu_template (TableFunctionManager &mgr, const Column< Array< T >> &input, Column< Array< T >> &first, Column< Array< T >> &second)
NEVER_INLINE HOST int32_t	tf_metadata_setter__cpu_template (TableFunctionManager &mgr, Column< bool > &success)
NEVER_INLINE HOST int32_t	tf_metadata_setter_repeated__cpu_template (TableFunctionManager &mgr, Column< bool > &success)
NEVER_INLINE HOST int32_t	tf_metadata_setter_size_mismatch__cpu_template (TableFunctionManager &mgr, Column< bool > &success)
NEVER_INLINE HOST int32_t	tf_metadata_getter__cpu_template (TableFunctionManager &mgr, const Column< bool > &input, Column< bool > &success)
NEVER_INLINE HOST int32_t	tf_metadata_getter_bad__cpu_template (TableFunctionManager &mgr, const Column< bool > &input, Column< bool > &success)
template<typename T >
NEVER_INLINE HOST int32_t	ct_overload_scalar_test__cpu_template (const T scalar, Column< T > &out)
template<typename T >
NEVER_INLINE HOST int32_t	ct_overload_column_test__cpu_template (const Column< T > &input, Column< T > &out)
template<typename T , typename K >
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)
template<typename T , typename K >
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)
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)

Macro Definition Documentation

#define CPU_DEVICE_CODE   0x637075;

Definition at line 27 of file TableFunctionsTesting.hpp.

Referenced by ct_device_selection_udtf_any(), ct_device_selection_udtf_both__cpu_(), and ct_device_selection_udtf_cpu__cpu_().

#define GPU_DEVICE_CODE   0x677075;

Definition at line 28 of file TableFunctionsTesting.hpp.

Referenced by ct_device_selection_udtf_any(), ct_device_selection_udtf_both__gpu_(), and ct_device_selection_udtf_gpu__gpu_().

Enumeration Type Documentation

enum TFAggType

Enumerator
MIN
MAX

Definition at line 1474 of file TableFunctionsTesting.hpp.

{ MIN, MAX };

Function Documentation

template<typename T >

NEVER_INLINE HOST int32_t array_asarray__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input,
		Column< Array< T >> &	output
	)

Definition at line 2189 of file TableFunctionsTesting.hpp.

References TableFunctionManager::getNewDictDbId(), TableFunctionManager::getNewDictId(), TableFunctionManager::getOrAddTransient(), TableFunctionManager::getString(), Column< T >::isNull(), TableFunctionManager::set_output_array_values_total_number(), TableFunctionManager::set_output_row_size(), Column< T >::setNull(), and Column< T >::size().

                                                                                {
  int size = input.size();
  int output_values_size = 0;
  for (int i = 0; i < size; i++) {
    output_values_size += (input.isNull(i) ? 0 : 1);
  }
  mgr.set_output_array_values_total_number(
      /*output column index=*/0,
      /*upper bound to the number of items in all output arrays=*/output_values_size);
  mgr.set_output_row_size(size);

  if constexpr (std::is_same<T, TextEncodingDict>::value) {
    for (int i = 0; i < size; i++) {
      if (input.isNull(i)) {
        output.setNull(i);
      } else {
        Array<T> arr = output.getItem(i, 1);
        arr[0] = mgr.getOrAddTransient(
            mgr.getNewDictDbId(),
            mgr.getNewDictId(),
            mgr.getString(input.getDictDbId(), input.getDictId(), input[i]));
      }
    }
  } else {
    for (int i = 0; i < size; i++) {
      if (input.isNull(i)) {
        output.setNull(i);
      } else {
        Array<T> arr = output.getItem(i, 1);
        arr[0] = input[i];
      }
    }
  }
  return size;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t array_concat__cpu_template	(	TableFunctionManager &	mgr,
		const ColumnList< Array< T >> &	inputs,
		Column< Array< T >> &	output
	)

Definition at line 2143 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_array_values_total_number(), and TableFunctionManager::set_output_row_size().

                                                                               {
  int size = inputs.size();

  int output_values_size = 0;
  for (int j = 0; j < inputs.numCols(); j++) {
    for (int i = 0; i < size; i++) {
      output_values_size += inputs[j][i].getSize();
    }
  }
  mgr.set_output_array_values_total_number(
      /*output column index=*/0,
      /*upper bound to the number of items in all output arrays=*/output_values_size);

  mgr.set_output_row_size(size);

  for (int i = 0; i < size; i++) {
    for (int j = 0; j < inputs.numCols(); j++) {
      Column<Array<T>> col = inputs[j];
      Array<T> arr = col[i];
      if constexpr (std::is_same<T, TextEncodingDict>::value) {
        if (col.getDictDbId() == output.getDictDbId() &&
            col.getDictId() == output.getDictId()) {
          output.concatItem(i, arr);
        } else {
          throw std::runtime_error(
              "concat of text encoding dict arrays with different dictionary ids is not "
              "implemented");
        }
      } else {
        output.concatItem(i,
                          arr);  // works only if i is the last row set, otherwise throws
      }
    }
  }
  return size;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t array_copier__cpu_template	(	TableFunctionManager &	mgr,
		const Column< Array< T >> &	input,
		Column< Array< T >> &	output
	)

Definition at line 2107 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_array_values_total_number(), TableFunctionManager::set_output_row_size(), and Column< T >::setNull().

                                                                               {
  int size = input.size();

  // count the number of items in all input arrays:
  int output_values_size = 0;
  for (int i = 0; i < size; i++) {
    output_values_size += input[i].getSize();
  }

  // set the size and allocate the output columns buffers:
  mgr.set_output_array_values_total_number(
      /*output column index=*/0,
      /*upper bound to the number of items in all output arrays=*/output_values_size);
  mgr.set_output_row_size(size);

  // set the items of output colums:
  for (int i = 0; i < size; i++) {
    if (input.isNull(i)) {
      output.setNull(i);
    } else {
      output.setItem(i, input[i]);
    }
  }

  return size;
}

Here is the call graph for this function:

template<typename T >

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 at line 2235 of file TableFunctionsTesting.hpp.

References Array< T >::getSize(), TableFunctionManager::set_output_array_values_total_number(), and TableFunctionManager::set_output_row_size().

                                                                              {
  int size = input.size();
  int first_values_size = 0;
  int second_values_size = 0;
  for (int i = 0; i < size; i++) {
    if (!input.isNull(i)) {
      int64_t sz = input[i].getSize();
      first_values_size += sz / 2;
      second_values_size += sz - sz / 2;
    }
  }
  mgr.set_output_array_values_total_number(0, first_values_size);
  mgr.set_output_array_values_total_number(1, second_values_size);
  mgr.set_output_row_size(size);

  for (int i = 0; i < size; i++) {
    if (input.isNull(i)) {
      first.setNull(i);
      second.setNull(i);
    } else {
      Array<T> arr = input[i];
      int64_t sz = arr.getSize();
      Array<T> arr1 = first.getItem(i, sz / 2);
      Array<T> arr2 = second.getItem(i, sz - sz / 2);
      for (int64_t j = 0; j < sz; j++) {
        if (j < sz / 2) {
          arr1[j] = arr[j];
        } else {
          arr2[j - sz / 2] = arr[j];
        }
      }
    }
  }
  return size;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t column_list_safe_row_sum__cpu_template	(	const ColumnList< T > &	input,
		Column< T > &	out
	)

Definition at line 1119 of file TableFunctionsTesting.hpp.

References ColumnList< T >::numCols(), safe_addition(), set_output_row_size(), heavydb.dtypes::T, and TABLE_FUNCTION_ERROR.

                                                                                   {
  int32_t output_num_rows = input.numCols();
  set_output_row_size(output_num_rows);
  for (int i = 0; i < output_num_rows; i++) {
    auto col = input[i];
    T s = 0;
    for (int j = 0; j < col.size(); j++) {
      try {
        s = safe_addition(s, col[j]);
      } catch (const std::exception& e) {
        return TABLE_FUNCTION_ERROR(e.what());
      } catch (...) {
        return TABLE_FUNCTION_ERROR("Unknown error");
      }
    }
    out[i] = s;
  }
  return output_num_rows;
}

Here is the call graph for this function:

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 at line 1403 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                                    {
  auto size = input1.size();
  mgr.set_output_row_size(size);
  for (int32_t i = 0; i < size; i++) {
    output1[i] = input1[i] + size;
    output2[i] = input2[i] * alpha;
  }
  return size;
}

Here is the call graph for this function:

template<typename T , typename U , typename K >

NEVER_INLINE HOST int32_t ct_binding_column2__cpu_template	(	const Column< T > &	input1,
		const Column< U > &	input2,
		Column< K > &	out
	)

Definition at line 828 of file TableFunctionsTesting.hpp.

References set_output_row_size(), and Column< T >::size().

                                                                           {
  if constexpr (std::is_same<T, TextEncodingDict>::value &&
                std::is_same<U, TextEncodingDict>::value) {
    set_output_row_size(input1.size());
    for (int64_t i = 0; i < input1.size(); i++) {
      out[i] = input1[i];
    }
    return input1.size();
  }

  set_output_row_size(1);
  if constexpr (std::is_same<T, int32_t>::value && std::is_same<U, double>::value) {
    out[0] = 10;
  } else if constexpr (std::is_same<T, double>::value && std::is_same<U, double>::value) {
    out[0] = 20;
  } else if constexpr (std::is_same<T, int32_t>::value &&
                       std::is_same<U, int32_t>::value) {
    out[0] = 30;
  } else if constexpr (std::is_same<T, double>::value &&
                       std::is_same<U, int32_t>::value) {
    out[0] = 40;
  }
  return 1;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_binding_column__cpu_template	(	const Column< T > &	input,
		Column< int32_t > &	out
	)

Definition at line 581 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                                {
  set_output_row_size(1);
  if constexpr (std::is_same<T, int32_t>::value) {
    out[0] = 10;
  } else {
    out[0] = 20;
  }
  return 1;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_binding_columnlist__cpu_template	(	const Column< T > &	input1,
		const ColumnList< T > &	input2,
		Column< int32_t > &	out
	)

Definition at line 553 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                                    {
  set_output_row_size(1);
  if constexpr (std::is_same<T, int32_t>::value) {
    out[0] = 1;
  } else if constexpr (std::is_same<T, float>::value) {
    out[0] = 2;
  } else if constexpr (std::is_same<T, TextEncodingDict>::value) {
    out[0] = 3;
  } else {
    out[0] = 4;
  }
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded1__cpu_1	(	const Column< TextEncodingDict > &	input,
		const int32_t	multiplier,
		Column< TextEncodingDict > &	out
	)

Definition at line 447 of file TableFunctionsTesting.hpp.

References Column< TextEncodingDict >::size().

                                                               {
  for (int64_t i = 0; i < input.size(); i++) {
    out[i] = input[i];  // assign string id
  }
  return multiplier * input.size();
}

Here is the call graph for this function:

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 at line 457 of file TableFunctionsTesting.hpp.

References set_output_row_size(), and Column< TextEncodingDict >::size().

                                                                {
  set_output_row_size(input1.size());
  for (int64_t i = 0; i < input1.size(); i++) {
    out1[i] = input1[i];
    out2[i] = input2[i];
  }
  return input1.size();
}

Here is the call graph for this function:

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 at line 470 of file TableFunctionsTesting.hpp.

References set_output_row_size(), and Column< TextEncodingDict >::size().

                                                                {
  set_output_row_size(input1.size());
  for (int64_t i = 0; i < input1.size(); i++) {
    out1[i] = input2[i];
    out2[i] = input1[i];
  }
  return input1.size();
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded4__cpu_1	(	const ColumnList< TextEncodingDict > &	input,
		Column< TextEncodingDict > &	out
	)

Definition at line 483 of file TableFunctionsTesting.hpp.

References set_output_row_size(), and ColumnList< TextEncodingDict >::size().

                                                               {
  int64_t sz = input[0].size();
  set_output_row_size(sz);
  for (int64_t i = 0; i < sz; i++) {
    out[i] = input[0][i];
  }
  return sz;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded5__cpu_1	(	const ColumnList< TextEncodingDict > &	input,
		Column< TextEncodingDict > &	out
	)

Definition at line 494 of file TableFunctionsTesting.hpp.

References set_output_row_size(), and ColumnList< TextEncodingDict >::size().

                                                               {
  int64_t sz = input[1].size();
  set_output_row_size(sz);
  for (int64_t i = 0; i < sz; i++) {
    out[i] = input[1][i];
  }
  return sz;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_binding_dict_encoded6__cpu_1	(	const ColumnList< TextEncodingDict > &	input,
		Column< TextEncodingDict > &	out0,
		Column< TextEncodingDict > &	out1
	)

Definition at line 505 of file TableFunctionsTesting.hpp.

References set_output_row_size(), and ColumnList< TextEncodingDict >::size().

                                                                {
  int64_t sz = input[0].size();
  set_output_row_size(sz);
  for (int64_t i = 0; i < sz; i++) {
    out0[i] = input[0][i];
    out1[i] = input[1][i];
  }
  return sz;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_binding_scalar_multiply__cpu_template	(	const Column< T > &	input,
		const T	multiplier,
		Column< T > &	out
	)

Definition at line 606 of file TableFunctionsTesting.hpp.

References Column< T >::isNull(), set_output_row_size(), Column< T >::setNull(), and Column< T >::size().

                                                                                   {
  const int64_t num_rows = input.size();
  set_output_row_size(num_rows);
  for (int64_t r = 0; r < num_rows; ++r) {
    if (!input.isNull(r)) {
      out[r] = input[r] * multiplier;
    } else {
      out.setNull(r);
    }
  }
  return num_rows;
}

Here is the call graph for this function:

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 at line 646 of file TableFunctionsTesting.hpp.

References ColumnList< TextEncodingDict >::numCols(), set_output_row_size(), Column< TextEncodingDict >::setNull(), and ColumnList< TextEncodingDict >::size().

                                                                     {
  const int64_t num_rows = input_strings.size();
  const int64_t num_cols = input_strings.numCols();
  set_output_row_size(num_rows);
  for (int64_t r = 0; r < num_rows; r++) {
    bool are_equal = true;
    if (num_cols > 0) {
      std::string first_str = input_strings[0].getString(r);
      for (int64_t c = 1; c != num_cols; ++c) {
        if (input_strings[c].getString(r) != first_str) {
          are_equal = false;
          break;
        }
      }
      strings_are_equal[r] = are_equal;
      if (are_equal && num_cols > 0) {
        string_if_equal[r] = input_strings[0][r];
      } else {
        string_if_equal.setNull(r);
      }
    }
  }
  return num_rows;
}

Here is the call graph for this function:

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 at line 627 of file TableFunctionsTesting.hpp.

References Column< TextEncodingDict >::getString(), set_output_row_size(), Column< T >::size(), and Column< TextEncodingDict >::size().

                                                               {
  const int64_t num_rows = input_str.size();
  set_output_row_size(num_rows);
  for (int64_t i = 0; i < num_rows; i++) {
    out_str[i] = input_str[i];
    const std::string str = input_str.getString(i);
    out_size[i] = str.size();
  }
  return num_rows;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_binding_template__cpu_template	(	const Column< T > &	input,
		Column< T > &	out
	)

Definition at line 530 of file TableFunctionsTesting.hpp.

References set_output_row_size(), and Column< T >::size().

                                                                            {
  set_output_row_size(input.size());
  for (int64_t i = 0; i < input.size(); i++) {
    out[i] = input[i];
  }
  return input.size();
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf2__cpu_21	(	const int32_t	multiplier,
		const Column< int32_t > &	input1,
		Column< int32_t > &	out
	)

Definition at line 277 of file TableFunctionsTesting.hpp.

                                                                               {
  out[0] = 1000 + 91 + multiplier;
  return 1;
}

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 at line 306 of file TableFunctionsTesting.hpp.

                                                                               {
  out[0] = 1000 + 169 + multiplier + 10 * input2;
  return 1;
}

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 at line 291 of file TableFunctionsTesting.hpp.

                                               {
  out[0] = 1000 + 396 + multiplier + 10 * input2;
  return 1;
}

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 at line 299 of file TableFunctionsTesting.hpp.

                                               {
  out[0] = 1000 + 369 + multiplier + 10 * input2;
  return 1;
}

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 at line 283 of file TableFunctionsTesting.hpp.

                                                                               {
  out[0] = 1000 + 196 + multiplier + 10 * input2;
  return 1;
}

EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf__cpu_11	(	const Column< int32_t > &	input1,
		const int32_t	multiplier,
		Column< int32_t > &	out
	)

Definition at line 202 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 19 + multiplier;
  return 1;
}

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 at line 208 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 119 + multiplier;
  return 1;
}

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 at line 215 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 1119 + multiplier;
  return 1;
}

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 at line 223 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 2119 + multiplier;
  return 1;
}

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 at line 231 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 2219 + multiplier;
  return 1;
}

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 at line 239 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 2129 + multiplier;
  return 1;
}

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 at line 247 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 139 + multiplier;
  return 1;
}

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 at line 254 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 329 + multiplier;
  return 1;
}

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 at line 261 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 349 + multiplier;
  return 1;
}

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 at line 268 of file TableFunctionsTesting.hpp.

                                                                              {
  out[0] = 1000 + 2429 + multiplier;
  return 1;
}

EXTENSION_NOINLINE_HOST int32_t ct_binding_udtf_constant__cpu_1	(	const Column< int32_t > &	input1,
		Column< int32_t > &	out
	)

Definition at line 129 of file TableFunctionsTesting.hpp.

                                                                                     {
  out[0] = 1;
  return 1;
}

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 at line 194 of file TableFunctionsTesting.hpp.

                                                       {
  out[0] = 242;
  return 1;
}

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 at line 134 of file TableFunctionsTesting.hpp.

                                                      {
  out[0] = 11;
  return 1;
}

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 at line 141 of file TableFunctionsTesting.hpp.

                                                      {
  out[0] = 111;
  return 1;
}

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 at line 149 of file TableFunctionsTesting.hpp.

                                                      {
  out[0] = 211;
  return 1;
}

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 at line 157 of file TableFunctionsTesting.hpp.

                                                      {
  out[0] = 221;
  return 1;
}

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 at line 165 of file TableFunctionsTesting.hpp.

                                                      {
  out[0] = 212;
  return 1;
}

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 at line 173 of file TableFunctionsTesting.hpp.

                                                      {
  out[0] = 13;
  return 1;
}

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 at line 180 of file TableFunctionsTesting.hpp.

                                                      {
  out[0] = 32;
  return 1;
}

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 at line 187 of file TableFunctionsTesting.hpp.

                                                      {
  out[0] = 34;
  return 1;
}

EXTENSION_NOINLINE_HOST int32_t ct_copy_and_add_size	(	TableFunctionManager &	mgr,
		const Column< int32_t > &	input,
		Column< int32_t > &	output
	)

Definition at line 1393 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                              {
  mgr.set_output_row_size(input.size());
  for (int32_t i = 0; i < input.size(); i++) {
    output[i] = input[i] + input.size();
  }
  return output.size();
}

Here is the call graph for this function:

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 at line 1898 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                               {
  const int32_t num_rows = input_arg1.size();
  mgr.set_output_row_size(num_rows);
  for (int32_t r = 0; r < num_rows; ++r) {
    out1[r] = input_arg1[r] + arg1;
    out2[r] = input_arg2[r] + arg2;
  }
  return num_rows;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_device_selection_udtf_any	(	const Column< int32_t > &	input,
		Column< int64_t > &	out
	)

Definition at line 41 of file TableFunctionsTesting.hpp.

References CPU_DEVICE_CODE, and GPU_DEVICE_CODE.

                                                                                         {
#ifdef __CUDACC__
  out[0] = GPU_DEVICE_CODE;
#else
  out[0] = CPU_DEVICE_CODE;
#endif
  return 1;
}

EXTENSION_NOINLINE_HOST int32_t ct_device_selection_udtf_both__cpu_	(	const Column< int32_t > &	input,
		Column< int64_t > &	out
	)

Definition at line 71 of file TableFunctionsTesting.hpp.

References CPU_DEVICE_CODE.

                                                                  {
  out[0] = CPU_DEVICE_CODE;
  return 1;
}

EXTENSION_NOINLINE int32_t ct_device_selection_udtf_both__gpu_	(	const Column< int32_t > &	input,
		Column< int64_t > &	out
	)

Definition at line 80 of file TableFunctionsTesting.hpp.

References GPU_DEVICE_CODE.

                                                                  {
  out[0] = GPU_DEVICE_CODE;
  return 1;
}

EXTENSION_NOINLINE_HOST int32_t ct_device_selection_udtf_cpu__cpu_	(	const Column< int32_t > &	input,
		Column< int64_t > &	out
	)

Definition at line 53 of file TableFunctionsTesting.hpp.

References CPU_DEVICE_CODE.

                                                                 {
  out[0] = CPU_DEVICE_CODE;
  return 1;
}

EXTENSION_NOINLINE int32_t ct_device_selection_udtf_gpu__gpu_	(	const Column< int32_t > &	input,
		Column< int64_t > &	out
	)

Definition at line 62 of file TableFunctionsTesting.hpp.

References GPU_DEVICE_CODE.

                                                                 {
  out[0] = GPU_DEVICE_CODE;
  return 1;
}

template<typename T >

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 at line 1190 of file TableFunctionsTesting.hpp.

References TextEncodingNone::size(), and Column< T >::size().

                                                                                    {
  const int32_t str_len = str.size();
  // Note: we assume RowMultiplier is 1 for this test, was to make running on
  // GPU easy Todo: Provide Constant RowMultiplier interface
  if (multiplier != 1) {
    return 0;
  }
  const int32_t num_input_rows = indices.size();
  const int32_t num_output_rows = num_input_rows * multiplier;

#ifdef __CUDACC__
  const int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
  const int32_t step = blockDim.x * gridDim.x;
#else
  const int32_t start = 0;
  const int32_t step = 1;
#endif

  for (int32_t i = start; i < num_output_rows; i += step) {
    idx[i] = indices[i % num_output_rows];
    char_bytes[i] = str[i % str_len];  // index < str_len ? str[i] : 0;
  }
  return num_output_rows;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_gpu_default_init__gpu_

(

Column< int32_t > &

output_buffer

)

Definition at line 1147 of file TableFunctionsTesting.hpp.

                                                                                     {
  // output_buffer[0] should always be 0 due to default initialization for GPU
  return 1;
}

EXTENSION_NOINLINE int32_t ct_hamming_distance	(	const TextEncodingNone &	str1,
		const TextEncodingNone &	str2,
		Column< int32_t > &	hamming_distance
	)

Definition at line 1158 of file TableFunctionsTesting.hpp.

References Column< T >::ptr_, and TextEncodingNone::size().

                                                                                  {
  const int32_t str_len = str1.size() <= str2.size() ? str1.size() : str2.size();

#ifdef __CUDACC__
  const int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
  const int32_t step = blockDim.x * gridDim.x;
  int32_t* output_ptr = hamming_distance.ptr_;
#else
  const int32_t start = 0;
  const int32_t step = 1;
#endif

  int32_t num_chars_unequal = 0;
  for (int32_t i = start; i < str_len; i += step) {
    num_chars_unequal += (str1[i] != str2[i]) ? 1 : 0;
  }
#ifdef __CUDACC__
  atomicAdd(output_ptr, num_chars_unequal);
#else
  hamming_distance[0] = num_chars_unequal;
#endif
  return 1;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_named_const_output__cpu_template	(	const Column< T > &	input,
		Column< T > &	out
	)

Definition at line 881 of file TableFunctionsTesting.hpp.

References Column< T >::size(), and heavydb.dtypes::T.

                                                                              {
  T acc1 = 0, acc2 = 0;
  for (int64_t i = 0; i < input.size(); i++) {
    if (i % 2 == 0) {
      acc1 += input[i];
    } else {
      acc2 += input[i];
    }
  }
  out[0] = acc1;
  out[1] = acc2;
  return 2;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_named_output__cpu_template	(	const Column< T > &	input,
		Column< T > &	out
	)

Definition at line 869 of file TableFunctionsTesting.hpp.

References set_output_row_size(), Column< T >::size(), and heavydb.dtypes::T.

                                                                        {
  set_output_row_size(1);
  T acc = 0;
  for (int64_t i = 0; i < input.size(); i++) {
    acc += input[i];
  }
  out[0] = acc;
  return 1;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_named_rowmul_output__cpu_template	(	const Column< T > &	input,
		int32_t	m,
		Column< T > &	out
	)

Definition at line 910 of file TableFunctionsTesting.hpp.

References Column< T >::size().

                                                                               {
  for (int64_t j = 0; j < m; j++) {
    for (int64_t i = 0; i < input.size(); i++) {
      out[j * input.size() + i] += input[i];
    }
  }
  return m * input.size();
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_named_user_const_output__cpu_template	(	const Column< T > &	input,
		int32_t	c,
		Column< T > &	out
	)

Definition at line 897 of file TableFunctionsTesting.hpp.

References Column< T >::size().

                                                                                   {
  for (int64_t i = 0; i < c; i++) {
    out[i] = 0;
  }
  for (int64_t i = 0; i < input.size(); i++) {
    out[i % c] += input[i];
  }
  return c;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_no_arg_constant_sizing

(

Column< int32_t > &

answer

)

Definition at line 946 of file TableFunctionsTesting.hpp.

                                                                              {
#ifdef __CUDACC__
  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
  int32_t stop = static_cast<int32_t>(42);
  int32_t step = blockDim.x * gridDim.x;
#else
  auto start = 0;
  auto stop = 42;
  auto step = 1;
#endif
  for (auto i = start; i < stop; i += step) {
    answer[i] = 42 * i;
  }
  return 42;
}

template<typename T >

NEVER_INLINE HOST int32_t ct_no_arg_runtime_sizing__cpu_template

(

Column< T > &

answer

)

Definition at line 932 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                                    {
  set_output_row_size(1);
  answer[0] = 42;
  return 1;
}

Here is the call graph for this function:

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 at line 1020 of file TableFunctionsTesting.hpp.

                                                                {
  for (int32_t i = 0; i < c; i++) {
    output[i] = input_num;
  }
  return c;
}

template<typename T , typename K >

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 at line 2468 of file TableFunctionsTesting.hpp.

References ColumnList< T >::numCols(), set_output_row_size(), Column< T >::size(), and heavydb.dtypes::T.

                                                            {
  set_output_row_size(1);
  int64_t num_cols = col_list1.numCols();
  K sum = 0;
  for (int64_t i = 0; i < num_cols; ++i) {
    const Column<K>& col = col_list1[i];
    for (int64_t j = 0; j < col.size(); ++j) {
      sum += col[j];
    }
  }

  int64_t num_cols2 = col_list2.numCols();
  T sum2 = 0;
  for (int64_t i = 0; i < num_cols2; ++i) {
    const Column<T>& col = col_list2[i];
    for (int64_t j = 0; j < col.size(); ++j) {
      sum2 += col[j];
    }
  }

  if (sum + sum2 > 0) {
    out[0] = first_col[0];
  } else {
    out[0] = last_col[0];
  }
  return 1;
}

Here is the call graph for this function:

template<typename T , typename K >

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 at line 2443 of file TableFunctionsTesting.hpp.

References ColumnList< T >::numCols(), set_output_row_size(), Column< T >::size(), and heavydb.dtypes::T.

                                                           {
  set_output_row_size(1);
  int64_t num_cols = col_list.numCols();
  T sum = 0;
  for (int64_t i = 0; i < num_cols; ++i) {
    const Column<T>& col = col_list[i];
    for (int64_t j = 0; j < col.size(); ++j) {
      sum += col[j];
    }
  }
  if (sum > 0) {
    out[0] = first_col[0];
  } else {
    out[0] = last_col[0];
  }
  return 1;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_overload_column_test__cpu_template	(	const Column< T > &	input,
		Column< T > &	out
	)

Definition at line 2425 of file TableFunctionsTesting.hpp.

References Column< T >::isNull(), set_output_row_size(), Column< T >::setNull(), and Column< T >::size().

                                                                                {
  int64_t size = input.size();
  set_output_row_size(size);
  for (int64_t i = 0; i < size; ++i) {
    if (input.isNull(i)) {
      out.setNull(i);
    } else {
      out[i] = input[i];
    }
  }
  return size;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_overload_scalar_test__cpu_template	(	const T	scalar,
		Column< T > &	out
	)

Definition at line 2411 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                                {
  set_output_row_size(1);
  if constexpr (std::is_same<T, int64_t>::value) {
    out[0] = scalar;
  } else if constexpr (std::is_same<T, Timestamp>::value) {
    out[0] = scalar.time;
  }
  return 1;
}

Here is the call graph for this function:

template<typename K , typename T , typename Z >

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 at line 1542 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                                    {
  const int64_t input_size = input_id.size();
  mgr.set_output_row_size(input_size);
  for (int64_t input_idx = 0; input_idx < input_size; ++input_idx) {
    output_id[input_idx] = input_id[input_idx];
    output_x[input_idx] = input_x[input_idx];
    output_y[input_idx] = input_y[input_idx];
    output_z[input_idx] = input_z[input_idx];
  }
  return input_size;
}

Here is the call graph for this function:

template<typename K , typename T , typename Z >

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 at line 1509 of file TableFunctionsTesting.hpp.

References get_min_or_max(), TextEncodingNone::getString(), MAX, MIN, TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                     {
  const std::string agg_type_str = agg_type.getString();
  const TFAggType min_or_max = agg_type_str == "MIN" ? TFAggType::MIN : TFAggType::MAX;
  mgr.set_output_row_size(1);
  output_row_count[0] = input_id.size();
  output_id[0] = get_min_or_max(input_id, min_or_max);
  output_x[0] = get_min_or_max(input_x, min_or_max);
  output_y[0] = get_min_or_max(input_y, min_or_max);
  output_z[0] = get_min_or_max(input_z, min_or_max);
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_require__cpu_	(	const Column< int32_t > &	input1,
		const int32_t	i,
		Column< int32_t > &	out
	)

Definition at line 1673 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                       {
  set_output_row_size(1);
  out[0] = 3;
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_require_and__cpu_	(	const Column< int32_t > &	input1,
		const int32_t	i,
		Column< int32_t > &	out
	)

Definition at line 1711 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                           {
  set_output_row_size(1);
  out[0] = 7;
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_require_mgr	(	TableFunctionManager &	mgr,
		const Column< int32_t > &	input1,
		const int32_t	i,
		Column< int32_t > &	out
	)

Definition at line 1689 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                     {
  set_output_row_size(1);
  out[0] = 4;
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_require_or_str__cpu_	(	const Column< int32_t > &	input1,
		const TextEncodingNone &	i,
		Column< int32_t > &	out
	)

Definition at line 1719 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                              {
  set_output_row_size(1);
  out[0] = 8;
  return 1;
}

Here is the call graph for this function:

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 at line 2508 of file TableFunctionsTesting.hpp.

                                                                        {
  out[0] = 0;
  return 1;
}

EXTENSION_NOINLINE_HOST int32_t ct_require_str__cpu_	(	const Column< int32_t > &	input1,
		const TextEncodingNone &	s,
		Column< int32_t > &	out
	)

Definition at line 1681 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                           {
  set_output_row_size(1);
  out[0] = 3;
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_require_str_diff__cpu_	(	const Column< int32_t > &	input1,
		const TextEncodingNone &	i,
		Column< int32_t > &	out
	)

Definition at line 1727 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                                {
  set_output_row_size(1);
  out[0] = 9;
  return 1;
}

Here is the call graph for this function:

template<typename T , typename K >

NEVER_INLINE HOST int32_t ct_require_templating__cpu_template	(	const Column< T > &	input1,
		const int32_t	i,
		Column< K > &	out
	)

Definition at line 1699 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                                              {
  set_output_row_size(1);
  if constexpr (std::is_same<T, int32_t>::value) {
    out[0] = 5;
  } else if constexpr (std::is_same<T, double>::value) {
    out[0] = 6.0;
  }
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_require_text_enc_dict__cpu_	(	const Column< TextEncodingDict > &	input,
		const int64_t	x,
		Column< int64_t > &	out
	)

Definition at line 1736 of file TableFunctionsTesting.hpp.

References set_output_row_size().

                                                     {
  set_output_row_size(1);
  out[0] = 10;
  return 1;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_scalar_1_arg_runtime_sizing__cpu_template	(	const T	num,
		Column< T > &	answer
	)

Definition at line 972 of file TableFunctionsTesting.hpp.

References set_output_row_size(), and heavydb.dtypes::T.

                                                                             {
  T quotient = num;
  set_output_row_size(30);
  int32_t counter{0};
  while (quotient >= 1) {
    answer[counter++] = quotient;
    quotient /= 10;
  }
  return counter;
}

Here is the call graph for this function:

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 at line 991 of file TableFunctionsTesting.hpp.

                                                                                      {
#ifdef __CUDACC__
  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
  int32_t stop = static_cast<int32_t>(5);
  int32_t step = blockDim.x * gridDim.x;
#else
  auto start = 0;
  auto stop = 5;
  auto step = 1;
#endif
  for (auto i = start; i < stop; i += step) {
    answer1[i] = num1 + i * num2;
    answer2[i] = num1 - i * num2;
  }
  return 5;
}

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 at line 1882 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size().

                                                                   {
  mgr.set_output_row_size(1);
  out1[0] = arg1;
  out2[0] = arg2;
  return 1;
 }

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_sleep1__cpu_	(	int32_t	seconds,
		int32_t	mode,
		Column< int32_t > &	output
	)

Definition at line 1293 of file TableFunctionsTesting.hpp.

References ct_sleep_worker(), TableFunctionManager::get_singleton(), set_output_row_size(), Column< T >::size(), and TABLE_FUNCTION_ERROR.

                                                                         {
  switch (mode) {
    case 0: {
      set_output_row_size(3);  // uses global singleton of TableFunctionManager
      break;
    }
    case 1: {
      auto* mgr = TableFunctionManager::get_singleton();
      mgr->set_output_row_size(3);
      break;
    }
    case 2:
    case 3: {
      break;
    }
    default:
      return TABLE_FUNCTION_ERROR("unexpected mode");
  }
  if (output.size() == 0) {
    return TABLE_FUNCTION_ERROR("unspecified output columns row size");
  }
  return ct_sleep_worker(seconds, output);
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_sleep2	(	TableFunctionManager &	mgr,
		int32_t	seconds,
		int32_t	mode,
		Column< int32_t > &	output
	)

Definition at line 1319 of file TableFunctionsTesting.hpp.

References ct_sleep_worker(), TableFunctionManager::get_singleton(), TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                   {
  switch (mode) {
    case 0:
    case 1: {
      mgr.set_output_row_size(3);  // uses thread-safe TableFunctionManager instance
      break;
    }
    case 2: {
      break;
    }
    case 3: {
      try {
        auto* mgr0 = TableFunctionManager::get_singleton();  // it may throw "singleton is
                                                             // not initialized"
        mgr0->set_output_row_size(3);
      } catch (std::exception& e) {
        return mgr.ERROR_MESSAGE(e.what());
      }
      break;
    }
    default:
      return mgr.ERROR_MESSAGE("unexpected mode");
  }
  if (output.size() == 0) {
    return mgr.ERROR_MESSAGE("unspecified output columns row size");
  }
  return ct_sleep_worker(seconds, output);
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_sleep_worker	(	int32_t	seconds,
		Column< int32_t > &	output
	)

Definition at line 1275 of file TableFunctionsTesting.hpp.

Referenced by ct_sleep1__cpu_(), and ct_sleep2().

                                                                                     {
  // save entering time
  output[0] = std::chrono::duration_cast<std::chrono::milliseconds>(
                  std::chrono::system_clock::now().time_since_epoch())
                  .count() &
              0xffffff;
  // store thread id info
  output[2] = std::hash<std::thread::id>()(std::this_thread::get_id()) & 0xffff;
  // do "computations" for given seconds
  std::this_thread::sleep_for(std::chrono::seconds(seconds));
  // save leaving time
  output[1] = std::chrono::duration_cast<std::chrono::milliseconds>(
                  std::chrono::system_clock::now().time_since_epoch())
                  .count() &
              0xffffff;
  return 3;
}

Here is the caller graph for this function:

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 at line 1425 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                  {
  // sorted set of common coordinates:
  std::set<int32_t, std::less<int32_t>> x12;
  // inverse map of coordinates and indices, keys are sorted:
  std::map<int32_t, int32_t, std::less<int32_t>> i1, i2;

  for (int32_t i = 0; i < x1.size(); i++) {
    i1[x1[i]] = i;
    x12.insert(x1[i]);
  }
  for (int32_t i = 0; i < x2.size(); i++) {
    i2[x2[i]] = i;
    x12.insert(x2[i]);
  }
  auto size = x12.size();

  mgr.set_output_row_size(size);
  int32_t k = 0;
  for (auto x_ : x12) {
    x[k] = x_;
    auto i1_ = i1.find(x_);
    auto i2_ = i2.find(x_);
    if (i1_ != i1.end()) {
      if (i2_ != i2.end()) {
        d[k] = d1[i1_->second] + d2[i2_->second];
      } else {
        d[k] = d1[i1_->second] + f2;
      }
    } else if (i2_ != i2.end()) {
      d[k] = f1 + d2[i2_->second];
    } else {
      d[k] = f1 + f2;
    }
    d[k] *= size;
    k++;
  }
  return size;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_string_concat__cpu_	(	TableFunctionManager &	mgr,
		const ColumnList< TextEncodingDict > &	input_strings,
		const TextEncodingNone &	separator,
		Column< TextEncodingDict > &	concatted_string
	)

Definition at line 702 of file TableFunctionsTesting.hpp.

References Column< TextEncodingDict >::getOrAddTransient(), TextEncodingNone::getString(), ColumnList< TextEncodingDict >::numCols(), TableFunctionManager::set_output_row_size(), Column< TextEncodingDict >::setNull(), and ColumnList< TextEncodingDict >::size().

                                                                           {
  const int64_t num_rows = input_strings.size();
  const int64_t num_cols = input_strings.numCols();
  const std::string separator_str{separator.getString()};
  mgr.set_output_row_size(num_rows);
  for (int64_t row_idx = 0; row_idx < num_rows; row_idx++) {
    if (num_cols > 0) {
      std::string concatted_output{input_strings[0].getString(row_idx)};
      for (int64_t col_idx = 1; col_idx < num_cols; ++col_idx) {
        concatted_output += separator_str;
        concatted_output += input_strings[col_idx].getString(row_idx);
      }
      const TextEncodingDict concatted_str_id =
          concatted_string.getOrAddTransient(concatted_output);
      concatted_string[row_idx] = concatted_str_id;
    } else {
      concatted_string.setNull(row_idx);
    }
  }
  return num_rows;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_string_to_chars__cpu_	(	const TextEncodingNone &	input,
		Column< int32_t > &	char_idx,
		Column< int8_t > &	char_bytes
	)

Definition at line 1230 of file TableFunctionsTesting.hpp.

References TextEncodingNone::getString(), and set_output_row_size().

                                                                                     {
  const std::string str{input.getString()};
  const int64_t str_size(str.size());
  set_output_row_size(str_size);
  for (int32_t i = 0; i < str_size; ++i) {
    char_idx[i] = i;
    char_bytes[i] = str[i];
  }
  return str_size;
}

Here is the call graph for this function:

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 at line 680 of file TableFunctionsTesting.hpp.

References Column< TextEncodingDict >::getOrAddTransient(), Column< TextEncodingDict >::getString(), TableFunctionManager::set_output_row_size(), Column< TextEncodingDict >::size(), and substring().

                                                                 {
  const int64_t num_rows = input_str.size();
  mgr.set_output_row_size(num_rows);
  for (int64_t row_idx = 0; row_idx < num_rows; row_idx++) {
    const std::string input_string{input_str.getString(row_idx)};
    const std::string substring = input_string.substr(pos[row_idx], len[row_idx]);
    const TextEncodingDict substr_id = output_substr.getOrAddTransient(substring);
    output_substr[row_idx] = substr_id;
  }
  return num_rows;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_synthesize_new_dict__cpu_	(	TableFunctionManager &	mgr,
		const int64_t	num_strings,
		Column< TextEncodingDict > &	new_dict_col
	)

Definition at line 733 of file TableFunctionsTesting.hpp.

References Column< TextEncodingDict >::getOrAddTransient(), TableFunctionManager::set_output_row_size(), and to_string().

                                                                             {
  mgr.set_output_row_size(num_strings);
  for (int32_t s = 0; s < num_strings; ++s) {
    const std::string new_string = "String_" + std::to_string(s);
    const int32_t string_id = new_dict_col.getOrAddTransient(new_string);
    new_dict_col[s] = string_id;
  }
  return num_strings;
}

Here is the call graph for this function:

template<typename T >

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 at line 1041 of file TableFunctionsTesting.hpp.

                                                                            {
  for (int32_t i = 0; i < c; i++) {
    output[i] = input_num;
  }
  return c;
}

EXTENSION_NOINLINE int32_t ct_test_nullable	(	const Column< int32_t > &	input,
		const int32_t	i,
		Column< int32_t > &	out
	)

Definition at line 1789 of file TableFunctionsTesting.hpp.

References Column< T >::setNull(), and Column< T >::size().

                                                                  {
  for (int i = 0; i < input.size(); i++) {
    if (i % 2 == 0) {
      out.setNull(i);
    } else {
      out[i] = input[i];
    }
  }
  return input.size();
}

Here is the call graph for this function:

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 at line 1861 of file TableFunctionsTesting.hpp.

References ColumnList< T >::numCols(), TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                {
  mgr.set_output_row_size(lst.numCols() + 1);
  out[0] = col[1];
  for (int i = 0; i < lst.numCols(); i++) {
    out[i + 1] = lst[i][1];
  }
  return out.size();
}

Here is the call graph for this function:

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 at line 1837 of file TableFunctionsTesting.hpp.

References ColumnList< T >::numCols(), TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                 {
  mgr.set_output_row_size(lst.numCols() + 1);
  out[0] = col[0];
  for (int i = 0; i < lst.numCols(); i++) {
    out[i + 1] = lst[i][0];
  }
  return out.size();
}

Here is the call graph for this function:

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 at line 1809 of file TableFunctionsTesting.hpp.

References Column< T >::size().

                                                                         {
  out[0] = 123;
  out[1] = 456;
  return out.size();
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_test_preflight_sizer_const	(	const Column< int32_t > &	input,
		Column< int32_t > &	out
	)

Definition at line 1818 of file TableFunctionsTesting.hpp.

References Column< T >::size().

                                                                               {
  out[0] = 789;
  out[1] = 321;
  return out.size();
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_throw_if_gt_100__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input,
		Column< T > &	output
	)

Definition at line 1358 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                              {
  int64_t num_rows = input.size();
  mgr.set_output_row_size(num_rows);
  for (int64_t r = 0; r < num_rows; ++r) {
    if (input[r] > 100) {
      return mgr.ERROR_MESSAGE("Values greater than 100 not allowed");
    }
    output[r] = input[r];
  }
  return num_rows;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_timestamp_add_interval__template	(	TableFunctionManager &	mgr,
		const Column< Timestamp > &	input,
		const T	inter,
		Column< Timestamp > &	out
	)

Definition at line 2040 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                            {
  int size = input.size();
  mgr.set_output_row_size(size);
  for (int i = 0; i < size; ++i) {
    out[i] = inter + input[i];
  }
  return size;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t ct_timestamp_add_offset	(	TableFunctionManager &	mgr,
		const Column< Timestamp > &	input,
		const Timestamp	offset,
		Column< Timestamp > &	out
	)

Definition at line 1967 of file TableFunctionsTesting.hpp.

References Column< T >::isNull(), TableFunctionManager::set_output_row_size(), Column< T >::setNull(), and Column< T >::size().

                                                                                {
  int size = input.size();
  mgr.set_output_row_size(size);
  for (int i = 0; i < size; ++i) {
    if (input.isNull(i)) {
      out.setNull(i);
    } else {
      out[i] = input[i] + offset;
    }
  }
  return size;
}

Here is the call graph for this function:

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 at line 2003 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size().

                                                     {
  mgr.set_output_row_size(1);
  out[0] = 1;
  return 1;
}

Here is the call graph for this function:

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 at line 1927 of file TableFunctionsTesting.hpp.

References Column< T >::isNull(), TableFunctionManager::set_output_row_size(), Column< T >::setNull(), and Column< T >::size().

                                                                         {
  int size = input.size();
  mgr.set_output_row_size(size);
  for (int i = 0; i < size; ++i) {
    if (input.isNull(i)) {
      ns.setNull(i);
      us.setNull(i);
      ms.setNull(i);
      s.setNull(i);
      m.setNull(i);
      h.setNull(i);
      d.setNull(i);
      mo.setNull(i);
      y.setNull(i);
    } else {
      ns[i] = input[i].getNanoseconds();
      us[i] = input[i].getMicroseconds();
      ms[i] = input[i].getMilliseconds();
      s[i] = input[i].getSeconds();
      m[i] = input[i].getMinutes();
      h[i] = input[i].getHours();
      d[i] = input[i].getDay();
      mo[i] = input[i].getMonth();
      y[i] = input[i].getYear();
    }
  }
  return size;
}

Here is the call graph for this function:

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 at line 1985 of file TableFunctionsTesting.hpp.

References Column< T >::isNull(), Column< T >::setNull(), and Column< T >::size().

                                                                   {
  int size = input.size();
  for (int i = 0; i < size; ++i) {
    if (input.isNull(i)) {
      out.setNull(i);
    } else {
      out[i] = input[i] + input2[i] + Timestamp(dummy);
    }
  }
  return size;
}

Here is the call graph for this function:

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 at line 2012 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), and Column< T >::size().

                                                                             {
  int size = input.size();
  mgr.set_output_row_size(size);
  for (int i = 0; i < size; ++i) {
    y[i] = input[i].truncateToYear();
    mo[i] = input[i].truncateToMonth();
    d[i] = input[i].truncateToDay();
    h[i] = input[i].truncateToHours();
    m[i] = input[i].truncateToMinutes();
    s[i] = input[i].truncateToSeconds();
    ms[i] = input[i].truncateToMilliseconds();
    us[i] = input[i].truncateToMicroseconds();
  }

  return size;
}

Here is the call graph for this function:

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 at line 339 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 1 + 10 * multiplier;
  return 1;
}

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 at line 346 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 2 + 11 * multiplier;
  return 1;
}

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 at line 354 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 101 + 10 * multiplier + x;
  return 1;
}

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 at line 365 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 99 + 10 * multiplier + x;
  return 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 at line 373 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 98 + multiplier + 10 * x;
  return 1;
}

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 at line 381 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 2 + multiplier;
  return 1;
}

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 at line 389 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 99 + multiplier + 11 * x;
  return 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 at line 397 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 98 + 100 * multiplier + x;
  return 1;
}

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 at line 405 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 99 + 100 * multiplier + x;
  return 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 at line 414 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 99 + 10 * multiplier + x;
  return 1;
}

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 at line 423 of file TableFunctionsTesting.hpp.

                                                     {
  out[0] = 1000 + 99 + 9 * multiplier + x;
  return 1;
}

template<typename K , typename T , typename Z >

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 at line 1620 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_output_row_size(), Column< T >::setNull(), and Column< T >::size().

                                                                {
  const int64_t input1_size = input1_id.size();
  const int64_t input2_size = input2_id.size();
  int64_t output_size = input1_size + input2_size;
  mgr.set_output_row_size(output_size);
  for (int64_t input1_idx = 0; input1_idx < input1_size; ++input1_idx) {
    output_id[input1_idx] = input1_id[input1_idx];
    output_x[input1_idx] = input1_x[input1_idx];
    output_y[input1_idx] = input1_y[input1_idx];
    output_z[input1_idx] = input1_z[input1_idx];
    output_w.setNull(input1_idx);
  }
  for (int64_t input2_idx = 0; input2_idx < input2_size; ++input2_idx) {
    output_id[input1_size + input2_idx] = input2_id[input2_idx];
    output_x[input1_size + input2_idx] = input2_x[input2_idx];
    output_y[input1_size + input2_idx] = input2_y[input2_idx];
    output_z[input1_size + input2_idx] = input2_z[input2_idx];
    output_w[input1_size + input2_idx] = input2_w[input2_idx];
  }
  return output_size;
}

Here is the call graph for this function:

template<typename K , typename T , typename Z >

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 at line 1574 of file TableFunctionsTesting.hpp.

References get_column_min_max(), get_min_or_max_union(), TextEncodingNone::getString(), MAX, MIN, TableFunctionManager::set_output_row_size(), Column< T >::setNull(), and Column< T >::size().

                                                           {
  mgr.set_output_row_size(1);
  const std::string agg_type_str = agg_type.getString();
  const TFAggType min_or_max = agg_type_str == "MIN" ? TFAggType::MIN : TFAggType::MAX;
  output_row_count[0] = input1_id.size() + input2_id.size();
  output_id[0] = get_min_or_max_union(input1_id, input2_id, min_or_max);
  output_x[0] = get_min_or_max_union(input1_x, input2_x, min_or_max);
  output_y[0] = get_min_or_max_union(input1_y, input2_y, min_or_max);
  output_z[0] = get_min_or_max_union(input1_z, input2_z, min_or_max);
  if (input2_w.size() > 0) {
    const auto w_min_max = get_column_min_max(input2_w);
    output_w[0] = agg_type_str == "MIN" ? w_min_max.first : w_min_max.second;
  } else {
    output_w.setNull(0);
  }
  return 1;
}

Here is the call graph for this function:

template<typename T >

TEMPLATE_INLINE T get_min_or_max	(	const Column< T > &	col,
		const TFAggType	min_or_max
	)

Definition at line 1477 of file TableFunctionsTesting.hpp.

References get_column_min_max(), and MIN.

Referenced by ct_pushdown_stats__cpu_template().

                                                                                   {
  const auto input_min_max = get_column_min_max(col);
  if (min_or_max == TFAggType::MIN) {
    return input_min_max.first;
  }
  return input_min_max.second;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

TEMPLATE_INLINE T get_min_or_max_union	(	const Column< T > &	col1,
		const Column< T > &	col2,
		const TFAggType	min_or_max
	)

Definition at line 1486 of file TableFunctionsTesting.hpp.

References get_column_min_max(), and MIN.

Referenced by ct_union_pushdown_stats__cpu_template().

                                                                   {
  const auto input1_min_max = get_column_min_max(col1);
  const auto input2_min_max = get_column_min_max(col2);
  if (min_or_max == TFAggType::MIN) {
    return input1_min_max.first < input2_min_max.first ? input1_min_max.first
                                                       : input2_min_max.first;
  }
  return input1_min_max.second > input2_min_max.second ? input1_min_max.second
                                                       : input2_min_max.second;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

T safe_addition	(	T	x,
		T	y
	)

Definition at line 1096 of file TableFunctionsTesting.hpp.

Referenced by column_list_safe_row_sum__cpu_template().

                          {
  if (x >= 0) {
    if (y > (std::numeric_limits<T>::max() - x)) {
      throw std::overflow_error("Addition overflow detected");
    }
  } else {
    if (y < (std::numeric_limits<T>::min() - x)) {
      throw std::underflow_error("Addition underflow detected");
    }
  }
  return x + y;
}

Here is the caller graph for this function:

template<typename T >

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 at line 797 of file TableFunctionsTesting.hpp.

References Column< T >::ptr_, set_output_row_size(), Column< T >::size(), and gpu_enabled::sort().

                                                                             {
  const int64_t num_rows = input.size();
  set_output_row_size(num_rows);
  output = input;
  if (sort_ascending) {
    std::sort(output.ptr_, output.ptr_ + num_rows, SortAsc<T>(nulls_last));
  } else {
    std::sort(output.ptr_, output.ptr_ + num_rows, SortDesc<T>(nulls_last));
  }
  if (limit < 0 || limit > num_rows) {
    return num_rows;
  }
  return limit;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t sum_along_row__cpu_template	(	const Column< Array< T >> &	input,
		Column< T > &	output
	)

Definition at line 2059 of file TableFunctionsTesting.hpp.

References TableFunctionManager::get_singleton(), Array< T >::getSize(), Array< T >::isNull(), Column< T >::setNull(), and heavydb.dtypes::T.

                                                                         {
  int size = input.size();
  for (int i = 0; i < size; i++) {
    const Array<T> arr = input[i];
    if (arr.isNull()) {
      output.setNull(i);
    } else {
      if constexpr (std::is_same<T, TextEncodingDict>::value) {
        auto* mgr = TableFunctionManager::get_singleton();
        std::string acc = "";
        for (auto j = 0; j < arr.getSize(); j++) {
          if (!arr.isNull(j)) {
            acc += mgr->getString(input.getDictDbId(), input.getDictId(), arr[j]);
          }
        }
        int32_t out_string_id =
            mgr->getOrAddTransient(output.getDictDbId(), output.getDictId(), acc);
        output[i] = out_string_id;
      } else {
        T acc{0};
        for (auto j = 0; j < arr.getSize(); j++) {
          if constexpr (std::is_same_v<T, bool>) {
            // todo: arr.isNull(i) returns arr[i] because bool does not
            // have null value, we should introduce 8-bit boolean type
            // for Arrays
            acc |= arr[j];
          } else {
            if (!arr.isNull(j)) {
              acc += arr[j];
            }
          }
        }
        output[i] = acc;
      }
    }
  }
  return size;
}

Here is the call graph for this function:

NEVER_INLINE HOST int32_t tf_metadata_getter__cpu_template	(	TableFunctionManager &	mgr,
		const Column< bool > &	input,
		Column< bool > &	success
	)

Definition at line 2338 of file TableFunctionsTesting.hpp.

References anonymous_namespace{Utm.h}::f, TableFunctionManager::get_metadata(), run_benchmark_import::result, and TableFunctionManager::set_output_row_size().

                                                                                  {
  // get them all back and check values
  int8_t i8{};
  int16_t i16{};
  int32_t i32{};
  int64_t i64{};
  float f{};
  double d{};
  bool b{};

  try {
    mgr.get_metadata("test_int8_t", i8);
    mgr.get_metadata("test_int16_t", i16);
    mgr.get_metadata("test_int32_t", i32);
    mgr.get_metadata("test_int64_t", i64);
    mgr.get_metadata("test_float", f);
    mgr.get_metadata("test_double", d);
    mgr.get_metadata("test_bool", b);
  } catch (const std::runtime_error& ex) {
    return mgr.ERROR_MESSAGE(ex.what());
  }

  // return value indicates values were correct
  // types are implicitly correct by this point, or the above would have thrown
  bool result = (i8 == 1) && (i16 == 2) && (i32 == 3) && (i64 == 4) && (f == 5.0f) &&
                (d == 6.0) && b;
  if (!result) {
    return mgr.ERROR_MESSAGE("Metadata return values are incorrect");
  }

  mgr.set_output_row_size(1);
  success[0] = true;
  return 1;
}

Here is the call graph for this function:

NEVER_INLINE HOST int32_t tf_metadata_getter_bad__cpu_template	(	TableFunctionManager &	mgr,
		const Column< bool > &	input,
		Column< bool > &	success
	)

Definition at line 2381 of file TableFunctionsTesting.hpp.

References anonymous_namespace{Utm.h}::f, TableFunctionManager::get_metadata(), and TableFunctionManager::set_output_row_size().

                                                                                      {
  // get one back as the wrong type
  // this should throw
  float f{};
  try {
    mgr.get_metadata("test_double", f);
  } catch (const std::runtime_error& ex) {
    return mgr.ERROR_MESSAGE(ex.what());
  }

  mgr.set_output_row_size(1);
  success[0] = true;
  return 1;
}

Here is the call graph for this function:

NEVER_INLINE HOST int32_t tf_metadata_setter__cpu_template	(	TableFunctionManager &	mgr,
		Column< bool > &	success
	)

Definition at line 2280 of file TableFunctionsTesting.hpp.

References anonymous_namespace{Utm.h}::f, TableFunctionManager::set_metadata(), and TableFunctionManager::set_output_row_size().

                                                                                  {
  // set one of each type
  mgr.set_metadata("test_int8_t", int8_t(1));
  mgr.set_metadata("test_int16_t", int16_t(2));
  mgr.set_metadata("test_int32_t", int32_t(3));
  mgr.set_metadata("test_int64_t", int64_t(4));
  mgr.set_metadata("test_float", 5.0f);
  mgr.set_metadata("test_double", 6.0);
  mgr.set_metadata("test_bool", true);

  mgr.set_output_row_size(1);
  success[0] = true;
  return 1;
}

Here is the call graph for this function:

NEVER_INLINE HOST int32_t tf_metadata_setter_repeated__cpu_template	(	TableFunctionManager &	mgr,
		Column< bool > &	success
	)

Definition at line 2303 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_metadata(), and TableFunctionManager::set_output_row_size().

                                                                 {
  // set the same name twice
  mgr.set_metadata("test_int8_t", int8_t(1));
  mgr.set_metadata("test_int8_t", int8_t(2));

  mgr.set_output_row_size(1);
  success[0] = true;
  return 1;
}

Here is the call graph for this function:

NEVER_INLINE HOST int32_t tf_metadata_setter_size_mismatch__cpu_template	(	TableFunctionManager &	mgr,
		Column< bool > &	success
	)

Definition at line 2321 of file TableFunctionsTesting.hpp.

References TableFunctionManager::set_metadata(), and TableFunctionManager::set_output_row_size().

                                                                      {
  // set the same name twice
  mgr.set_metadata("test_int8_t", int8_t(1));
  mgr.set_metadata("test_int8_t", int16_t(2));

  mgr.set_output_row_size(1);
  success[0] = true;
  return 1;
}

Here is the call graph for this function: