Como chamar funções e procedimentos armazenados no Snowpark Python¶

Como chamar funções definidas pelo sistema¶

Se você precisar chamar funções SQL definidas pelo sistema, use as funções equivalentes no módulo snowflake.snowpark.functions.

O exemplo a seguir chama a função upper no módulo functions (o equivalente da função UPPER definida pelo sistema) para retornar os valores na coluna do nome da tabela sample_product_data com letras maiúsculas:

>>> # Import the upper function from the functions module.
>>> from snowflake.snowpark.functions import upper, col
>>> session.table("sample_product_data").select(upper(col("name")).alias("upper_name")).collect()
[Row(UPPER_NAME='PRODUCT 1'), Row(UPPER_NAME='PRODUCT 1A'), Row(UPPER_NAME='PRODUCT 1B'), Row(UPPER_NAME='PRODUCT 2'), Row(UPPER_NAME='PRODUCT 2A'), Row(UPPER_NAME='PRODUCT 2B'), Row(UPPER_NAME='PRODUCT 3'), Row(UPPER_NAME='PRODUCT 3A'), Row(UPPER_NAME='PRODUCT 3B'), Row(UPPER_NAME='PRODUCT 4'), Row(UPPER_NAME='PRODUCT 4A'), Row(UPPER_NAME='PRODUCT 4B')]

Se uma função SQL definida pelo sistema não estiver disponível no módulo de funções, você pode usar uma das seguintes abordagens:

• Use a função call_function para chamar a função definida pelo sistema.

• Use a função function para criar um objeto de função que você pode usar para chamar a função definida pelo sistema.

call_function e function são definidas no módulo snowflake.snowpark.functions.

Para call_function, passe o nome da função definida pelo sistema como o primeiro argumento. Se você precisar passar os valores das colunas para a função definida pelo sistema, defina e passe objetos Column como argumentos adicionais para a função call_function.

O exemplo a seguir chama a função definida pelo sistema RADIANS passando o valor da coluna col1:

>>> # Import the call_function function from the functions module.
>>> from snowflake.snowpark.functions import call_function
>>> df = session.create_dataframe([[1, 2], [3, 4]], schema=["col1", "col2"])
>>> # Call the system-defined function RADIANS() on col1.
>>> df.select(call_function("radians", col("col1"))).collect()
[Row(RADIANS("COL1")=0.017453292519943295), Row(RADIANS("COL1")=0.05235987755982988)]

A função call_function returna uma Column que você pode passar para os métodos de transformação de DataFrame (por exemplo, filter, select, etc.).

Para function, passe o nome da função definida pelo sistema e use o objeto da função retornada para chamar a função definida pelo sistema. Por exemplo:

>>> # Import the call_function function from the functions module.
>>> from snowflake.snowpark.functions import function

>>> # Create a function object for the system-defined function RADIANS().
>>> radians = function("radians")
>>> df = session.create_dataframe([[1, 2], [3, 4]], schema=["col1", "col2"])
>>> # Call the system-defined function RADIANS() on col1.
>>> df.select(radians(col("col1"))).collect()
[Row(RADIANS("COL1")=0.017453292519943295), Row(RADIANS("COL1")=0.05235987755982988)]

Como chamar funções definidas pelo usuário (UDFs)¶

Para chamar UDFs que você registrou pelo nome e UDFs que você criou ao executar CREATE FUNCTION, use a função call_udf no módulo snowflake.snowpark.functions. Passe o nome da UDF como o primeiro argumento e quaisquer parâmetros da UDF como argumentos adicionais.

O exemplo a seguir chama a função UDF minus_one passando os valores das colunas col1 e col2. O exemplo passa o valor de retorno de minus_one para o método select do DataFrame.

>>> # Import the call_udf function from the functions module.
>>> from snowflake.snowpark.functions import call_udf

>>> # Runs the scalar function 'minus_one' on col1 of df.
>>> df = session.create_dataframe([[1, 2], [3, 4]], schema=["col1", "col2"])
>>> df.select(call_udf("minus_one", col("col1"))).collect()
[Row(MINUS_ONE("COL1")=0), Row(MINUS_ONE("COL1")=2)]

