Appeler des fonctions et des procédures stockées dans Python Snowpark¶

Appel de fonctions définies par le système¶

Si vous devez appeler des fonctions SQL définies par le système, utilisez les fonctions équivalentes dans le module snowflake.snowpark.functions.

L’exemple suivant appelle la fonction upper du module functions (l’équivalent de la fonction UPPER définie par le système) pour renvoyer les valeurs de la colonne nom de la table sample_product_data avec les lettres en majuscules :

>>> # 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')]

Si une fonction SQL définie par le système n’est pas disponible dans le module fonctions, vous pouvez utiliser l’une des approches suivantes :

• Utilisez la fonction call_function pour appeler la fonction définie par le système.

• Utilisez la fonction function pour créer un objet fonction que vous pouvez utiliser pour appeler la fonction définie par le système.

call_function et function sont définis dans le module snowflake.snowpark.functions.

Pour call_function, transmettez le nom de la fonction définie par le système comme premier argument. Si vous devez transmettre les valeurs des colonnes à la fonction définie par le système, définissez et transmettez les objets colonne comme arguments supplémentaires dans la fonction call_function.

L’exemple suivant appelle la fonction RADIANS définie par le système, en lui transmettant la valeur de la colonne 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)]

La fonction call_function renvoie un Column, que vous pouvez transmettre aux méthodes de transformation DataFrame (par exemple, filter, select, etc.).

Pour function, transmettez le nom de la fonction définie par le système, et utilisez l’objet fonction retourné pour appeler la fonction définie par le système. Par exemple :

>>> # 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)]

Appel de fonctions définies par l’utilisateur (UDFs)¶

Pour appeler des UDFs que vous avez enregistrées par le nom et des UDFs que vous avez créées en exécutant CREATEFUNCTION, utilisez la fonction call_udf dans le module snowflake.snowpark.functions. Transmettez le nom de l’UDF comme premier argument et tous les paramètres de l’UDF comme arguments supplémentaires.

L’exemple suivant appelle la fonction UDF minus_one, en lui transmettant les valeurs des colonnes col1 et col2. L’exemple transmet la valeur de retour de minus_one à la méthode select de 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)]

Appels de fonctions de table définies par l’utilisateur (UDTFs)¶

Pour appeler des UDTFs que vous avez enregistrées par le nom et des UDTFs que vous avez créées en exécutant CREATEFUNCTION, utilisez l’une des fonctions répertoriées ci-dessous. Les deux retournent un DataFrame représentant un ensemble de données relationnelles évaluées tardivement.

Notez que vous pouvez les utiliser pour appeler d’autres fonctions de table, y compris les fonctions de table définies par le système.

Pour plus d’informations sur l’enregistrement d’une UDTF, voir Enregistrement d’une UDTF.

• Pour appeler l’UDTF sans spécifier de jointure latérale, appelez la fonction table_function dans la classe snowflake.snowpark.Session.

  Pour la référence de la fonction et des exemples, voir Session.table_function.

  Le code de l’exemple suivant utilise table_function pour appeler la fonction generator_udtf enregistrée avec la fonction 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

• Pour faire un appel à l’UDTF dans laquelle votre appel spécifie une jointure latérale, utilisez la fonction join_table_function dans la classe snowflake.snowpark.DataFrame.

  Lorsque vous joignez latéralement une UDTF, vous pouvez spécifier les clauses PARTITION BY et ORDER BY.

  Pour la référence de la fonction et des exemples, voir DataFrame.join_table_function.

  Le code de l’exemple suivant effectue une jointure latérale, en spécifiant les paramètres partition_by et order_by. Le code de cet exemple appelle d’abord la fonction snowflake.snowpark.functions.table_function pour créer un objet fonction représentant la fonction SPLIT_TO_TABLE définie par le système. C’est cet objet fonction que join_table_function appelle ensuite.

  Pour la référence de la fonction snowflake.snowpark.functions.table_function voir table_function. Pour la référence de la fonction SPLIT_TO_TABLE voir 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

Appel de procédures stockées¶

Pour appeler une procédure stockée, utilisez la méthode d’appel de la classe Session.

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