Snowpark Migration Accelerator : Codes de problème pour Spark - Scala¶

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’élément Spark qui n’est pas pris en charge par Snowpark et qui génère donc cet EWI.

val df = session.range(10)
val result = df.isLocal

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1112 au code de sortie pour vous indiquer que cet élément n’est pas pris en charge par Snowpark

val df = session.range(10)
/*EWI: SPRKSCL1112 => org.apache.spark.sql.Dataset.isLocal is not supported*/
val result = df.isLocal

Correction recommandée

Comme il s’agit d’un code d’erreur générique qui s’applique à une série de fonctions non prises en charge, il n’existe pas de correction unique et spécifique. L’action appropriée dépend de l’élément utilisé.

Veuillez noter que même si l’élément n’est pas pris en charge, cela ne signifie pas nécessairement qu’il est impossible de trouver une solution ou une solution de contournement. Cela signifie seulement que l’outil SMA lui-même ne peut pas trouver la solution.

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Recommandations supplémentaires¶

• Il est peu probable qu’il s’agisse d’une erreur dans le code source lui-même, mais plutôt d’une erreur dans la manière dont SMA traite le code source. La meilleure configuration serait de signaler un problème dans SMA.

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.max, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(10, 12, 20, 15, 18).toDF("value")
val result1 = df.select(max("value"))
val result2 = df.select(max(col("value")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1153 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(10, 12, 20, 15, 18).toDF("value")
/*EWI: SPRKSCL1153 => org.apache.spark.sql.functions.max has a workaround, see documentation for more info*/
val result1 = df.select(max("value"))
/*EWI: SPRKSCL1153 => org.apache.spark.sql.functions.max has a workaround, see documentation for more info*/
val result2 = df.select(max(col("value")))

Correction recommandée

Snowpark dispose d’une fonction max équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(10, 12, 20, 15, 18).toDF("value")
val result1 = df.select(max(col("value")))
val result2 = df.select(max(col("value")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.explode utilisée pour obtenir les informations consolidées des champs du tableau du jeu de données.

    val explodeData = Seq(
      Row("Cat", Array("Gato","Chat")),
      Row("Dog", Array("Perro","Chien")),
      Row("Bird", Array("Ave","Oiseau"))
    )

    val explodeSchema = StructType(
      List(
        StructField("Animal", StringType),
        StructField("Translation", ArrayType(StringType))
      )
    )

    val rddExplode = session.sparkContext.parallelize(explodeData)

    val dfExplode = session.createDataFrame(rddExplode, explodeSchema)

    dfExplode.select(explode(dfExplode("Translation").alias("exploded")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1102 au code de sortie pour vous indiquer que cette fonction n’est pas prise en charge par Snowpark

    val explodeData = Seq(
      Row("Cat", Array("Gato","Chat")),
      Row("Dog", Array("Perro","Chien")),
      Row("Bird", Array("Ave","Oiseau"))
    )

    val explodeSchema = StructType(
      List(
        StructField("Animal", StringType),
        StructField("Translation", ArrayType(StringType))
      )
    )

    val rddExplode = session.sparkContext.parallelize(explodeData)

    val dfExplode = session.createDataFrame(rddExplode, explodeSchema)

    /*EWI: SPRKSCL1102 => Explode is not supported */
    dfExplode.select(explode(dfExplode("Translation").alias("exploded")))

Correction recommandée

Étant donné que Explode n’est pas pris en charge par Snowpark, la fonction flatten peut être utilisée comme substitut.

La correction suivante crée un aplatissement du dataframe dfExplode, puis effectue la requête pour répliquer le résultat dans Spark.

    val explodeData = Seq(
      Row("Cat", Array("Gato","Chat")),
      Row("Dog", Array("Perro","Chien")),
      Row("Bird", Array("Ave","Oiseau"))
    )

    val explodeSchema = StructType(
      List(
        StructField("Animal", StringType),
        StructField("Translation", ArrayType(StringType))
      )
    )

    val rddExplode = session.sparkContext.parallelize(explodeData)

    val dfExplode = session.createDataFrame(rddExplode, explodeSchema)

     var dfFlatten = dfExplode.flatten(col("Translation")).alias("exploded")
                              .select(col("exploded.value").alias("Translation"))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.min, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(1, 3, 10, 1, 3).toDF("value")
val result1 = df.select(min("value"))
val result2 = df.select(min(col("value")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1136 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(1, 3, 10, 1, 3).toDF("value")
/*EWI: SPRKSCL1136 => org.apache.spark.sql.functions.min has a workaround, see documentation for more info*/
val result1 = df.select(min("value"))
/*EWI: SPRKSCL1136 => org.apache.spark.sql.functions.min has a workaround, see documentation for more info*/
val result2 = df.select(min(col("value")))

Correction recommandée

Snowpark dispose d’une fonction min équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui prend un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(1, 3, 10, 1, 3).toDF("value")
val result1 = df.select(min(col("value")))
val result2 = df.select(min(col("value")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Recommandations supplémentaires¶

• Inclure un fichier de projet de configuration dans le dossier d’entrée.

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.tan, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(-1.0, 0.5, 1.0, 2.0).toDF("value")
val result1 = df.withColumn("tanh_value", tanh("value"))
val result2 = df.withColumn("tanh_value", tanh(col("value")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1147 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(-1.0, 0.5, 1.0, 2.0).toDF("value")
/*EWI: SPRKSCL1147 => org.apache.spark.sql.functions.tanh has a workaround, see documentation for more info*/
val result1 = df.withColumn("tanh_value", tanh("value"))
/*EWI: SPRKSCL1147 => org.apache.spark.sql.functions.tanh has a workaround, see documentation for more info*/
val result2 = df.withColumn("tanh_value", tanh(col("value")))

Correction recommandée

Snowpark dispose d’une fonction tanh équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(-1.0, 0.5, 1.0, 2.0).toDF("value")
val result1 = df.withColumn("tanh_value", tanh(col("value")))
val result2 = df.withColumn("tanh_value", tanh(col("value")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’utilisation de la fonction org.apache.spark.sql.functions.split qui génère cet EWI.

val df = Seq("apple,banana,orange", "grape,lemon,lime", "cherry,blueberry,strawberry").toDF("values")
val result1 = df.withColumn("split_values", split(col("values"), ","))
val result2 = df.withColumn("split_values", split(col("values"), ",", 0))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1116 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq("apple,banana,orange", "grape,lemon,lime", "cherry,blueberry,strawberry").toDF("values")
/*EWI: SPRKSCL1116 => org.apache.spark.sql.functions.split has a workaround, see documentation for more info*/
val result1 = df.withColumn("split_values", split(col("values"), ","))
/*EWI: SPRKSCL1116 => org.apache.spark.sql.functions.split has a workaround, see documentation for more info*/
val result2 = df.withColumn("split_values", split(col("values"), ",", 0))

Correction recommandée

Pour la surcharge Spark qui reçoit deux arguments, vous pouvez convertir le deuxième argument en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.lit comme solution de contournement.

La surcharge qui reçoit trois arguments n’est pas encore prise en charge par Snowpark et il n’y a pas de solution de contournement.

val df = Seq("apple,banana,orange", "grape,lemon,lime", "cherry,blueberry,strawberry").toDF("values")
val result1 = df.withColumn("split_values", split(col("values"), lit(",")))
val result2 = df.withColumn("split_values", split(col("values"), ",", 0)) // This overload is not supported yet

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de fonction org.apache.spark.sql.functions.corr, d’abord utilisée avec des noms de colonne comme arguments, puis avec des objets de colonne.

val df = Seq(
  (10.0, 20.0),
  (20.0, 40.0),
  (30.0, 60.0)
).toDF("col1", "col2")

val result1 = df.select(corr("col1", "col2"))
val result2 = df.select(corr(col("col1"), col("col2")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1122 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(
  (10.0, 20.0),
  (20.0, 40.0),
  (30.0, 60.0)
).toDF("col1", "col2")

/*EWI: SPRKSCL1122 => org.apache.spark.sql.functions.corr has a workaround, see documentation for more info*/
val result1 = df.select(corr("col1", "col2"))
/*EWI: SPRKSCL1122 => org.apache.spark.sql.functions.corr has a workaround, see documentation for more info*/
val result2 = df.select(corr(col("col1"), col("col2")))

Correction recommandée

Snowpark dispose d’une fonction corr équivalente qui reçoit deux objets de colonne comme arguments. Pour cette raison, la surcharge Spark qui reçoit des objets de colonne comme arguments est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit deux arguments de type chaîne, vous pouvez convertir les chaînes en objets de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(
  (10.0, 20.0),
  (20.0, 40.0),
  (30.0, 60.0)
).toDF("col1", "col2")

val result1 = df.select(corr(col("col1"), col("col2")))
val result2 = df.select(corr(col("col1"), col("col2")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de code intégré SQL qui ne peut pas être traité.

spark.sql("CREATE VIEW IF EXISTS My View" + "AS Select * From my Table WHERE date < current_date()")

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1173 au code de sortie pour vous indiquer que le code intégré SQL ne peut pas être traité.

/*EWI: SPRKSCL1173 => SQL embedded code cannot be processed.*/
spark.sql("CREATE VIEW IF EXISTS My View" + "AS Select * From my Table WHERE date < current_date()")

Correction recommandée

Assurez-vous que le code intégré SQL est une chaîne sans interpolations, variables ou concaténations de chaînes.

Recommandations supplémentaires¶

• Vous trouverez plus d’informations sur le code intégré SQL ici.

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Voici un exemple où l’élément à traiter n’est pas un littéral et ne peut pas être évalué par SMA.

val format_type = "csv"
spark.read.format(format_type).load(path)

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1163 au code de sortie pour vous indiquer que le paramètre format_type n’est pas une valeur littérale et, par conséquent, il ne peut pas être évalué par SMA.

/*EWI: SPRKSCL1163 => format_type is not a literal and can't be evaluated*/
val format_type = "csv"
spark.read.format(format_type).load(path)

Correction recommandée

• Assurez-vous que la valeur de la variable est valide afin d’éviter des comportements inattendus.

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.grouping_id, d’abord utilisée avec plusieurs noms de colonnes comme arguments, puis avec des objets de colonne.

val df = Seq(
  ("Store1", "Product1", 100),
  ("Store1", "Product2", 150),
  ("Store2", "Product1", 200),
  ("Store2", "Product2", 250)
).toDF("store", "product", "amount")

val result1 = df.cube("store", "product").agg(sum("amount"), grouping_id("store", "product"))
val result2 = df.cube("store", "product").agg(sum("amount"), grouping_id(col("store"), col("product")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1132 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(
  ("Store1", "Product1", 100),
  ("Store1", "Product2", 150),
  ("Store2", "Product1", 200),
  ("Store2", "Product2", 250)
).toDF("store", "product", "amount")

/*EWI: SPRKSCL1132 => org.apache.spark.sql.functions.grouping_id has a workaround, see documentation for more info*/
val result1 = df.cube("store", "product").agg(sum("amount"), grouping_id("store", "product"))
/*EWI: SPRKSCL1132 => org.apache.spark.sql.functions.grouping_id has a workaround, see documentation for more info*/
val result2 = df.cube("store", "product").agg(sum("amount"), grouping_id(col("store"), col("product")))

Correction recommandée

Snowpark dispose d’une fonction grouping_id équivalente qui reçoit plusieurs objets de colonne comme arguments. Pour cette raison, la surcharge Spark qui reçoit plusieurs objets de colonne comme arguments est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit plusieurs arguments de type chaîne, vous pouvez convertir les chaînes en objets de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(
  ("Store1", "Product1", 100),
  ("Store1", "Product2", 150),
  ("Store2", "Product1", 200),
  ("Store2", "Product2", 250)
).toDF("store", "product", "amount")

val result1 = df.cube("store", "product").agg(sum("amount"), grouping_id(col("store"), col("product")))
val result2 = df.cube("store", "product").agg(sum("amount"), grouping_id(col("store"), col("product")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’utilisation de org.apache.spark.sql.DataFrameWriter.option pour ajouter des options à une instruction du rédacteur.

df.write.format("net.snowflake.spark.snowflake").option("dbtable", tablename)

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1106 au code de sortie pour vous indiquer que la méthode option n’est pas prise en charge par Snowpark

df.write.saveAsTable(tablename)
/*EWI: SPRKSCL1106 => Writer option is not supported .option("dbtable", tablename)*/

Correction recommandée

Il n’y a pas de correction recommandée pour ce scénario.

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’utilisation de la fonction org.apache.spark.sql.functions.kurtosis qui génère cet EWI. Dans cet exemple, la fonction kurtosis est utilisée pour calculer le kurtosis de la colonne sélectionnée.

val df = Seq("1", "2", "3").toDF("elements")
val result1 = kurtosis(col("elements"))
val result2 = kurtosis("elements")

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1157 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq("1", "2", "3").toDF("elements")
/*EWI: SPRKSCL1157 => org.apache.spark.sql.functions.kurtosis has a workaround, see documentation for more info*/
val result1 = kurtosis(col("elements"))
/*EWI: SPRKSCL1157 => org.apache.spark.sql.functions.kurtosis has a workaround, see documentation for more info*/
val result2 = kurtosis("elements")

Correction recommandée

Snowpark dispose d’une fonction kurtosis équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq("1", "2", "3").toDF("elements")
val result1 = kurtosis(col("elements"))
val result2 = kurtosis(col("elements"))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.tan, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(math.Pi / 4, math.Pi / 3, math.Pi / 6).toDF("angle")
val result1 = df.withColumn("tan_value", tan("angle"))
val result2 = df.withColumn("tan_value", tan(col("angle")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1146 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(math.Pi / 4, math.Pi / 3, math.Pi / 6).toDF("angle")
/*EWI: SPRKSCL1146 => org.apache.spark.sql.functions.tan has a workaround, see documentation for more info*/
val result1 = df.withColumn("tan_value", tan("angle"))
/*EWI: SPRKSCL1146 => org.apache.spark.sql.functions.tan has a workaround, see documentation for more info*/
val result2 = df.withColumn("tan_value", tan(col("angle")))

Correction recommandée

Snowpark dispose d’une fonction tan équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(math.Pi / 4, math.Pi / 3, math.Pi / 6).toDF("angle")
val result1 = df.withColumn("tan_value", tan(col("angle")))
val result2 = df.withColumn("tan_value", tan(col("angle")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’utilisation de la fonction org.apache.spark.sql.functions.translate qui génère cet EWI. Dans cet exemple, la fonction translate est utilisée pour remplacer les caractères “a”, “e” et “o” dans chaque mot par “1”, “2” et “3”, respectivement.

val df = Seq("hello", "world", "scala").toDF("word")
val result = df.withColumn("translated_word", translate(col("word"), "aeo", "123"))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1117 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq("hello", "world", "scala").toDF("word")
/*EWI: SPRKSCL1117 => org.apache.spark.sql.functions.translate has a workaround, see documentation for more info*/
val result = df.withColumn("translated_word", translate(col("word"), "aeo", "123"))

Correction recommandée

Pour contourner le problème, vous pouvez convertir les deuxième et troisième arguments en un objet de colonne à l’aide de la fonction com.snowflake.snowpark.functions.lit.

val df = Seq("hello", "world", "scala").toDF("word")
val result = df.withColumn("translated_word", translate(col("word"), lit("aeo"), lit("123")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.cos, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(0.0, Math.PI / 4, Math.PI / 2, Math.PI).toDF("angle_radians")
val result1 = df.withColumn("cosine_value", cos("angle_radians"))
val result2 = df.withColumn("cosine_value", cos(col("angle_radians")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1123 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(0.0, Math.PI / 4, Math.PI / 2, Math.PI).toDF("angle_radians")
/*EWI: SPRKSCL1123 => org.apache.spark.sql.functions.cos has a workaround, see documentation for more info*/
val result1 = df.withColumn("cosine_value", cos("angle_radians"))
/*EWI: SPRKSCL1123 => org.apache.spark.sql.functions.cos has a workaround, see documentation for more info*/
val result2 = df.withColumn("cosine_value", cos(col("angle_radians")))

Correction recommandée

Snowpark dispose d’une fonction cos équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(0.0, Math.PI / 4, Math.PI / 2, Math.PI).toDF("angle_radians")
val result1 = df.withColumn("cosine_value", cos(col("angle_radians")))
val result2 = df.withColumn("cosine_value", cos(col("angle_radians")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’utilisation de la fonction org.apache.spark.sql.types.StructField.apply qui génère cet EWI. Dans cet exemple, la fonction apply est utilisée pour générer une instance de StructField.

val result = StructField("f1", StringType(), True, metadata)

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1172 au code de sortie pour vous indiquer que ce paramètre des métadonnées n’est pas pris en charge par Snowflake.

/*EWI: SPRKSCL1172 => Snowpark does not support StructFiled with metadata parameter.*/
val result = StructField("f1", StringType(), True, metadata)

Correction recommandée

Snowpark dispose d’une fonction com.snowflake.snowpark.types.StructField.apply équivalente qui reçoit trois paramètres. Dans ce cas, vous pouvez essayer de supprimer l’argument des métadonnées.

val result = StructField("f1", StringType(), True, metadata)

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Recommandations supplémentaires¶

• En guise de solution de contournement, vous pouvez vérifier la taille du fichier s’il est trop lourd pour être traité. Analysez également si l’outil peut y accéder afin d’éviter tout problème d’accès.

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.least, d’abord utilisée avec plusieurs noms de colonnes comme arguments, puis avec des objets de colonne.

val df = Seq((10, 20, 5), (15, 25, 30), (7, 14, 3)).toDF("value1", "value2", "value3")
val result1 = df.withColumn("least", least("value1", "value2", "value3"))
val result2 = df.withColumn("least", least(col("value1"), col("value2"), col("value3")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1133 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq((10, 20, 5), (15, 25, 30), (7, 14, 3)).toDF("value1", "value2", "value3")
/*EWI: SPRKSCL1133 => org.apache.spark.sql.functions.least has a workaround, see documentation for more info*/
val result1 = df.withColumn("least", least("value1", "value2", "value3"))
/*EWI: SPRKSCL1133 => org.apache.spark.sql.functions.least has a workaround, see documentation for more info*/
val result2 = df.withColumn("least", least(col("value1"), col("value2"), col("value3")))

Correction recommandée

Snowpark dispose d’une fonction least équivalente qui reçoit plusieurs objets de colonne comme arguments. Pour cette raison, la surcharge Spark qui reçoit plusieurs objets de colonne comme arguments est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit plusieurs arguments de type chaîne, vous pouvez convertir les chaînes en objets de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq((10, 20, 5), (15, 25, 30), (7, 14, 3)).toDF("value1", "value2", "value3")
val result1 = df.withColumn("least", least(col("value1"), col("value2"), col("value3")))
val result2 = df.withColumn("least", least(col("value1"), col("value2"), col("value3")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’utilisation de org.apache.spark.sql.DataFrameWriter.option pour enregistrer le contenu du DataFrame.

df.write.format("net.snowflake.spark.snowflake").save()

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1107 au code de sortie pour vous indiquer que la méthode d’enregistrement n’est pas prise en charge par Snowpark

df.write.saveAsTable(tablename)
/*EWI: SPRKSCL1107 => Writer method is not supported .save()*/

Correction recommandée

Il n’y a pas de correction recommandée pour ce scénario.

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.degrees, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(math.Pi, math.Pi / 2, math.Pi / 4, math.Pi / 6).toDF("radians")
val result1 = df.withColumn("degrees", degrees("radians"))
val result2 = df.withColumn("degrees", degrees(col("radians")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1156 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(math.Pi, math.Pi / 2, math.Pi / 4, math.Pi / 6).toDF("radians")
/*EWI: SPRKSCL1156 => org.apache.spark.sql.functions.degrees has a workaround, see documentation for more info*/
val result1 = df.withColumn("degrees", degrees("radians"))
/*EWI: SPRKSCL1156 => org.apache.spark.sql.functions.degrees has a workaround, see documentation for more info*/
val result2 = df.withColumn("degrees", degrees(col("radians")))

Correction recommandée

Snowpark dispose d’une fonction degrees équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(math.Pi, math.Pi / 2, math.Pi / 4, math.Pi / 6).toDF("radians")
val result1 = df.withColumn("degrees", degrees(col("radians")))
val result2 = df.withColumn("degrees", degrees(col("radians")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de fonction org.apache.spark.sql.functions.covar_samp, d’abord utilisée avec des noms de colonne comme arguments, puis avec des objets de colonne.

val df = Seq(
  (10.0, 20.0),
  (15.0, 25.0),
  (20.0, 30.0),
  (25.0, 35.0),
  (30.0, 40.0)
).toDF("value1", "value2")

val result1 = df.select(covar_samp("value1", "value2").as("sample_covariance"))
val result2 = df.select(covar_samp(col("value1"), col("value2")).as("sample_covariance"))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1127 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(
  (10.0, 20.0),
  (15.0, 25.0),
  (20.0, 30.0),
  (25.0, 35.0),
  (30.0, 40.0)
).toDF("value1", "value2")

/*EWI: SPRKSCL1127 => org.apache.spark.sql.functions.covar_samp has a workaround, see documentation for more info*/
val result1 = df.select(covar_samp("value1", "value2").as("sample_covariance"))
/*EWI: SPRKSCL1127 => org.apache.spark.sql.functions.covar_samp has a workaround, see documentation for more info*/
val result2 = df.select(covar_samp(col("value1"), col("value2")).as("sample_covariance"))

Correction recommandée

Snowpark dispose d’une fonction covar_samp équivalente qui reçoit deux objets de colonne comme arguments. Pour cette raison, la surcharge Spark qui reçoit deux objets de colonne comme arguments est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit deux arguments de type chaîne, vous pouvez convertir les chaînes en objets de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(
  (10.0, 20.0),
  (15.0, 25.0),
  (20.0, 30.0),
  (25.0, 35.0),
  (30.0, 40.0)
).toDF("value1", "value2")

val result1 = df.select(covar_samp(col("value1"), col("value2")).as("sample_covariance"))
val result2 = df.select(covar_samp(col("value1"), col("value2")).as("sample_covariance"))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.next_day, d’abord utilisée avec une chaîne comme le deuxième argument, puis avec un objet de colonne.

val df = Seq("2024-11-06", "2024-11-13", "2024-11-20").toDF("date")
val result1 = df.withColumn("next_monday", next_day(col("date"), "Mon"))
val result2 = df.withColumn("next_monday", next_day(col("date"), lit("Mon")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1113 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq("2024-11-06", "2024-11-13", "2024-11-20").toDF("date")
/*EWI: SPRKSCL1113 => org.apache.spark.sql.functions.next_day has a workaround, see documentation for more info*/
val result1 = df.withColumn("next_monday", next_day(col("date"), "Mon"))
/*EWI: SPRKSCL1113 => org.apache.spark.sql.functions.next_day has a workaround, see documentation for more info*/
val result2 = df.withColumn("next_monday", next_day(col("date"), lit("Mon")))

Correction recommandée

Snowpark dispose d’une fonction next_day équivalente qui reçoit deux objets de colonne comme arguments. Pour cette raison, la surcharge Spark qui reçoit deux objets de colonne comme arguments est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un objet de colonne et une chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.lit comme solution de contournement.

val df = Seq("2024-11-06", "2024-11-13", "2024-11-20").toDF("date")
val result1 = df.withColumn("next_monday", next_day(col("date"), lit("Mon")))
val result2 = df.withColumn("next_monday", next_day(col("date"), lit("Mon")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de code Scala non valide d’où l’outil SMA peut sortir.

Class myClass {

    def function1() & = { 1 }

    def function2() = { 2 }

    def function3() = { 3 }

}

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1002 au code de sortie pour vous indiquer que le code du fichier comporte des erreurs d’analyse, mais que SMA peut sortir de cette erreur et poursuivre l’analyse du code du fichier.

class myClass {

    def function1();//EWI: SPRKSCL1002 => Unexpected end of declaration. Failed token: '&' @(3,21).
    & = { 1 }

    def function2() = { 2 }

    def function3() = { 3 }

}

Correction recommandée

Puisque le message identifie l’erreur dans l’instruction, vous pouvez essayer d’identifier la syntaxe non valide et de la supprimer ou de commenter l’instruction pour éviter l’erreur d’analyse.

Class myClass {

    def function1() = { 1 }

    def function2() = { 2 }

    def function3() = { 3 }

}

Class myClass {

    // def function1() & = { 1 }

    def function2() = { 2 }

    def function3() = { 3 }

}

Recommandations supplémentaires¶

• Vérifiez que le code du fichier est un code Scala valide.

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de fonction pour laquelle SMA n’a pas pu déterminer un statut de mappage approprié et a, par conséquent, généré cet EWI. Dans ce cas, vous devez supposer que notDefinedFunction() est une fonction Spark valide et que le code s’exécute.

val df = session.range(10)
val result = df.notDefinedFunction()

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1142 au code de sortie pour vous indiquer que cet élément n’est pas défini.

val df = session.range(10)
/*EWI: SPRKSCL1142 => org.apache.spark.sql.DataFrame.notDefinedFunction is not defined*/
val result = df.notDefinedFunction()

Correction recommandée

Pour tenter d’identifier le problème, vous pouvez effectuer les validations suivantes :

• Vérifiez s’il s’agit d’un élément Spark valide.

• Vérifiez que la syntaxe de l’élément est correcte et qu’il est correctement orthographié.

• Vérifiez que vous utilisez une version de Spark prise en charge par SMA.

S’il s’agit d’un élément Spark valide, veuillez signaler que vous avez rencontré une erreur de conversion sur cet élément particulier en utilisant l’option Signaler un problème de l’outil SMA et incluez toute information supplémentaire que vous jugez utile.

Veuillez noter que si un élément n’est pas défini par SMA, cela ne signifie pas nécessairement qu’il n’est pas pris en charge par Snowpark. Vous devez consulter la documentation de Snowpark pour vérifier qu’un élément équivalent existe.

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.variance, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(10, 20, 30, 40, 50).toDF("value")
val result1 = df.select(variance("value"))
val result2 = df.select(variance(col("value")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1152 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(10, 20, 30, 40, 50).toDF("value")
/*EWI: SPRKSCL1152 => org.apache.spark.sql.functions.variance has a workaround, see documentation for more info*/
val result1 = df.select(variance("value"))
/*EWI: SPRKSCL1152 => org.apache.spark.sql.functions.variance has a workaround, see documentation for more info*/
val result2 = df.select(variance(col("value")))

Correction recommandée

Snowpark dispose d’une fonction variance équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(10, 20, 30, 40, 50).toDF("value")
val result1 = df.select(variance(col("value")))
val result2 = df.select(variance(col("value")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de chaînage de méthodes SparkBuilder dont de nombreuses méthodes ne sont pas prises en charge par Snowflake.

val spark = SparkSession.builder()
           .master("local")
           .appName("testApp")
           .config("spark.sql.broadcastTimeout", "3600")
           .enableHiveSupport()
           .getOrCreate()

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1103 au code de sortie pour vous indiquer que les méthodes master, appName et enableHiveSupport ne sont pas prises en charge par Snowpark. Par conséquent, cela pourrait affecter la migration de l’instruction de la session Spark.

val spark = Session.builder.configFile("connection.properties")
/*EWI: SPRKSCL1103 => SparkBuilder Method is not supported .master("local")*/
/*EWI: SPRKSCL1103 => SparkBuilder Method is not supported .appName("testApp")*/
/*EWI: SPRKSCL1103 => SparkBuilder method is not supported .enableHiveSupport()*/
.create

Correction recommandée

Pour créer la session, il est exigé d’ajouter la configuration Snowflake Snowpark appropriée.

Dans cet exemple, une variable configs est utilisée.

    val configs = Map (
      "URL" -> "https://<myAccount>.snowflakecomputing.com:<port>",
      "USER" -> <myUserName>,
      "PASSWORD" -> <myPassword>,
      "ROLE" -> <myRole>,
      "WAREHOUSE" -> <myWarehouse>,
      "DB" -> <myDatabase>,
      "SCHEMA" -> <mySchema>
    )
    val session = Session.builder.configs(configs).create

Il est également recommandé d’utiliser un fichier de configuration (profile.properties) contenant les informations relatives à la connexion :

## profile.properties file (a text file)
URL = https://<account_identifier>.snowflakecomputing.com
USER = <username>
PRIVATEKEY = <unencrypted_private_key_from_the_private_key_file>
ROLE = <role_name>
WAREHOUSE = <warehouse_name>
DB = <database_name>
SCHEMA = <schema_name>

Et avec le fichier de configuration Session.builder.configFile, la session peut être créée :

val session = Session.builder.configFile("/path/to/properties/file").create

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.sin, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(Math.PI / 2, Math.PI, Math.PI / 6).toDF("angle")
val result1 = df.withColumn("sin_value", sin("angle"))
val result2 = df.withColumn("sin_value", sin(col("angle")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1137 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(Math.PI / 2, Math.PI, Math.PI / 6).toDF("angle")
/*EWI: SPRKSCL1137 => org.apache.spark.sql.functions.sin has a workaround, see documentation for more info*/
val result1 = df.withColumn("sin_value", sin("angle"))
/*EWI: SPRKSCL1137 => org.apache.spark.sql.functions.sin has a workaround, see documentation for more info*/
val result2 = df.withColumn("sin_value", sin(col("angle")))

Correction recommandée

Snowpark dispose d’une fonction sin équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq(Math.PI / 2, Math.PI, Math.PI / 6).toDF("angle")
val result1 = df.withColumn("sin_value", sin(col("angle")))
val result2 = df.withColumn("sin_value", sin(col("angle")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénarios¶

Il existe plusieurs scénarios en fonction du type de format que vous essayez de charger. Il peut s’agir d’un format pris en charge ou non pris en charge.

spark.read.format("csv").load(path)

spark.read.csv(path)

spark.read.format("net.snowflake.spark.snowflake").load(path)

/*EWI: SPRKSCL1166 => The parameter net.snowflake.spark.snowflake is not supported for org.apache.spark.sql.DataFrameReader.format
  EWI: SPRKSCL1112 => org.apache.spark.sql.DataFrameReader.load(scala.String) is not supported*/
spark.read.format("net.snowflake.spark.snowflake").load(path)

val myFormat = "csv"
spark.read.format(myFormat).load(path)

/*EWI: SPRKSCL1163 => myFormat is not a literal and can't be evaluated
  EWI: SPRKSCL1112 => org.apache.spark.sql.DataFrameReader.load(scala.String) is not supported*/
spark.read.format(myFormat).load(path)

Recommandations supplémentaires¶

• L’emplacement Snowpark n’accepte que les emplacements Cloud utilisant une zone de préparation Snowflake.

• La documentation des méthodes prises en charge par Snowpark se trouve dans la documentation.

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’utilisation de la fonction org.apache.spark.sql.functions.trunc qui génère cet EWI.

val df = Seq(
  Date.valueOf("2024-10-28"),
  Date.valueOf("2023-05-15"),
  Date.valueOf("2022-11-20"),
).toDF("date")

val result = df.withColumn("truncated", trunc(col("date"), "month"))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1118 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(
  Date.valueOf("2024-10-28"),
  Date.valueOf("2023-05-15"),
  Date.valueOf("2022-11-20"),
).toDF("date")

/*EWI: SPRKSCL1118 => org.apache.spark.sql.functions.trunc has a workaround, see documentation for more info*/
val result = df.withColumn("truncated", trunc(col("date"), "month"))

Correction recommandée

Pour contourner le problème, vous pouvez convertir le deuxième argument en un objet de colonne à l’aide de la fonction com.snowflake.snowpark.functions.lit.

val df = Seq(
  Date.valueOf("2024-10-28"),
  Date.valueOf("2023-05-15"),
  Date.valueOf("2022-11-20"),
).toDF("date")

val result = df.withColumn("truncated", trunc(col("date"), lit("month")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple de la fonction org.apache.spark.sql.functions.toRadians, d’abord utilisée avec un nom de colonne comme argument, puis avec un objet de colonne.

val df = Seq(0, 45, 90, 180, 270).toDF("degrees")
val result1 = df.withColumn("radians", toRadians("degrees"))
val result2 = df.withColumn("radians", toRadians(col("degrees")))

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1149 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq(0, 45, 90, 180, 270).toDF("degrees")
/*EWI: SPRKSCL1149 => org.apache.spark.sql.functions.toRadians has a workaround, see documentation for more info*/
val result1 = df.withColumn("radians", toRadians("degrees"))
/*EWI: SPRKSCL1149 => org.apache.spark.sql.functions.toRadians has a workaround, see documentation for more info*/
val result2 = df.withColumn("radians", toRadians(col("degrees")))

Correction recommandée

En guise de solution de contournement, vous pouvez utiliser la fonction radians. Pour la surcharge Spark qui reçoit un argument de type chaîne, vous devez également convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col.

val df = Seq(0, 45, 90, 180, 270).toDF("degrees")
val result1 = df.withColumn("radians", radians(col("degrees")))
val result2 = df.withColumn("radians", radians(col("degrees")))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénario¶

Entrée

Vous trouverez ci-dessous un exemple d’utilisation de la fonction org.apache.spark.sql.functions.stddev_samp qui génère cet EWI. Dans cet exemple, la fonction stddev_samp est utilisée pour calculer l’écart type de l’échantillon de la colonne sélectionnée.

val df = Seq("1.7", "2.1", "3.0", "4.4", "5.2").toDF("elements")
val result1 = stddev_samp(col("elements"))
val result2 = stddev_samp("elements")

Sortie

L’outil SMA ajoute l’EWI SPRKSCL1159 au code de sortie pour vous indiquer que cette fonction n’est pas entièrement prise en charge par Snowpark, mais qu’il existe une solution de contournement.

val df = Seq("1.7", "2.1", "3.0", "4.4", "5.2").toDF("elements")
/*EWI: SPRKSCL1159 => org.apache.spark.sql.functions.stddev_samp has a workaround, see documentation for more info*/
val result1 = stddev_samp(col("elements"))
/*EWI: SPRKSCL1159 => org.apache.spark.sql.functions.stddev_samp has a workaround, see documentation for more info*/
val result2 = stddev_samp("elements")

Correction recommandée

Snowpark dispose d’une fonction stddev_samp équivalente qui reçoit un objet de colonne comme argument. Pour cette raison, la surcharge Spark qui reçoit un objet de colonne comme argument est directement prise en charge par Snowpark et ne nécessite aucun changement.

Pour la surcharge qui reçoit un argument de type chaîne, vous pouvez convertir la chaîne en un objet de colonne en utilisant la fonction com.snowflake.snowpark.functions.col comme solution de contournement.

val df = Seq("1.7", "2.1", "3.0", "4.4", "5.2").toDF("elements")
val result1 = stddev_samp(col("elements"))
val result2 = stddev_samp(col("elements"))

Recommandations supplémentaires¶

• Pour plus d’assistance, vous pouvez nous envoyer un e-mail à sma-support@snowflake.com ou signaler un problème dans l’outil SMA.

Scénarios¶

Il existe plusieurs scénarios en fonction du type de format que vous essayez de charger. Il peut s’agir d’un format pris en charge ou non pris en charge.

spark.read.format("csv").load(path)

spark.read.csv(path)

spark.read.format("net.snowflake.spark.snowflake").load(path)

/*EWI: SPRKSCL1108 => The parameter net.snowflake.spark.snowflake is not supported for org.apache.spark.sql.DataFrameReader.format
  EWI: SPRKSCL1112 => org.apache.spark.sql.DataFrameReader.load(scala.String) is not supported*/
spark.read.format("net.snowflake.spark.snowflake").load(path)