Como chamar funções de tabela definidas pelo usuário (UDTFs)¶

Para chamar UDTFs que você registrou pelo nome e UDTFs que você criou ao executar CREATE FUNCTION, use uma das funções listadas abaixo. Ambas retornam um DataFrame representando um conjunto de dados relacionais de avaliação lenta.

Observe que você também pode usá-las para chamar outras funções de tabela, incluindo as funções de tabela definidas pelo sistema.

Para obter mais informações sobre como registrar uma UDTF, consulte Como registrar uma UDTF.

• Para chamar a UDTF sem especificar uma junção lateral, chame a função table_function na classe snowflake.snowpark.Session.

  Para obter a referência e exemplos da função, consulte Session.table_function.

  O código no exemplo a seguir usa table_function para chamar a função generator_udtf registrada com a função udtf.

  >>> from snowflake.snowpark.types import IntegerType, StructField, StructType
  >>> from snowflake.snowpark.functions import udtf, lit
  >>> class GeneratorUDTF:
  ...     def process(self, n):
  ...         for i in range(n):
  ...             yield (i, )
  >>> generator_udtf = udtf(GeneratorUDTF, output_schema=StructType([StructField("number", IntegerType())]), input_types=[IntegerType()])
  >>> session.table_function(generator_udtf(lit(3))).collect()
  [Row(NUMBER=0), Row(NUMBER=1), Row(NUMBER=2)]
  

  Copy

• Para fazer uma chamada à UDTF na qual sua chamada especifica uma junção lateral, use a função join_table_function na classe snowflake.snowpark.DataFrame.

  Quando você une uma UDTF lateralmente, você pode especificar as cláusulas PARTITION BY e ORDER BY.

  Para obter uma referência e exemplos da função, consulte DataFrame.join_table_function.

  O código no exemplo a seguir realiza uma junção lateral especificando os parâmetros partition_by e order_by. O código nesse exemplo primeiro chama a função snowflake.snowpark.functions.table_function para criar um objeto de função representando a função SPLIT_TO_TABLE definida pelo sistema. É este objeto de função que join_table_function chama posteriormente.

  Para obter uma referência da função snowflake.snowpark.functions.table_function, consulte table_function. Para obter uma referência da função SPLIT_TO_TABLE, consulte SPLIT_TO_TABLE.

  >>> from snowflake.snowpark.functions import table_function
  >>> split_to_table = table_function("split_to_table")
  >>> df = session.create_dataframe([
  ...     ["John", "James", "address1 address2 address3"],
  ...     ["Mike", "James", "address4 address5 address6"],
  ...     ["Cathy", "Stone", "address4 address5 address6"],
  ... ],
  ... schema=["first_name", "last_name", "addresses"])
  >>> df.join_table_function(split_to_table(df["addresses"], lit(" ")).over(partition_by="last_name", order_by="first_name")).show()
  ----------------------------------------------------------------------------------------
  |"FIRST_NAME"  |"LAST_NAME"  |"ADDRESSES"                 |"SEQ"  |"INDEX"  |"VALUE"   |
  ----------------------------------------------------------------------------------------
  |John          |James        |address1 address2 address3  |1      |1        |address1  |
  |John          |James        |address1 address2 address3  |1      |2        |address2  |
  |John          |James        |address1 address2 address3  |1      |3        |address3  |
  |Mike          |James        |address4 address5 address6  |2      |1        |address4  |
  |Mike          |James        |address4 address5 address6  |2      |2        |address5  |
  |Mike          |James        |address4 address5 address6  |2      |3        |address6  |
  |Cathy         |Stone        |address4 address5 address6  |3      |1        |address4  |
  |Cathy         |Stone        |address4 address5 address6  |3      |2        |address5  |
  |Cathy         |Stone        |address4 address5 address6  |3      |3        |address6  |
  ----------------------------------------------------------------------------------------
  

  Copy

Como chamar procedimentos armazenados¶

Para chamar um procedimento armazenado, use o método de chamada da classe Session.

>>> session.call("your_proc_name", 1)  
 0