TableFunctionsTesting.h File Reference

#include "../../heavydbTypes.h"

Include dependency graph for TableFunctionsTesting.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

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 >
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 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_HOST int32_t	ct_require_text_collist_enc_dict__cpu_ (const ColumnList< TextEncodingDict > &input, const int64_t x, Column< int64_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_require_cursor__cpu_ (const Column< int64_t > &input, int64_t y, Column< int64_t > &out)
EXTENSION_NOINLINE_HOST int32_t	ct_test_allocator (TableFunctionManager &mgr, const Column< int32_t > &input, const TextEncodingNone &t, Column< int32_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_HOST int32_t	ct_timestamp_add_offset_cpu_only (const Column< Timestamp > &input, const int32_t multiplier, 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_append__cpu_template (TableFunctionManager &mgr, const Column< Array< T >> &input1, const Array< T > &input2, 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)
EXTENSION_NOINLINE int32_t	ct_coords__cpu_ (TableFunctionManager &mgr, const Column< GeoPoint > &points, Column< double > &xcoords, Column< double > &ycoords)
EXTENSION_NOINLINE int32_t	ct_shift__cpu_ (TableFunctionManager &mgr, const Column< GeoPoint > &points, const double x, const double y, Column< GeoPoint > &shifted_points)
template<typename T >
NEVER_INLINE HOST int32_t	ct_pointn__cpu_template (TableFunctionManager &mgr, const Column< T > &points, int64_t n, Column< double > &xcoords, Column< double > &ycoords)
template<typename T >
NEVER_INLINE HOST int32_t	ct_copy__generic_cpu_template (TableFunctionManager &mgr, const Column< T > &inputs, Column< T > &outputs)
template<typename T >
NEVER_INLINE HOST int32_t	ct_concat__generic_cpu_template (TableFunctionManager &mgr, const Column< T > &input1, const Column< T > &input2, Column< T > &outputs)
template<typename T >
NEVER_INLINE HOST int32_t	ct_concat__generic2_cpu_template (TableFunctionManager &mgr, const Column< T > &input1, const T &input2, Column< T > &outputs)
template<typename T >
NEVER_INLINE HOST int32_t	ct_concat__generic3_cpu_template (TableFunctionManager &mgr, const T &input1, const Column< T > &input2, Column< T > &outputs)
EXTENSION_NOINLINE int32_t	ct_linestringn__cpu_ (TableFunctionManager &mgr, const Column< GeoPolygon > &polygons, int64_t n, Column< GeoLineString > &linestrings)
EXTENSION_NOINLINE int32_t	ct_make_polygon3__cpu_ (TableFunctionManager &mgr, const Column< GeoLineString > &rings, const Column< GeoLineString > &holes1, const Column< GeoLineString > &holes2, Column< GeoPolygon > &polygons, Column< int > &sizes)
EXTENSION_NOINLINE int32_t	ct_make_linestring2__cpu_ (TableFunctionManager &mgr, const Column< double > &x, const Column< double > &y, double dx, double dy, Column< GeoLineString > &linestrings)
EXTENSION_NOINLINE int32_t	ct_make_multipolygon__cpu_ (TableFunctionManager &mgr, const Column< GeoPolygon > &polygons, Column< GeoMultiPolygon > &mpolygons)
EXTENSION_NOINLINE int32_t	ct_polygonn__cpu_ (TableFunctionManager &mgr, const Column< GeoMultiPolygon > &mpolygons, int64_t n, Column< GeoPolygon > &polygons)
EXTENSION_NOINLINE int32_t	ct_to_multilinestring__cpu_ (TableFunctionManager &mgr, const Column< GeoPolygon > &polygons, Column< GeoMultiLineString > &mlinestrings)
EXTENSION_NOINLINE int32_t	ct_to_polygon__cpu_ (TableFunctionManager &mgr, const Column< GeoMultiLineString > &mlinestrings, Column< GeoPolygon > &polygons)
EXTENSION_NOINLINE int32_t	row_copier (const Column< double > &input_col, int copy_multiplier, Column< double > &output_col)
EXTENSION_NOINLINE_HOST int32_t	row_copier2__cpu__ (const Column< double > &input_col, int copy_multiplier, Column< double > &output_col, Column< double > &output_col2)
EXTENSION_NOINLINE_HOST int32_t	row_copier_columnlist__cpu__ (TableFunctionManager &mgr, const ColumnList< double > &cols, Column< double > &output_col)
template<typename T >
TEMPLATE_NOINLINE int32_t	row_repeater__cpu_template (TableFunctionManager &mgr, const Column< T > &input_col, const int reps, Column< T > &output_col)
EXTENSION_NOINLINE int32_t	row_copier_text (const Column< TextEncodingDict > &input_col, int copy_multiplier, Column< TextEncodingDict > &output_col)
EXTENSION_NOINLINE int32_t	row_adder (const int copy_multiplier, const Column< double > &input_col1, const Column< double > &input_col2, Column< double > &output_col)
EXTENSION_NOINLINE int32_t	row_addsub (const int copy_multiplier, const Column< double > &input_col1, const Column< double > &input_col2, Column< double > &output_col1, Column< double > &output_col2)
EXTENSION_NOINLINE_HOST int32_t	get_max_with_row_offset__cpu_ (const Column< int > &input_col, Column< int > &output_max_col, Column< int > &output_max_row_col)
EXTENSION_NOINLINE_HOST int32_t	column_list_get__cpu_ (const ColumnList< double > &col_list, const int index, const int m, Column< double > &col)
EXTENSION_NOINLINE int32_t	column_list_first_last (const ColumnList< double > &col_list, const int m, Column< double > &col1, Column< double > &col2)
EXTENSION_NOINLINE_HOST int32_t	column_list_row_sum__cpu_ (const ColumnList< int32_t > &input, Column< int32_t > &out)
template<typename T >
TEMPLATE_NOINLINE int32_t	ct_test_int_default_arg__template (const Column< T > &inp, const T x, const int32_t multiplier, Column< T > &out)
template<typename T >
TEMPLATE_NOINLINE int32_t	ct_test_float_default_arg__template (const Column< T > &inp, const T x, const int32_t multiplier, Column< T > &out)
EXTENSION_NOINLINE int32_t	ct_test_string_default_arg__cpu_ (TableFunctionManager &mgr, const Column< TextEncodingDict > &inp, const TextEncodingNone &suffix, Column< TextEncodingDict > &out)
EXTENSION_NOINLINE int32_t	ct_test_func__cpu_1 (const Column< int32_t > &input1, const int32_t x, const int32_t multiplier, Column< int32_t > &out)
EXTENSION_NOINLINE int32_t	ct_test_func__cpu_2 (const Column< int32_t > &input1, const Column< int32_t > &input2, const int32_t multiplier, Column< int32_t > &out)
EXTENSION_NOINLINE int32_t	ct_test_calcite_casting_char__cpu_ (TableFunctionManager &mgr, const Column< TextEncodingDict > &input1, Column< TextEncodingDict > &out)
EXTENSION_NOINLINE int32_t	ct_test_calcite_casting_bigint__cpu_ (TableFunctionManager &mgr, const Column< int64_t > &input1, Column< int64_t > &out)
EXTENSION_NOINLINE int32_t	ct_test_calcite_casting_double__cpu_ (TableFunctionManager &mgr, const Column< double > &input1, Column< double > &out)
EXTENSION_NOINLINE int32_t	ct_test_calcite_casting_timestamp__cpu_ (TableFunctionManager &mgr, const Column< Timestamp > &input1, Column< Timestamp > &out)
template<typename T >
TEMPLATE_NOINLINE int32_t	ct_test_calcite_casting_columnlist__template_cpu_ (TableFunctionManager &mgr, const Column< T > &first, const ColumnList< T > &list, Column< T > &out)

Function Documentation

template<typename T >

NEVER_INLINE HOST int32_t array_append__cpu_template	(	TableFunctionManager &	mgr,
		const Column< Array< T >> &	input1,
		const Array< T > &	input2,
		Column< Array< T >> &	output
	)

Definition at line 177 of file ArrayTestTableFunctions.cpp.

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

                                                                               {
  int size = input1.size();
  int output_values_size = input2.size() * size;
  for (int i = 0; i < size; i++) {
    output_values_size += input1[i].size();
  }
  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++) {
    output.concatItem(i, input1[i]);
    output.concatItem(i, input2);
  }
  return size;
}

Here is the call graph for this function:

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 270 of file ArrayTestTableFunctions.cpp.

References TableFunctionManager::getNewDictDbId(), TableFunctionManager::getNewDictId(), TableFunctionManager::getOrAddTransient(), TableFunctionManager::getString(), Column< T >::isNull(), TableFunctionManager::set_output_array_values_total_number(), TableFunctionManager::set_output_row_size(), 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 149 of file ArrayTestTableFunctions.cpp.

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].size();
    }
  }
  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];
      output.concatItem(i,
                        col[i]);  // 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 89 of file ArrayTestTableFunctions.cpp.

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

                                                                               {
  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].size();
  }

  // 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++) {
    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 328 of file ArrayTestTableFunctions.cpp.

