Aufrufen von Funktionen und gespeicherten Prozeduren in Snowpark Python¶

Aufrufen von systemdefinierten Funktionen¶

Wenn Sie systemdefinierte SQL-Funktionen aufrufen müssen, verwenden Sie die entsprechenden Funktionen des Moduls snowflake.snowpark.functions.

Im folgenden Beispiel wird die Funktion upper im Modul functions (das Äquivalent zur systemdefinierten Funktion UPPER) aufgerufen, um die Werte in der Namensspalte der Tabelle sample_product_data mit Großbuchstaben zurückzugeben:

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

Wenn im Funktionsmodul keine systemdefinierte SQL-Funktion verfügbar ist, können Sie einen der folgenden Ansätze verwenden:

• Verwenden Sie die Funktion call_function, um die systemdefinierte Funktion aufzurufen.

• Verwenden Sie die Funktion function, um ein Funktionsobjekt zu erstellen, das Sie zum Aufrufen der systemdefinierten Funktion verwenden können.

call_function und function sind im Modul snowflake.snowpark.functions definiert.

Für call_function übergeben Sie den Namen der systemdefinierten Funktion als erstes Argument. Wenn Sie die Werte von Spalten an die systemdefinierte Funktion übergeben müssen, definieren Sie Spalten-Objekte und übergeben diese als zusätzliche Argumente an die call_function-Funktion.

Im folgenden Beispiel wird die systemdefinierte Funktion RADIANS aufgerufen, die den Wert aus der Spalte col1 übergibt:

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

Die Funktion call_function gibt einen Column-Wert zurück, den Sie an die DataFrame-Transformationsmethoden (z. B. filter oder select) übergeben können.

Für function übergeben Sie den Namen der systemdefinierten Funktion, und Sie verwenden das zurückgegebene Funktionsobjekt, um die systemdefinierte Funktion aufzurufen. Beispiel:

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

Benutzerdefinierte Funktionen (UDFs)¶

Zum Aufrufen von UDFs, die Sie mit Namen registriert haben, und von UDFs, die Sie durch Ausführen von CREATE FUNCTION erstellt haben, verwenden Sie die Funktion call_udf im Modul snowflake.snowpark.functions. Übergeben Sie den Namen der UDF als erstes Argument und alle UDF-Parameter als weitere Argumente.

Im folgenden Beispiel wird die UDF-Funktion minus_one aufgerufen, wobei die Werte aus den Spalten col1 und col2 übergeben werden. Im Beispiel wird der Rückgabewert von minus_one an die Methode select des DataFrame übergeben.

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

Aufrufen benutzerdefinierter Tabellenfunktionen (UDTFs)¶

Zum Aufrufen von UDTFs, die Sie mit Namen registriert haben, und von UDTFs, die Sie durch Ausführen von CREATE FUNCTION erstellt haben, verwenden Sie eine der unten aufgeführten Funktionen. Sowohl UDTFs als auch UDFs geben ein DataFrame-Objekt zurück, das ein im Lazy-Modus ausgewertetes, relationales Dataset repräsentiert.

Beachten Sie, dass Sie damit auch andere Tabellenfunktionen aufrufen können, einschließlich systemdefinierte Tabellenfunktionen.

Weitere Informationen zur Registrierung einer UDTF finden Sie unter Registrieren einer UDTF.

• Um die UDTF aufzurufen, ohne eine seitliche Verknüpfung (Lateral Join) anzugeben, rufen Sie die Funktion table_function der Klasse snowflake.snowpark.Session auf.

  Die Funktionsreferenz und Beispiele finden Sie unter Session.table_function.

  Im folgenden Codebeispiel wird table_function verwendet, um die Funktion generator_udtf aufzurufen, die mit der Funktion udtf registriert ist.

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

• Für das Aufrufen einer UDTF, in der Ihr Aufruf eine seitliche Verknüpfung angibt, verwenden Sie die Funktion join_table_function der Klasse snowflake.snowpark.DataFrame.

  Bei der seitlichen Verknüpfung einer UDTF können Sie die Klauseln PARTITION BY und ORDER BY angeben.

  Die Funktionsreferenz und Beispiele finden Sie unter DataFrame.join_table_function.

  Im folgenden Codebeispiel wird eine seitliche Verknüpfung unter Angabe der Parameter partition_by und order_by ausgeführt. In diesem Codebeispiel wird zunächst die Funktion snowflake.snowpark.functions.table_function aufgerufen, um ein Funktionsobjekt zu erstellen, das die systemdefinierte Funktion SPLIT_TO_TABLE repräsentiert. Dieses Funktionsobjekt wird dann von join_table_function aufgerufen.

  Die Funktionsreferenz zu snowflake.snowpark.functions.table_function finden Sie unter table_function. Die Funktionsreferenz zu SPLIT_TO_TABLE finden Sie unter 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

Aufrufen von gespeicherten Prozeduren¶

Um eine gespeicherte Prozedur aufzurufen, verwenden Sie die Call-Methode der Session-Klasse.

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