Input list to Snowflake SQL udf - user-defined-functions

Question

I have created a Snowflake SQL udf I call with the following code:
select *
from table(drill_top_down('12345','XXX)) order by depth,path;
If I need to run the query for multiple items is it then possible to input a list or similar to the udf, and then loop through my input list?
Or can I somehow call my function in smarter way so I can get the result from multiple inputs?

Answer 1

You can provide a Snowflake Array, Object or Variant with your argument sets nested within, and use that as input to the table function.
Adapting your example, using array construct to provide two sets of arguments the input would look something like :
select *
from table(drill_top_down(
array_construct(
array_construct('12345','XXX'),
array_construct('67890','YYY')
)::array;
Or my preference is to use parse_json, as I find it easier to read
select *
from table(drill_top_down(parse_json('
[ ["12345","XXX"],
["67890","YYY"] ]')::array;
You will need to adapt your Table Function to unpack the Argument Sets using a common-table-expression (CTE) to tabularise the input arguments and then unnest them with Lateral Flatten.
Here's a trivial example:
CREATE OR REPLACE FUNCTION array_concat ( arr array)
RETURNS TABLE ( concatenated_string varchar )
AS
$$
With a as (Select arr)
Select listagg(value)
From a, table(flatten(input => arr))
$$
;
Here is a slightly more sophisticated example that performs an operation with each argument set, using row_number() to group them.
CREATE OR REPLACE FUNCTION array_calcs ( arg_list array)
RETURNS TABLE
( arg_id integer,
array_sz integer,
array_sum integer,
array_mean decimal(12,2) )
AS
$$
With
-- CTE containing the ARGS
arg_input as (select arg_list),
-- CTE un-nest (flatten) first level of args list to each args set
arg_sets as
(Select row_number() over (order by NULL desc) as arg_id, value as arg_set
From arg_input, lateral flatten(input => arg_list))
-- Do something with the Args. e.g. Perform some calculations with the Input arguments
Select arg_id , count(*) array_sz, sum(value)::integer array_sum, array_sum/array_sz::decimal(12,2) array_mean
From arg_sets, table(flatten(input => arg_set))
Where is_decimal( value ) or is_integer( value ) or is_double( value ) -- filter out non-numeric arguments i.e. validate inputs
Group By arg_id
$$;
This works if we provide the following input arguments
Select * from table(array_calcs(parse_json('[ [1],
[1,2],
[1,2,3],
[1,2,3,4],
["A","B"],
["A",1]
]')::array));
Producing the following:
ARG_ID
ARRAY_SZ
ARRAY_SUM
ARRAY_MEAN
1
1
1
1.0
2
2
3
1.5
3
3
6
2.0
4
4
10
2.5
6
1
1
1.0
But word of caution. If your aim was to build your arguments directly from your data, rather than hard-code them in the function call, you are more than likely to run into this issue:
Create or replace View V_array_calcs_input as
Select parse_json($1)::array arg_list
from (values ('[[1],[1,2],[1,2,3],[1,2,3,4],["A","B"], ["A",1]'));
Select *
from V_array_calcs_input,
table(array_calcs(arg_list));
SQL compilation error: Unsupported subquery type cannot be evaluated
A Stored Procedure, or JavaScript UDF/UDTF may be better options to resolve this, if you can build the functional logic you need in either of those.