References TableFunctionManager::set_output_array_values_total_number(), TableFunctionManager::set_output_row_size(), and Array< T >::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].size();
      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.size();
      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:

EXTENSION_NOINLINE int32_t column_list_first_last	(	const ColumnList< double > &	col_list,
		const int	m,
		Column< double > &	col1,
		Column< double > &	col2
	)

Definition at line 831 of file OtherTestTableFunctions.cpp.

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

                                                                        {
  col1 = col_list[0];
  col2 = col_list[col_list.numCols() - 1];
  return col1.size();
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t column_list_get__cpu_	(	const ColumnList< double > &	col_list,
		const int	index,
		const int	m,
		Column< double > &	col
	)

Definition at line 821 of file OtherTestTableFunctions.cpp.

References Column< T >::size().

                                                                           {
  col = col_list[index];  // copy the data of col_list item to output column
  return col.size();
}

Here is the call graph for this function:

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

Definition at line 843 of file OtherTestTableFunctions.cpp.

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

                                                                                  {
  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];
    int32_t s = 0;
    for (int j = 0; j < col.size(); j++) {
      s += col[j];
    }
    out[i] = s;
  }
  return output_num_rows;
}

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 178 of file OtherTestTableFunctions.cpp.

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 325 of file OtherTestTableFunctions.cpp.

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 28 of file SignatureTestTableFunctions.cpp.

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 507 of file RbcTestTableFunctions.cpp.

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 468 of file RbcTestTableFunctions.cpp.

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 370 of file RbcTestTableFunctions.cpp.

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 380 of file RbcTestTableFunctions.cpp.

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 393 of file RbcTestTableFunctions.cpp.

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 406 of file RbcTestTableFunctions.cpp.

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 417 of file RbcTestTableFunctions.cpp.

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 428 of file RbcTestTableFunctions.cpp.

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 29 of file OtherTestTableFunctions.cpp.

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 40 of file StringTestTableFunctions.cpp.

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 26 of file StringTestTableFunctions.cpp.

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 445 of file RbcTestTableFunctions.cpp.

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 227 of file RbcTestTableFunctions.cpp.

                                                                               {
  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 256 of file RbcTestTableFunctions.cpp.

                                                                               {
  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 241 of file RbcTestTableFunctions.cpp.

                                               {
  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 249 of file RbcTestTableFunctions.cpp.

                                               {
  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 233 of file RbcTestTableFunctions.cpp.

                                                                               {
  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 152 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 158 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 165 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 173 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 181 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 189 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 197 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 204 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 211 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 218 of file RbcTestTableFunctions.cpp.

                                                                              {
  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 79 of file RbcTestTableFunctions.cpp.

                                                                                     {
  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 144 of file RbcTestTableFunctions.cpp.

                                                       {
  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 84 of file RbcTestTableFunctions.cpp.

                                                      {
  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 91 of file RbcTestTableFunctions.cpp.

                                                      {
  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 99 of file RbcTestTableFunctions.cpp.

                                                      {
  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 107 of file RbcTestTableFunctions.cpp.

                                                      {
  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 115 of file RbcTestTableFunctions.cpp.

                                                      {
  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 123 of file RbcTestTableFunctions.cpp.

                                                      {
  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 130 of file RbcTestTableFunctions.cpp.

                                                      {
  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 137 of file RbcTestTableFunctions.cpp.

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

template<typename T >

NEVER_INLINE HOST int32_t ct_concat__generic2_cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input1,
		const T &	input2,
		Column< T > &	outputs
	)

Definition at line 91 of file FlatBufferTableFunctions.cpp.

                                                                              {
  auto size = input1.size();
  mgr.set_output_item_values_total_number(0,
                                          input1.getNofValues() + size * input2.size());
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (input1.isNull(i) || input2.isNull()) {
      output.setNull(i);
    } else {
      output[i] = input1[i];
      output[i] += input2;
    }
  }
  return size;
}

template<typename T >

NEVER_INLINE HOST int32_t ct_concat__generic3_cpu_template	(	TableFunctionManager &	mgr,
		const T &	input1,
		const Column< T > &	input2,
		Column< T > &	outputs
	)

Definition at line 121 of file FlatBufferTableFunctions.cpp.

                                                                              {
  auto size = input2.size();
  mgr.set_output_item_values_total_number(0,
                                          input2.getNofValues() + size * input1.size());
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (input2.isNull(i) || input1.isNull()) {
      output.setNull(i);
    } else {
      output[i] = input1;
      output[i] += input2[i];
    }
  }
  return size;
}

template<typename T >

NEVER_INLINE HOST int32_t ct_concat__generic_cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input1,
		const Column< T > &	input2,
		Column< T > &	outputs
	)

Definition at line 56 of file FlatBufferTableFunctions.cpp.

                                                                              {
  auto size = input1.size();
  mgr.set_output_item_values_total_number(0,
                                          input1.getNofValues() + input2.getNofValues());
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (input1.isNull(i)) {
      if (input2.isNull(i)) {
        outputs.setNull(i);
      } else {
        outputs[i] = input2[i];
      }
    } else if (input2.isNull(i)) {
      outputs[i] = input1[i];
    } else {
      outputs[i] = input1[i];
      outputs.concatItem(i, input2[i]);
    }
  }
  return size;
}

EXTENSION_NOINLINE int32_t ct_coords__cpu_	(	TableFunctionManager &	mgr,
		const Column< GeoPoint > &	points,
		Column< double > &	xcoords,
		Column< double > &	ycoords
	)

Definition at line 28 of file GeoTestTableFunctions.cpp.

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

                                                                    {
  auto size = points.size();
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (points.isNull(i)) {
      xcoords.setNull(i);
      ycoords.setNull(i);
    } else {
      const auto point = points[i];
      xcoords[i] = point.x;
      ycoords[i] = point.y;
    }
  }
  return size;
}

Here is the call graph for this function:

template<typename T >

NEVER_INLINE HOST int32_t ct_copy__generic_cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	inputs,
		Column< T > &	outputs
	)

Definition at line 28 of file FlatBufferTableFunctions.cpp.

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

                                                                            {
  auto size = inputs.size();
  mgr.set_output_item_values_total_number(0, inputs.getNofValues());
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (inputs.isNull(i)) {
      outputs.setNull(i);
    } else {
      outputs[i] = inputs[i];
    }
  }
  return size;
}

Here is the call graph for this function:

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

Definition at line 315 of file OtherTestTableFunctions.cpp.

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 508 of file SignatureTestTableFunctions.cpp.

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 28 of file RbcTestTableFunctions.cpp.

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 58 of file RbcTestTableFunctions.cpp.

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 67 of file RbcTestTableFunctions.cpp.

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 40 of file RbcTestTableFunctions.cpp.

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 49 of file RbcTestTableFunctions.cpp.

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 152 of file StringTestTableFunctions.cpp.

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 953 of file OtherTestTableFunctions.cpp.

                                                                                     {
  // 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 125 of file StringTestTableFunctions.cpp.

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:

EXTENSION_NOINLINE int32_t ct_linestringn__cpu_	(	TableFunctionManager &	mgr,
		const Column< GeoPolygon > &	polygons,
		int64_t	n,
		Column< GeoLineString > &	linestrings
	)

Definition at line 105 of file GeoTestTableFunctions.cpp.

References flatbuffer::Column< RowType, RowStruct >::getNofValues(), flatbuffer::Column< RowType, RowStruct >::isNull(), TableFunctionManager::set_output_item_values_total_number(), TableFunctionManager::set_output_row_size(), flatbuffer::Column< RowType, RowStruct >::setItem(), flatbuffer::Column< RowType, RowStruct >::setNull(), and flatbuffer::Column< RowType, RowStruct >::size().

                                                                                    {
  auto size = polygons.size();
  mgr.set_output_item_values_total_number(0, polygons.getNofValues());
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (polygons.isNull(i)) {
      linestrings.setNull(i);
    } else {
      int64_t sz = polygons[i].size();
      if (n < 1 || n > sz) {
        linestrings.setNull(i);
      } else {
        const auto poly = polygons[i];
        const auto ring = poly[n - 1];
        linestrings.setItem(i, ring);
      }
    }
  }
  return size;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_make_linestring2__cpu_	(	TableFunctionManager &	mgr,
		const Column< double > &	x,
		const Column< double > &	y,
		double	dx,
		double	dy,
		Column< GeoLineString > &	linestrings
	)

Definition at line 285 of file GeoTestTableFunctions.cpp.

References Column< T >::isNull(), parse_ast::line, TableFunctionManager::set_output_item_values_total_number(), TableFunctionManager::set_output_row_size(), flatbuffer::Column< RowType, RowStruct >::setNull(), and Column< T >::size().

                                                                                         {
  auto size = x.size();
  mgr.set_output_item_values_total_number(0, size * 4);
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (x.isNull(i) || y.isNull(i)) {
      linestrings.setNull(i);
    } else {
      std::vector<double> line{x[i], y[i], x[i] + dx, y[i] + dy};
      linestrings[i].fromCoords(line);
    }
  }
  return size;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_make_multipolygon__cpu_	(	TableFunctionManager &	mgr,
		const Column< GeoPolygon > &	polygons,
		Column< GeoMultiPolygon > &	mpolygons
	)

Definition at line 306 of file GeoTestTableFunctions.cpp.

References flatbuffer::Column< RowType, RowStruct >::getNofValues(), flatbuffer::Column< RowType, RowStruct >::isNull(), parse_ast::line, TableFunctionManager::set_output_item_values_total_number(), TableFunctionManager::set_output_row_size(), flatbuffer::Column< RowType, RowStruct >::setNull(), flatbuffer::Column< RowType, RowStruct >::size(), flatbuffer::NestedArray< ItemType >::size(), Geo::LineString::toCoords(), and toString().

                                                               {
  auto size = polygons.size();
  mgr.set_output_item_values_total_number(0, polygons.getNofValues());
  mgr.set_output_row_size(size);

  // Initialize mpolygons
  int count_nulls = 0;
  for (int64_t i = 0; i < size; i++) {
    if (polygons.isNull(i)) {
      mpolygons.setNull(i);
      count_nulls++;
    } else {
      std::vector<std::vector<std::vector<double>>> mpolygon_coords;
      mpolygon_coords.reserve(1);
      std::vector<std::vector<double>> polygon_coords = polygons[i].toCoords();
      mpolygon_coords.push_back(polygon_coords);
      auto status = mpolygons[i].fromCoords(mpolygon_coords);
      if (status != FlatBufferManager::Status::Success) {
        return mgr.ERROR_MESSAGE("fromCoords failed: " + ::toString(status));
      }
    }
  }

  // Check mpolygons content
  if (count_nulls == 0) {
    return mgr.ERROR_MESSAGE("counting null test failed: count_nulls=" +
                             ::toString(count_nulls) + ", expected non-zero.");
  }

  for (int64_t i = 0; i < size; i++) {
    if (mpolygons.isNull(i)) {
      count_nulls--;
    } else {
      std::vector<std::vector<double>> polygon_coords = polygons[i].toCoords();

      // mpolygons[i] is Geo::MultiPolygon instances
      // mpolygons[i][j] is Geo::Polygon instances
      // mpolygons[i][j][k] is Geo::LineString instances
      // mpolygons[i][j][k][l] is Geo::Point2D instances

      auto nof_polygons = mpolygons[i].size();
      if (nof_polygons != 1) {
        return mgr.ERROR_MESSAGE("multipolygon size test failed: nof_polygons=" +
                                 ::toString(nof_polygons) + ", expected 1.");
      }

      std::vector<std::vector<std::vector<double>>> mpolygon_coords =
          mpolygons[i].toCoords();
      if (nof_polygons != mpolygon_coords.size()) {
        return mgr.ERROR_MESSAGE(
            "multipolygon toCoords size test failed: mpolygon_coords.size()=" +
            ::toString(mpolygon_coords.size()) + ", expected " +
            ::toString(nof_polygons) + ".");
      }

      Geo::Polygon poly = mpolygons[i][0];
      std::vector<std::vector<double>> poly_coords = mpolygon_coords[0];
      if (poly.size() != polygon_coords.size()) {
        return mgr.ERROR_MESSAGE("multipolygon polygon size test failed: poly.size()=" +
                                 ::toString(poly.size()) + ", expected " +
                                 ::toString(polygon_coords.size()) + ".");
      }

      if (poly_coords.size() != polygon_coords.size()) {
        return mgr.ERROR_MESSAGE(
            "multipolygon polygon coords size test failed: poly_coords.size()=" +
            ::toString(poly_coords.size()) + ", expected " +
            ::toString(polygon_coords.size()) + ".");
      }

      for (size_t j = 0; j < poly.size(); j++) {
        Geo::LineString line = poly[j];
        std::vector<double> line_coords = line.toCoords();
        auto nof_points = polygon_coords[j].size() / 2;
        if (poly.size(j) != nof_points) {
          return mgr.ERROR_MESSAGE(
              "multipolygon polygon linestring size test failed: poly.size(" +
              ::toString(j) + ")=" + ::toString(poly.size(j)) + ", expected " +
              ::toString(nof_points) + ".");
        }
        if (line.size() != nof_points) {
          return mgr.ERROR_MESSAGE(
              "multipolygon polygon linestring size test failed: line.size()=" +
              ::toString(line.size()) + ", expected " + ::toString(nof_points) + ".");
        }
        if (poly_coords[j].size() != nof_points * 2) {
          return mgr.ERROR_MESSAGE(
              "multipolygon polygon linestring coords size test failed: "
              "poly_coords[j].size()=" +
              ::toString(poly_coords[j].size()) + ", expected " +
              ::toString(nof_points * 2) + ".");
        }
        if (line_coords.size() != nof_points * 2) {
          return mgr.ERROR_MESSAGE(
              "multipolygon polygon linestring coords size test failed: "
              "line_coords.size()=" +
              ::toString(line_coords.size()) + ", expected " +
              ::toString(nof_points * 2) + ".");
        }

        for (size_t k = 0; k < nof_points; k++) {
          if (std::abs(polygon_coords[j][2 * k] - line_coords[2 * k]) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "multipolygon polygon linestring X coord test failed: line_coords[2*k]=" +
                ::toString(line_coords[2 * k]) + ", expected " +
                ::toString(polygon_coords[j][2 * k]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k] - poly_coords[j][2 * k]) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "multipolygon polygon X coord test failed: poly_coords[j][2*k]=" +
                ::toString(poly_coords[j][2 * k]) + ", expected " +
                ::toString(polygon_coords[j][2 * k]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k] - line[k].x) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "multipolygon polygon linestring X coord test failed: line[k].x=" +
                ::toString(line[k].x) + ", expected " +
                ::toString(polygon_coords[j][2 * k]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k + 1] - line_coords[2 * k + 1]) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "multipolygon polygon linestring Y coord test failed: "
                "line_coords[2*k+1]=" +
                ::toString(line_coords[2 * k + 1]) + ", expected " +
                ::toString(polygon_coords[j][2 * k + 1]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k + 1] - poly_coords[j][2 * k + 1]) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "multipolygon polygon Y coord test failed: poly_coords[j][2*k+1]=" +
                ::toString(poly_coords[j][2 * k + 1]) + ", expected " +
                ::toString(polygon_coords[j][2 * k + 1]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k + 1] - line[k].y) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "multipolygon polygon linestring X coord test failed: line[k].y=" +
                ::toString(line[k].y) + ", expected " +
                ::toString(polygon_coords[j][2 * k + 1]) + ".");
          }
        }
      }
    }
  }

  if (count_nulls != 0) {
    return mgr.ERROR_MESSAGE("counting null test failed: count_nulls=" +
                             ::toString(count_nulls) + ", expected 0.");
  }

  return size;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_make_polygon3__cpu_	(	TableFunctionManager &	mgr,
		const Column< GeoLineString > &	rings,
		const Column< GeoLineString > &	holes1,
		const Column< GeoLineString > &	holes2,
		Column< GeoPolygon > &	polygons,
		Column< int > &	sizes
	)

Definition at line 129 of file GeoTestTableFunctions.cpp.

References flatbuffer::Column< RowType, RowStruct >::getNofValues(), flatbuffer::Column< RowType, RowStruct >::isNull(), parse_ast::line, TableFunctionManager::set_output_item_values_total_number(), TableFunctionManager::set_output_row_size(), Column< T >::setNull(), flatbuffer::Column< RowType, RowStruct >::setNull(), flatbuffer::Column< RowType, RowStruct >::size(), flatbuffer::NestedArray< ItemType >::size(), Geo::LineString::toCoords(), and toString().

                                                                      {
  auto size = rings.size();
  mgr.set_output_item_values_total_number(
      0, rings.getNofValues() + holes1.getNofValues() + holes2.getNofValues());
  mgr.set_output_row_size(size);
  // Initialize polygons
  int count_nulls = 0;
  for (int64_t i = 0; i < size; i++) {
    if (rings.isNull(i)) {
      polygons.setNull(i);
      sizes.setNull(i);
      count_nulls++;
    } else {
      std::vector<std::vector<double>> polygon_coords;

      polygon_coords.push_back(rings[i].toCoords());
      if (!holes1.isNull(i)) {
        polygon_coords.push_back(holes1[i].toCoords());
        if (!holes2.isNull(i)) {
          polygon_coords.push_back(holes2[i].toCoords());
        }
      }

      auto polygon = polygons[i];
      auto status = polygon.fromCoords(polygon_coords);

      if (status != FlatBufferManager::Status::Success) {
        return mgr.ERROR_MESSAGE("fromCoords failed: " + ::toString(status));
      }
      int nofpoints = 0;
      for (size_t j = 0; j < polygon.size(); j++) {
        nofpoints += polygon.size(j);
      }
      sizes[i] = nofpoints;
    }
  }

  // Check polygons content
  if (count_nulls == 0) {
    return mgr.ERROR_MESSAGE("counting null test failed: count_nulls=" +
                             ::toString(count_nulls) + ", expected non-zero.");
  }

  for (int64_t i = 0; i < size; i++) {
    if (polygons.isNull(i)) {
      count_nulls--;
    } else {
      std::vector<std::vector<double>> polygon_coords;
      polygon_coords.push_back(rings[i].toCoords());
      if (!holes1.isNull(i)) {
        polygon_coords.push_back(holes1[i].toCoords());
      }
      if (!holes2.isNull(i)) {
        polygon_coords.push_back(holes2[i].toCoords());
      }

      // polygons[i] is Geo::Polygon instances
      // polygons[i][j] is Geo::LineString instances
      // polygons[i][j][k] is Geo::Point2D instances

      auto nof_lines = polygons[i].size();

      if (nof_lines != polygon_coords.size()) {
        return mgr.ERROR_MESSAGE(
            "polygon size test failed: nof_lines=" + ::toString(nof_lines) +
            ", expected " + ::toString(polygon_coords.size()) + ".");
      }
      std::vector<std::vector<double>> poly_coords = polygons[i].toCoords();
      if (nof_lines != poly_coords.size()) {
        return mgr.ERROR_MESSAGE(
            "polygon toCoords size test failed: poly_coords.size()=" +
            ::toString(poly_coords.size()) + ", expected " + ::toString(nof_lines) + ".");
      }

      auto poly = polygons[i];

      for (size_t j = 0; j < poly.size(); j++) {
        Geo::LineString line = poly[j];
        std::vector<double> line_coords = line.toCoords();
        auto nof_points = polygon_coords[j].size() / 2;
        if (poly.size(j) != nof_points) {
          return mgr.ERROR_MESSAGE("polygon linestring size test failed: poly.size(" +
                                   ::toString(j) + ")=" + ::toString(poly.size(j)) +
                                   ", expected " + ::toString(nof_points) + ".");
        }
        if (line.size() != nof_points) {
          return mgr.ERROR_MESSAGE("polygon linestring size test failed: line.size()=" +
                                   ::toString(line.size()) + ", expected " +
                                   ::toString(nof_points) + ".");
        }
        if (poly_coords[j].size() != nof_points * 2) {
          return mgr.ERROR_MESSAGE(
              "polygon linestring coords size test failed: poly_coords[j].size()=" +
              ::toString(poly_coords[j].size()) + ", expected " +
              ::toString(nof_points * 2) + ".");
        }
        if (line_coords.size() != nof_points * 2) {
          return mgr.ERROR_MESSAGE(
              "polygon linestring coords size test failed: line_coords.size()=" +
              ::toString(line_coords.size()) + ", expected " +
              ::toString(nof_points * 2) + ".");
        }
        for (size_t k = 0; k < nof_points; k++) {
          if (std::abs(polygon_coords[j][2 * k] - line_coords[2 * k]) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "polygon linestring X coord test failed: line_coords[2*k]=" +
                ::toString(line_coords[2 * k]) + ", expected " +
                ::toString(polygon_coords[j][2 * k]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k] - poly_coords[j][2 * k]) > 1e-7) {
            return mgr.ERROR_MESSAGE("polygon X coord test failed: poly_coords[j][2*k]=" +
                                     ::toString(poly_coords[j][2 * k]) + ", expected " +
                                     ::toString(polygon_coords[j][2 * k]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k] - line[k].x) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "polygon linestring X coord test failed: line[k].x=" +
                ::toString(line[k].x) + ", expected " +
                ::toString(polygon_coords[j][2 * k]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k + 1] - line_coords[2 * k + 1]) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "polygon linestring Y coord test failed: line_coords[2*k+1]=" +
                ::toString(line_coords[2 * k + 1]) + ", expected " +
                ::toString(polygon_coords[j][2 * k + 1]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k + 1] - poly_coords[j][2 * k + 1]) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "polygon Y coord test failed: poly_coords[j][2*k+1]=" +
                ::toString(poly_coords[j][2 * k + 1]) + ", expected " +
                ::toString(polygon_coords[j][2 * k + 1]) + ".");
          }
          if (std::abs(polygon_coords[j][2 * k + 1] - line[k].y) > 1e-7) {
            return mgr.ERROR_MESSAGE(
                "polygon linestring X coord test failed: line[k].y=" +
                ::toString(line[k].y) + ", expected " +
                ::toString(polygon_coords[j][2 * k + 1]) + ".");
          }
        }
      }
    }
  }

  if (count_nulls != 0) {
    return mgr.ERROR_MESSAGE("counting null test failed: count_nulls=" +
                             ::toString(count_nulls) + ", expected 0.");
  }

  return size;
}

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 100 of file SignatureTestTableFunctions.cpp.

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 82 of file SignatureTestTableFunctions.cpp.

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 144 of file SignatureTestTableFunctions.cpp.

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 121 of file SignatureTestTableFunctions.cpp.

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 182 of file SignatureTestTableFunctions.cpp.

                                                                              {
#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 170 of file SignatureTestTableFunctions.cpp.

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 247 of file SignatureTestTableFunctions.cpp.

                                                                {
  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 623 of file SignatureTestTableFunctions.cpp.

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 586 of file SignatureTestTableFunctions.cpp.

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 548 of file SignatureTestTableFunctions.cpp.

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 527 of file SignatureTestTableFunctions.cpp.

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 T >

NEVER_INLINE HOST int32_t ct_pointn__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	points,
		int64_t	n,
		Column< double > &	xcoords,
		Column< double > &	ycoords
	)

Definition at line 68 of file GeoTestTableFunctions.cpp.

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

                                                                           {
  auto size = points.size();
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (points.isNull(i)) {
      xcoords.setNull(i);
      ycoords.setNull(i);
    } else {
      const auto point = points[i][n - 1];  // n is one-based
      xcoords[i] = point.x;
      ycoords[i] = point.y;
    }
  }
  return size;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_polygonn__cpu_	(	TableFunctionManager &	mgr,
		const Column< GeoMultiPolygon > &	mpolygons,
		int64_t	n,
		Column< GeoPolygon > &	polygons
	)

Definition at line 459 of file GeoTestTableFunctions.cpp.

References flatbuffer::Column< RowType, RowStruct >::getNofValues(), flatbuffer::Column< RowType, RowStruct >::isNull(), TableFunctionManager::set_output_item_values_total_number(), TableFunctionManager::set_output_row_size(), flatbuffer::Column< RowType, RowStruct >::setItem(), flatbuffer::Column< RowType, RowStruct >::setNull(), and flatbuffer::Column< RowType, RowStruct >::size().

                                                                           {
  auto size = mpolygons.size();
  mgr.set_output_item_values_total_number(0, mpolygons.getNofValues());
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (mpolygons.isNull(i)) {
      polygons.setNull(i);
    } else {
      polygons.setItem(i, mpolygons[i][n - 1]);
    }
  }
  return size;
}

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 84 of file FilterPushdownTestTableFunctions.cpp.

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 61 of file FilterPushdownTestTableFunctions.cpp.

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 326 of file SignatureTestTableFunctions.cpp.

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 374 of file SignatureTestTableFunctions.cpp.

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_cursor__cpu_	(	const Column< int64_t > &	input,
		int64_t	y,
		Column< int64_t > &	out
	)

Definition at line 416 of file SignatureTestTableFunctions.cpp.

References set_output_row_size().

                                                                              {
  set_output_row_size(1);
  out[0] = 12;
  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 342 of file SignatureTestTableFunctions.cpp.

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 382 of file SignatureTestTableFunctions.cpp.

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 672 of file SignatureTestTableFunctions.cpp.

                                                                        {
  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 334 of file SignatureTestTableFunctions.cpp.

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 390 of file SignatureTestTableFunctions.cpp.

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 352 of file SignatureTestTableFunctions.cpp.

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_collist_enc_dict__cpu_	(	const ColumnList< TextEncodingDict > &	input,
		const int64_t	x,
		Column< int64_t > &	out
	)

Definition at line 408 of file SignatureTestTableFunctions.cpp.

References set_output_row_size().

                                                             {
  set_output_row_size(1);
  out[0] = 11;
  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 399 of file SignatureTestTableFunctions.cpp.

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 202 of file SignatureTestTableFunctions.cpp.

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 224 of file SignatureTestTableFunctions.cpp.

                                                                                      {
#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 496 of file SignatureTestTableFunctions.cpp.

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 int32_t ct_shift__cpu_	(	TableFunctionManager &	mgr,
		const Column< GeoPoint > &	points,
		const double	x,
		const double	y,
		Column< GeoPoint > &	shifted_points
	)

Definition at line 47 of file GeoTestTableFunctions.cpp.

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

                                                                            {
  auto size = points.size();
  mgr.set_output_row_size(size);
  for (int64_t i = 0; i < size; i++) {
    if (points.isNull(i)) {
      shifted_points.setNull(i);
    } else {
      auto point = points[i];
      point.x += x;
      point.y += y;
      shifted_points.setItem(i, point);
    }
  }
  return size;
}

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 232 of file OtherTestTableFunctions.cpp.

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 258 of file OtherTestTableFunctions.cpp.

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 214 of file OtherTestTableFunctions.cpp.

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 347 of file OtherTestTableFunctions.cpp.

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 85 of file StringTestTableFunctions.cpp.

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 200 of file StringTestTableFunctions.cpp.

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 68 of file StringTestTableFunctions.cpp.

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 111 of file StringTestTableFunctions.cpp.

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 262 of file SignatureTestTableFunctions.cpp.

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

EXTENSION_NOINLINE_HOST int32_t ct_test_allocator	(	TableFunctionManager &	mgr,
		const Column< int32_t > &	input,
		const TextEncodingNone &	t,
		Column< int32_t > &	out
	)

Definition at line 424 of file SignatureTestTableFunctions.cpp.

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

                                                                        {
  mgr.enable_output_allocations();
  mgr.set_output_row_size(1);
  TextEncodingNone t2(mgr, t.getString());
  out[0] = 11;
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_test_calcite_casting_bigint__cpu_	(	TableFunctionManager &	mgr,
		const Column< int64_t > &	input1,
		Column< int64_t > &	out
	)

Definition at line 776 of file SignatureTestTableFunctions.cpp.

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

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

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_test_calcite_casting_char__cpu_	(	TableFunctionManager &	mgr,
		const Column< TextEncodingDict > &	input1,
		Column< TextEncodingDict > &	out
	)

Definition at line 764 of file SignatureTestTableFunctions.cpp.

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

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

Here is the call graph for this function:

template<typename T >

TEMPLATE_NOINLINE int32_t ct_test_calcite_casting_columnlist__template_cpu_	(	TableFunctionManager &	mgr,
		const Column< T > &	first,
		const ColumnList< T > &	list,
		Column< T > &	out
	)

Definition at line 813 of file SignatureTestTableFunctions.cpp.

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

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

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_test_calcite_casting_double__cpu_	(	TableFunctionManager &	mgr,
		const Column< double > &	input1,
		Column< double > &	out
	)

Definition at line 788 of file SignatureTestTableFunctions.cpp.

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

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

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_test_calcite_casting_timestamp__cpu_	(	TableFunctionManager &	mgr,
		const Column< Timestamp > &	input1,
		Column< Timestamp > &	out
	)

Definition at line 800 of file SignatureTestTableFunctions.cpp.

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

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

Here is the call graph for this function:

template<typename T >

TEMPLATE_NOINLINE int32_t ct_test_float_default_arg__template	(	const Column< T > &	inp,
		const T	x,
		const int32_t	multiplier,
		Column< T > &	out
	)

Definition at line 719 of file SignatureTestTableFunctions.cpp.

References Column< T >::size().

                                                                              {
  int32_t size = inp.size();
  for (int i = 0; i < size; ++i) {
    out[i] = inp[i] / x;
  }

  return size;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_test_func__cpu_1	(	const Column< int32_t > &	input1,
		const int32_t	x,
		const int32_t	multiplier,
		Column< int32_t > &	out
	)

Definition at line 958 of file OtherTestTableFunctions.cpp.

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

EXTENSION_NOINLINE int32_t ct_test_func__cpu_2	(	const Column< int32_t > &	input1,
		const Column< int32_t > &	input2,
		const int32_t	multiplier,
		Column< int32_t > &	out
	)

Definition at line 966 of file OtherTestTableFunctions.cpp.

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

template<typename T >

TEMPLATE_NOINLINE int32_t ct_test_int_default_arg__template	(	const Column< T > &	inp,
		const T	x,
		const int32_t	multiplier,
		Column< T > &	out
	)

Definition at line 681 of file SignatureTestTableFunctions.cpp.

References Column< T >::size().

                                                                            {
  int32_t size = inp.size();
  for (int i = 0; i < size; ++i) {
    out[i] = inp[i] * x;
  }

  return size;
}

Here is the call graph for this function:

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

Definition at line 414 of file OtherTestTableFunctions.cpp.

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 482 of file SignatureTestTableFunctions.cpp.

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 467 of file SignatureTestTableFunctions.cpp.

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 448 of file SignatureTestTableFunctions.cpp.

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 457 of file SignatureTestTableFunctions.cpp.

References Column< T >::size().

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

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_test_string_default_arg__cpu_	(	TableFunctionManager &	mgr,
		const Column< TextEncodingDict > &	inp,
		const TextEncodingNone &	suffix,
		Column< TextEncodingDict > &	out
	)

Definition at line 747 of file SignatureTestTableFunctions.cpp.

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

                                                                {
  int32_t size = inp.size();
  mgr.set_output_row_size(size);
  for (int i = 0; i < size; ++i) {
    std::string output_string = inp.getString(i);
    output_string += suffix.getString();
    const TextEncodingDict concatted_id = out.getOrAddTransient(output_string);
    out[i] = concatted_id;
  }

  return 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 291 of file OtherTestTableFunctions.cpp.

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 569 of file OtherTestTableFunctions.cpp.

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 471 of file OtherTestTableFunctions.cpp.

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_add_offset_cpu_only	(	const Column< Timestamp > &	input,
		const int32_t	multiplier,
		const Timestamp	offset,
		Column< Timestamp > &	out
	)

Definition at line 504 of file OtherTestTableFunctions.cpp.

                                                         {
  out[0] = input[0] + offset;
  return 1;
}

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 532 of file OtherTestTableFunctions.cpp.

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 431 of file OtherTestTableFunctions.cpp.

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 514 of file OtherTestTableFunctions.cpp.

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 541 of file OtherTestTableFunctions.cpp.

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 int32_t ct_to_multilinestring__cpu_	(	TableFunctionManager &	mgr,
		const Column< GeoPolygon > &	polygons,
		Column< GeoMultiLineString > &	mlinestrings
	)

Definition at line 477 of file GeoTestTableFunctions.cpp.

References flatbuffer::Column< RowType, RowStruct >::getNofValues(), flatbuffer::Column< RowType, RowStruct >::isNull(), TableFunctionManager::set_output_item_values_total_number(), TableFunctionManager::set_output_row_size(), flatbuffer::Column< RowType, RowStruct >::setNull(), flatbuffer::Column< RowType, RowStruct >::size(), and toString().

                                                                      {
  auto size = polygons.size();
  mgr.set_output_item_values_total_number(0, polygons.getNofValues());
  mgr.set_output_row_size(size);
  // Initialize mlinestrings
  int count_nulls = 0;
  FlatBufferManager::Status status{};
  for (int64_t i = 0; i < size; i++) {
    if (polygons.isNull(i)) {
      mlinestrings.setNull(i);
      count_nulls++;
    } else {
      std::vector<std::vector<double>> polygon_coords = polygons[i].toCoords();
      status = mlinestrings[i].fromCoords(polygon_coords);
      if (status != FlatBufferManager::Status::Success) {
        return mgr.ERROR_MESSAGE("fromCoords failed: " + ::toString(status));
      }
    }
  }
  return size;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t ct_to_polygon__cpu_	(	TableFunctionManager &	mgr,
		const Column< GeoMultiLineString > &	mlinestrings,
		Column< GeoPolygon > &	polygons
	)

Definition at line 502 of file GeoTestTableFunctions.cpp.

References flatbuffer::Column< RowType, RowStruct >::getNofValues(), flatbuffer::Column< RowType, RowStruct >::isNull(), TableFunctionManager::set_output_item_values_total_number(), TableFunctionManager::set_output_row_size(), flatbuffer::Column< RowType, RowStruct >::setNull(), flatbuffer::Column< RowType, RowStruct >::size(), and toString().

                                                  {
  auto size = mlinestrings.size();
  mgr.set_output_item_values_total_number(0, mlinestrings.getNofValues());
  mgr.set_output_row_size(size);
  // Initialize polygons
  int count_nulls = 0;
  FlatBufferManager::Status status{};
  for (int64_t i = 0; i < size; i++) {
    if (mlinestrings.isNull(i)) {
      polygons.setNull(i);
      count_nulls++;
    } else {
      std::vector<std::vector<double>> polygon_coords;
      status = mlinestrings[i].toCoords(polygon_coords);
      if (status != FlatBufferManager::Status::Success) {
        return mgr.ERROR_MESSAGE("toCoords failed: " + ::toString(status));
      }
      status = polygons[i].fromCoords(polygon_coords);
      if (status != FlatBufferManager::Status::Success) {
        return mgr.ERROR_MESSAGE("fromCoords failed: " + ::toString(status));
      }
    }
  }
  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 273 of file RbcTestTableFunctions.cpp.

                                                     {
  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 280 of file RbcTestTableFunctions.cpp.

                                                     {
  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 288 of file RbcTestTableFunctions.cpp.

                                                     {
  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 299 of file RbcTestTableFunctions.cpp.

                                                     {
  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 307 of file RbcTestTableFunctions.cpp.

                                                     {
  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 315 of file RbcTestTableFunctions.cpp.

                                                     {
  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 323 of file RbcTestTableFunctions.cpp.

                                                     {
  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 331 of file RbcTestTableFunctions.cpp.

                                                     {
  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 339 of file RbcTestTableFunctions.cpp.

                                                     {
  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 348 of file RbcTestTableFunctions.cpp.

                                                     {
  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 357 of file RbcTestTableFunctions.cpp.

                                                     {
  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 142 of file FilterPushdownTestTableFunctions.cpp.

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 106 of file FilterPushdownTestTableFunctions.cpp.

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:

EXTENSION_NOINLINE_HOST int32_t get_max_with_row_offset__cpu_	(	const Column< int > &	input_col,
		Column< int > &	output_max_col,
		Column< int > &	output_max_row_col
	)

Definition at line 794 of file OtherTestTableFunctions.cpp.

References Column< T >::size().

                                                               {
  if ((output_max_col.size() != 1) || output_max_row_col.size() != 1) {
    return -1;
  }
  auto start = 0;
  auto stop = input_col.size();
  auto step = 1;

  int curr_max = -2147483648;
  int curr_max_row = -1;
  for (auto i = start; i < stop; i += step) {
    if (input_col[i] > curr_max) {
      curr_max = input_col[i];
      curr_max_row = i;
    }
  }
  output_max_col[0] = curr_max;
  output_max_row_col[0] = curr_max_row;
  return 1;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t row_adder	(	const int	copy_multiplier,
		const Column< double > &	input_col1,
		const Column< double > &	input_col2,
		Column< double > &	output_col
	)

Definition at line 721 of file OtherTestTableFunctions.cpp.

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

                                                                 {
  int32_t output_row_count = copy_multiplier * input_col1.size();
  if (output_row_count > 100) {
    // Test failure propagation.
    return -1;
  }
  if (output_col.size() != output_row_count) {
    return -1;
  }

#ifdef __CUDACC__
  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
  int32_t stop = static_cast<int32_t>(input_col1.size());
  int32_t step = blockDim.x * gridDim.x;
#else
  auto start = 0;
  auto stop = input_col1.size();
  auto step = 1;
#endif
  auto stride = input_col1.size();
  for (auto i = start; i < stop; i += step) {
    for (int c = 0; c < copy_multiplier; c++) {
      if (input_col1.isNull(i) || input_col2.isNull(i)) {
        output_col.setNull(i + (c * stride));
      } else {
        output_col[i + (c * stride)] = input_col1[i] + input_col2[i];
      }
    }
  }

  return output_row_count;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t row_addsub	(	const int	copy_multiplier,
		const Column< double > &	input_col1,
		const Column< double > &	input_col2,
		Column< double > &	output_col1,
		Column< double > &	output_col2
	)

Definition at line 757 of file OtherTestTableFunctions.cpp.

References Column< T >::size().

                                                                   {
  int32_t output_row_count = copy_multiplier * input_col1.size();
  if (output_row_count > 100) {
    // Test failure propagation.
    return -1;
  }
  if ((output_col1.size() != output_row_count) ||
      (output_col2.size() != output_row_count)) {
    return -1;
  }

#ifdef __CUDACC__
  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
  int32_t stop = static_cast<int32_t>(input_col1.size());
  int32_t step = blockDim.x * gridDim.x;
#else
  auto start = 0;
  auto stop = input_col1.size();
  auto step = 1;
#endif
  auto stride = input_col1.size();
  for (auto i = start; i < stop; i += step) {
    for (int c = 0; c < copy_multiplier; c++) {
      output_col1[i + (c * stride)] = input_col1[i] + input_col2[i];
      output_col2[i + (c * stride)] = input_col1[i] - input_col2[i];
    }
  }
  return output_row_count;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t row_copier	(	const Column< double > &	input_col,
		int	copy_multiplier,
		Column< double > &	output_col
	)

Definition at line 596 of file OtherTestTableFunctions.cpp.

References Column< T >::size().

Referenced by row_copier2__cpu__().

                                                                  {
  int32_t output_row_count = copy_multiplier * input_col.size();
  if (output_row_count > 100) {
    // Test failure propagation.
    return -1;
  }
  if (output_col.size() != output_row_count) {
    return -1;
  }

#ifdef __CUDACC__
  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
  int32_t stop = static_cast<int32_t>(input_col.size());
  int32_t step = blockDim.x * gridDim.x;
#else
  auto start = 0;
  auto stop = input_col.size();
  auto step = 1;
#endif

  for (auto i = start; i < stop; i += step) {
    for (int c = 0; c < copy_multiplier; c++) {
      output_col[i + (c * input_col.size())] = input_col[i];
    }
  }

  return output_row_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EXTENSION_NOINLINE_HOST int32_t row_copier2__cpu__	(	const Column< double > &	input_col,
		int	copy_multiplier,
		Column< double > &	output_col,
		Column< double > &	output_col2
	)

Definition at line 629 of file OtherTestTableFunctions.cpp.

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

                                                                                {
  if (copy_multiplier == -1) {
    // Test UDTF return without allocating output columns, expect
    // empty output columns.
    return 0;
  }
  if (copy_multiplier == -2) {
    // Test UDTF return without allocating output columns but
    // returning positive row size, expect runtime error.
    return 1;
  }
#ifndef __CUDACC__
  if (copy_multiplier == -3) {
    // Test UDTF throw before allocating output columns, expect
    // runtime error.
    throw std::runtime_error("row_copier2: throw before calling set_output_row_size");
  }
  if (copy_multiplier == -4) {
    // Test UDTF throw after allocating output columns, expect
    // runtime error.
    set_output_row_size(1);
    throw std::runtime_error("row_copier2: throw after calling set_output_row_size");
  }
#endif
  if (copy_multiplier == -5) {
    // Test UDTF setting negative row size, expect runtime error.
    set_output_row_size(-1);
  }
  int32_t output_row_count = copy_multiplier * input_col.size();
  /* set_output_row_size can be used only when an UDTF is executed on CPU */
  set_output_row_size(output_row_count);
  auto result = row_copier(input_col, copy_multiplier, output_col);
  if (result >= 0) {
    result = row_copier(input_col, copy_multiplier, output_col2);
  }
  return result;
}

Here is the call graph for this function:

EXTENSION_NOINLINE_HOST int32_t row_copier_columnlist__cpu__	(	TableFunctionManager &	mgr,
		const ColumnList< double > &	cols,
		Column< double > &	output_col
	)

Definition at line 671 of file OtherTestTableFunctions.cpp.

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

                                                         {
  int32_t output_row_count = 0;
  for (int i = 0; i < cols.numCols(); ++i) {
    output_row_count += cols[i].size();
  }
  mgr.set_output_row_size(output_row_count);
  int idx = 0;
  for (int i = 0; i < cols.numCols(); ++i) {
    for (int j = 0; j < cols[i].size(); ++j) {
      output_col[idx++] = cols[i][j];
    }
  }
  return output_row_count;
}

Here is the call graph for this function:

EXTENSION_NOINLINE int32_t row_copier_text	(	const Column< TextEncodingDict > &	input_col,
		int	copy_multiplier,
		Column< TextEncodingDict > &	output_col
	)

Definition at line 690 of file OtherTestTableFunctions.cpp.

References Column< TextEncodingDict >::size().

                                                                                 {
  int32_t output_row_count = copy_multiplier * input_col.size();
  if (output_row_count > 100) {
    // Test failure propagation.
    return -1;
  }
  if (output_col.size() != output_row_count) {
    return -2;
  }

#ifdef __CUDACC__
  int32_t start = threadIdx.x + blockDim.x * blockIdx.x;
  int32_t stop = static_cast<int32_t>(input_col.size());
  int32_t step = blockDim.x * gridDim.x;
#else
  auto start = 0;
  auto stop = input_col.size();
  auto step = 1;
#endif

  for (auto i = start; i < stop; i += step) {
    for (int c = 0; c < copy_multiplier; c++) {
      output_col[i + (c * input_col.size())] = input_col[i];
    }
  }

  return output_row_count;
}

Here is the call graph for this function:

template<typename T >

TEMPLATE_NOINLINE int32_t row_repeater__cpu_template	(	TableFunctionManager &	mgr,
		const Column< T > &	input_col,
		const int	reps,
		Column< T > &	output_col
	)

Definition at line 976 of file OtherTestTableFunctions.cpp.

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

                                                                            {
  // Equivalent to row_copier but supports output row sizes larger
  // than MAX_INT
  size_t output_row_count = input_col.size() * reps;
  mgr.set_output_row_size(output_row_count);

  auto start = 0;
  auto stop = input_col.size();
  auto step = 1;

  for (auto i = start; i < stop; i += step) {
    for (int c = 0; c < reps; c++) {
      output_col[i + (stop * c)] = input_col[i];
    }
  }

  return SUCCESS;
}

Here is the call 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 101 of file OtherTestTableFunctions.cpp.

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 29 of file ArrayTestTableFunctions.cpp.

References TableFunctionManager::get_singleton(), Array< T >::isNull(), Column< T >::setNull(), Array< T >::size(), 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 (size_t j = 0; j < arr.size(); 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 (size_t j = 0; j < arr.size(); 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 897 of file OtherTestTableFunctions.cpp.

References 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 934 of file OtherTestTableFunctions.cpp.

References 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 857 of file OtherTestTableFunctions.cpp.

References 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 874 of file OtherTestTableFunctions.cpp.

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 886 of file OtherTestTableFunctions.cpp.

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: