Snowpark Migration Accelerator：Spark 的问题代码 – Scala¶
SPRKSCL1126¶
消息：org.apache.spark.sql.functions.covar_pop 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用 org.apache.spark.sql.functions.covar_pop (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#covar_pop(columnName1:String,columnName2:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
输入
以下是 org.apache.spark.sql.functions.covar_pop 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(
(10.0, 100.0),
(20.0, 150.0),
(30.0, 200.0),
(40.0, 250.0),
(50.0, 300.0)
).toDF("column1", "column2")
val result1 = df.select(covar_pop("column1", "column2").as("covariance_pop"))
val result2 = df.select(covar_pop(col("column1"), col("column2")).as("covariance_pop"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1126，以告知您 Snowpark 并非完全支持此函数，但它有替代方案。
val df = Seq(
(10.0, 100.0),
(20.0, 150.0),
(30.0, 200.0),
(40.0, 250.0),
(50.0, 300.0)
).toDF("column1", "column2")
/*EWI: SPRKSCL1126 => org.apache.spark.sql.functions.covar_pop has a workaround, see documentation for more info*/
val result1 = df.select(covar_pop("column1", "column2").as("covariance_pop"))
/*EWI: SPRKSCL1126 => org.apache.spark.sql.functions.covar_pop has a workaround, see documentation for more info*/
val result2 = df.select(covar_pop(col("column1"), col("column2")).as("covariance_pop"))
推荐修复方法
Snowpark 拥有等效的 covar_pop 函数，该函数接收两个列对象作为实参。因此，Snowpark 直接支持接收两个列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收两个字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
(10.0, 100.0),
(20.0, 150.0),
(30.0, 200.0),
(40.0, 250.0),
(50.0, 300.0)
).toDF("column1", "column2")
val result1 = df.select(covar_pop(col("column1"), col("column2")).as("covariance_pop"))
val result2 = df.select(covar_pop(col("column1"), col("column2")).as("covariance_pop"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1112¶
消息：不支持 spark 元素
类别:转换错误
描述¶
当 SMA 检测到使用了 Snowpark 不支持的 Spark 元素且它没有自己的相关错误代码时，就会出现此问题。这是 SMA 对任何不支持的 Spark 元素使用的通用错误代码。
场景¶
输入
以下是 Snowpark 不支持的 Spark 元素的示例，因此它会生成此 EWI。
val df = session.range(10)
val result = df.isLocal
输出
SMA 在输出代码中添加了 EWI SPRKSCL1112，以告知您 Snowpark 不支持此元素。
val df = session.range(10)
/*EWI: SPRKSCL1112 => org.apache.spark.sql.Dataset.isLocal is not supported*/
val result = df.isLocal
推荐修复方法
由于这是适用于一系列不支持的函数的通用错误代码，因此没有单一的具体修复方法。相应的操作将取决于所使用的特定元素。
请注意，尽管不支持该元素，但这并不一定意味着找不到解决方案或替代方案。这仅意味着 SMA 本身无法找到解决方案。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1143¶
消息：加载符号表时出错
类别:转换错误
描述¶
如果加载 SMA 符号表的符号时出错，就会出现此问题。符号表是 SMA 基础架构的一部分，允许进行更复杂的转换。
其他建议¶
这不太可能是源代码本身存在错误，而更可能是 SMA 处理源代码的方式出现了错误。最佳解决方案是 在 SMA 中 提交问题。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1153¶
警告
自 Spark Conversion Core 版本 4.3.2 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.max 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.max (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#max(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.max 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(10, 12, 20, 15, 18).toDF("value")
val result1 = df.select(max("value"))
val result2 = df.select(max(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1153，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 max 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(10, 12, 20, 15, 18).toDF("value")
val result1 = df.select(max(col("value")))
val result2 = df.select(max(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1102¶
自 Spark Conversion Core 2.3.22 起，此问题代码已 弃用
消息：不支持 Explode
类别:警告
描述¶
当 SMA 检测到使用了 Snowpark 不支持的 org.apache.spark.sql.functions.explode (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#explode(e:org.apache.spark.sql.Column):org.apache.spark.sql.Column) 函数时，就会出现此问题。
场景¶
输入
以下是 org.apache.spark.sql.functions.explode 函数示例，用于获取数据集的数组字段的合并信息。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1102，以告知您 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")))
推荐修复方法
由于 Snowpark 不支持 explode，因此可以使用函数 flatten 作为替代方案。
以下修复方法先扁平化处理 dfExplode 数据框，然后在 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"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1136¶
警告
自 Spark Conversion Core 4.3.2 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.min 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.min (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#min(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.min 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(1, 3, 10, 1, 3).toDF("value")
val result1 = df.select(min("value"))
val result2 = df.select(min(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1136，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 min 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接受字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(1, 3, 10, 1, 3).toDF("value")
val result1 = df.select(min(col("value")))
val result2 = df.select(min(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1167¶
消息：在输入文件夹中找不到项目文件
类别:警告
描述¶
当 SMA 检测到输入文件夹中没有任何项目配置文件时，就会出现此问题。SMA 支持的项目配置文件包括：
build.sbt
build.gradle
pom.xml
其他建议¶
向输入文件夹中添加配置项目文件。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1147¶
消息：org.apache.spark.sql.functions.tanh 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到有人使用了 org.apache.spark.sql.functions.tanh (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#tanh(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.tanh 函数示例，首先使用列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1147，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 tanh 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1116¶
警告
自 Spark Conversion Core 版本 2.40.1 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.split 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.split (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#split(str:org.apache.spark.sql.Column,pattern:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.split 函数的示例。
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))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1116，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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))
推荐修复方法
对于接收两个实参的 Spark 重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.lit 函数将第二个实参转换为列对象。
Snowpark 尚不支持接收三个实参的重载，也没有替代方案。
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
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1122¶
消息：org.apache.spark.sql.functions.corr 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.corr (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#corr(columnName1:String,columnName2:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.corr 函数示例，首先使用列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1122，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 corr 函数，该函数接收两个列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收两个字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1173¶
消息：无法处理嵌入式 SQL 代码。
类别:警告。
描述¶
当 SMA 检测到无法处理的嵌入式 SQL 代码时，就会出现此问题。然后，嵌入式 SQL 代码无法转换为 Snowflake。
场景¶
输入
以下是无法处理的嵌入式 SQL 代码的示例。
spark.sql("CREATE VIEW IF EXISTS My View" + "AS Select * From my Table WHERE date < current_date()")
输出
SMA 在输出代码中添加了 EWI SPRKSCL1173，以告知您无法处理嵌入式 SQL 代码。
/*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()")
推荐修复方法
确保嵌入式 SQL 代码是不含插值、变量或字符串拼接的字符串。
其他建议¶
您可以在 此处 找到有关嵌入式 SQL 的更多信息。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1163¶
消息：该元素非字面量，无法进行计算。
类别:转换错误。
描述¶
如果当前处理元素非字面量，而 SMA 无法对其进行计算，就会出现此问题。
场景¶
输入
以下示例展示了当待处理元素非字面量时，SMA 无法对其进行计算的情况。
val format_type = "csv"
spark.read.format(format_type).load(path)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1163，以告知您 format_type 参数非字面量，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)
推荐修复方法
确保变量的值是有效的，以避免意外行为。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1132¶
消息：org.apache.spark.sql.functions.grouping_id 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.grouping_id (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#grouping_id(colName:String,colNames:String*):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.grouping_id 函数示例，首先使用多个列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1132，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 grouping_id 函数，该函数接收多个列对象作为实参。因此，Snowpark 直接支持接收多个列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收多个字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1106¶
警告
此问题代码已 弃用
消息：不支持 Writer 选项。
类别:转换错误。
描述¶
当该工具在 writer 语句中检测到使用了 Snowpark 不支持的选项时，就会出现此问题。
场景¶
输入
以下是用于向 writer 语句添加选项的 org.apache.spark.sql.DataFrameWriter.option (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/DataFrameWriter.html) 的示例。
df.write.format("net.snowflake.spark.snowflake").option("dbtable", tablename)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1106，以告知您 Snowpark 不支持该选项方法。
df.write.saveAsTable(tablename)
/*EWI: SPRKSCL1106 => Writer option is not supported .option("dbtable", tablename)*/
推荐修复方法
对于此场景，没有推荐的修复方法
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1157¶
消息：org.apache.spark.sql.functions.kurtosis 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.kurtosis (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#kurtosis(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.kurtosis 函数的示例。在此示例中，kurtosis 函数用于计算所选列的峰度。
val df = Seq("1", "2", "3").toDF("elements")
val result1 = kurtosis(col("elements"))
val result2 = kurtosis("elements")
输出
SMA 在输出代码中添加了 EWI SPRKSCL1157，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")
推荐修复方法
Snowpark 拥有等效的 kurtosis 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq("1", "2", "3").toDF("elements")
val result1 = kurtosis(col("elements"))
val result2 = kurtosis(col("elements"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1146¶
消息：org.apache.spark.sql.functions.tan 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用 org.apache.spark.sql.functions.tan (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#tan(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.tan 函数示例，首先使用列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1146，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 tan 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1117¶
警告
自 Spark Conversion Core 2.40.1 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.translate 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.translate (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#translate(src:org.apache.spark.sql.Column,matchingString:String,replaceString:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.translate 函数的示例。在此示例中，translate 函数用于将每个单词中的字符 “a”、“e” 和 “o” 分别替换为 “1”、“2” 和 “3”。
val df = Seq("hello", "world", "scala").toDF("word")
val result = df.withColumn("translated_word", translate(col("word"), "aeo", "123"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1117，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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"))
推荐修复方法
替代方案是，您可以使用 com.snowflake.snowparke.snowpark.functions.lit 函数将第二个和第三个实参转换为列对象。
val df = Seq("hello", "world", "scala").toDF("word")
val result = df.withColumn("translated_word", translate(col("word"), lit("aeo"), lit("123")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1123¶
消息：org.apache.spark.sql.functions.cos 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.cos (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#cos(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.cos 函数示例，首先使用列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1123，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 cos 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1172¶
消息：Snowpark 不支持带有元数据参数的 StructFiled。
类别:警告
描述¶
当 SMA 检测到 org.apache.spark.sql.types.StructField.apply (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/types/StructField.html) 带有 org.apache.spark.sql.types.Metadata (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/types/Metadata.html) 参数，就会出现此问题。这是因为 Snowpark 不支持元数据参数。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.types.StructField.apply 函数的示例。在此示例中，apply 函数用于生成 StructField 的实例。
val result = StructField("f1", StringType(), True, metadata)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1172，以告知您 Snowflake 不支持元数据参数。
/*EWI: SPRKSCL1172 => Snowpark does not support StructFiled with metadata parameter.*/
val result = StructField("f1", StringType(), True, metadata)
推荐修复方法
Snowpark 拥有等效的 com.snowflake.snowpark.types.StructField.apply 函数，该函数接收三个参数。然后，作为替代方案，可以尝试删除元数据实参。
val result = StructField("f1", StringType(), True, metadata)
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1162¶
备注
此问题代码已 弃用
消息：提取 dbc 文件时出错。
类别:警告。
描述¶
当无法提取 dbc 文件时，就会出现此问题。此警告可能是由以下一个或多个原因引起的：文件过大、无法访问、只读等。
其他建议¶
作为一种替代方案，如果文件太大无法处理，则可以检查文件的大小。此外，分析该工具是否可以访问文件，以免出现任何访问问题。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1133¶
消息：org.apache.spark.sql.functions.least 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.least (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#least(columnName:String,columnNames:String*):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.least 函数示例，首先使用多个列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1133，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 least 函数，该函数接收多个列对象作为实参。因此，Snowpark 直接支持接收多个列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收多个字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1107¶
警告
此问题代码已 弃用
消息：不支持 Writer save。
类别:转换错误。
描述¶
当该工具在 writer 语句中检测到使用了 Snowpark 不支持的 writer save 方法时，就会出现此问题。
场景¶
输入
以下是用于保存 DataFrame 内容的 org.apache.spark.sql.DataFrameWriter.save (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/DataFrameWriter.html) 的示例。
df.write.format("net.snowflake.spark.snowflake").save()
输出
SMA 在输出代码中添加了 EWI SPRKSCL1107，以告知您 Snowpark 不支持该保存方法。
df.write.saveAsTable(tablename)
/*EWI: SPRKSCL1107 => Writer method is not supported .save()*/
推荐修复方法
对于此场景，没有推荐的修复方法
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1156¶
消息：org.apache.spark.sql.functions.degrees 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.degrees (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#degrees(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.degrees 函数示例，首先使用列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1156，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 degrees 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1127¶
消息：org.apache.spark.sql.functions.covar_samp 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.covar_samp (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#covar_samp(columnName1:String,columnName2:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.covar_samp 函数示例，首先使用列名作为实参，然后使用列对象。
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"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1127，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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"))
推荐修复方法
Snowpark 拥有等效的 covar_samp 函数，该函数接收两个列对象作为实参。因此，Snowpark 直接支持接收两个列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收两个字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1113¶
消息：org.apache.spark.sql.functions.next_day 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.next_day (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#next_day(date:org.apache.spark.sql.Column,dayOfWeek:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.next_day 函数的示例，首先使用字符串作为第二个实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1113，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 next_day 函数，该函数接收两个列对象作为实参。因此，Snowpark 直接支持接收两个列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收列对象和字符串的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.lit (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#lit(literal:Any):org.apache.spark.sql.Column) 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1002¶
消息：此代码段包含解析错误恢复 语句
类别:解析错误。
描述¶
当 SMA 检测到文件代码中存在某些无法正确读取或理解的语句时，就会出现此问题，称为 解析错误，但是 SMA 可以从该解析错误中恢复并继续分析文件代码。在这种情况下，SMA 能够毫无错误地处理文件的代码。
场景¶
输入
以下是 SMA 可以恢复的无效 Scala 代码示例。
Class myClass {
def function1() & = { 1 }
def function2() = { 2 }
def function3() = { 3 }
}
输出
SMA 在输出代码中添加了 EWI SPRKSCL1002，以告知您文件的代码存在解析错误，但是 SMA 可以从该错误中恢复并继续分析文件代码。
class myClass {
def function1();//EWI: SPRKSCL1002 => Unexpected end of declaration. Failed token: '&' @(3,21).
& = { 1 }
def function2() = { 2 }
def function3() = { 3 }
}
推荐修复方法
由于该消息指出了语句中的错误，因此您可以尝试识别无效语法并将其删除，或注释掉该语句以避免解析错误。
Class myClass {
def function1() = { 1 }
def function2() = { 2 }
def function3() = { 3 }
}
Class myClass {
// def function1() & = { 1 }
def function2() = { 2 }
def function3() = { 3 }
}
其他建议¶
检查该文件的代码是否为有效的 Scala 代码。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1142¶
消息：spark 元素 未定义
类别:转换错误
描述¶
当 SMA 无法确定给定元素的相应映射状态时，就会出现此问题。这意味着，SMA 还不知道 Snowpark 是否支持该元素。请注意，这是 SMA 对任何未定义元素使用的通用错误代码。
场景¶
输入
以下是 SMA 无法确定相应映射状态的函数示例，因此生成了此 EWI。在这种情况下，应假设 notDefinedFunction() 是有效的 Spark 函数，代码就可以运行了。
val df = session.range(10)
val result = df.notDefinedFunction()
输出
SMA 在输出代码中添加了 EWI SPRKSCL1142，以提示此元素未定义。
val df = session.range(10)
/*EWI: SPRKSCL1142 => org.apache.spark.sql.DataFrame.notDefinedFunction is not defined*/
val result = df.notDefinedFunction()
推荐修复方法
要尝试找出问题，可以执行以下验证：
检查它是否为有效的 Spark 元素。
检查元素的语法是否正确以及拼写是否正确。
检查是否使用的是 SMA 支持的 Spark 版本。
如果是有效的 Spark 元素，请使用 SMA 的 Report an Issue 选项报告您遇到的有关该特定元素的转换错误，并添加您认为可能有帮助的任何其他信息。
请注意，如果 SMA 未定义某个元素，不一定意味着 Snowpark 不支持该元素。您应该查看 [Snowpark 文档] (https://docs.snowflake.com/developer-guide/snowpark/reference/scala/com/snowflake/snowpark/index.html) 以验证是否存在等效元素。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1152¶
消息：org.apache.spark.sql.functions.variance 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.variance (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#variance(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.variance 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(10, 20, 30, 40, 50).toDF("value")
val result1 = df.select(variance("value"))
val result2 = df.select(variance(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1152，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 variance 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(10, 20, 30, 40, 50).toDF("value")
val result1 = df.select(variance(col("value")))
val result2 = df.select(variance(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1103¶
此问题代码已 弃用
消息：SparkBuilder 方法不是受支持的 方法名称
类别:转换错误
描述¶
当 SMA 在 SparkBuilder 方法链接中检测到 Snowflake 不支持的方法时，就会出现此问题。因此，这可能会影响 reader 语句的迁移。
以下是不支持的 SparkBuilder 方法：
master
appName
enableHiveSupport
withExtensions
场景¶
输入
以下是 SparkBuilder 方法链接的示例，其中包含许多 Snowflake 不支持的方法。
val spark = SparkSession.builder()
.master("local")
.appName("testApp")
.config("spark.sql.broadcastTimeout", "3600")
.enableHiveSupport()
.getOrCreate()
输出
SMA 在输出代码中添加了 EWI SPRKSCL1103，以告知您 Snowpark 不支持 master、appName 和 enableHiveSupport 方法。然后，这可能会影响 Spark Session 语句的迁移。
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
推荐修复方法
要创建会话，需要添加适当的 Snowflake Snowpark 配置。
在此示例中，使用了配置变量。
val configs = Map (
"URL" -> "https://<myAccount>.snowflakecomputing.cn:<port>",
"USER" -> <myUserName>,
"PASSWORD" -> <myPassword>,
"ROLE" -> <myRole>,
"WAREHOUSE" -> <myWarehouse>,
"DB" -> <myDatabase>,
"SCHEMA" -> <mySchema>
)
val session = Session.builder.configs(configs).create
此外，还建议使用包含连接信息的 configFile (profile.properties)：
## profile.properties file (a text file)
URL = https://<account_identifier>.snowflakecomputing.cn
USER = <username>
PRIVATEKEY = <unencrypted_private_key_from_the_private_key_file>
ROLE = <role_name>
WAREHOUSE = <warehouse_name>
DB = <database_name>
SCHEMA = <schema_name>
使用 Session.builder.configFile 可以创建会话：
val session = Session.builder.configFile("/path/to/properties/file").create
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1137¶
消息：org.apache.spark.sql.functions.sin 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.sin (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#sin(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.sin 函数示例，首先使用列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1137，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
Snowpark 拥有等效的 sin 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1166¶
备注
此问题代码已 弃用
消息：不支持 org.apache.spark.sql.DataFrameReader.format。
类别:警告。
描述¶
当 org.apache.spark.sql.DataFrameReader.format (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/DataFrameReader.html#format(source:String):org.apache.spark.sql.DataFrameReader) 具有 Snowpark 不支持的实参时，就会出现此问题。
场景¶
根据您尝试加载的格式类型，分为几种情况。它可以是 supported 或 non-supported 格式。
场景 1¶
输入
该工具会分析尝试加载的格式类型，支持的格式有：
csvjsonorcparquettext
以下示例显示了该工具在传递 csv 值时如何转换 format 方法。
spark.read.format("csv").load(path)
输出
当加载函数有一个参数时，该工具会将 format 方法转换为 csv 方法调用。
spark.read.csv(path)
推荐修复方法
在此示例中，该工具不显示 EWI，这意味着无需修复。
场景 2¶
输入
以下示例显示了该工具在传递 net.snowflake.spark.snowflake 值时如何转换 format 方法。
spark.read.format("net.snowflake.spark.snowflake").load(path)
输出
该工具显示 EWI SPRKSCL1166，表示不支持值 net.snowflake.spark.snowflake。
/*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)
推荐修复方法
对于 not supported 场景，没有具体的修复方法，因为它取决于尝试读取的文件。
场景 3¶
输入
以下示例显示了该工具在传递 csv 时如何转换 format 方法，但改用变量。
val myFormat = "csv"
spark.read.format(myFormat).load(path)
输出
由于该工具无法在运行时确定变量的值，因此会显示 EWI SPRKSCL1163，提不支持该值。
/*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)
推荐修复方法
替代方案是，您可以检查变量的值并将其作为字符串添加到 format 调用中。
其他建议¶
Snowpark 位置仅接受使用 Snowflake 暂存区 的云位置。
Snowpark 支持的方法的文档可以在 文档 中找到
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1118¶
消息：org.apache.spark.sql.functions.trunc 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.trunc (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#trunc(date:org.apache.spark.sql.Column,format:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.trunc 函数的示例。
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"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1118，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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"))
推荐修复方法
替代方案是，您可以使用 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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1149¶
消息：org.apache.spark.sql.functions.toRadians 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.toRadians (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#toRadians(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.toRadians 函数示例，首先使用列名作为实参，然后使用列对象。
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")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1149，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")))
推荐修复方法
替代方案是，您可以使用 radians 函数。对于接收字符串实参的 Spark 重载，还必须使用 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")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1159¶
消息：org.apache.spark.sql.functions.stddev_samp 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.stddev_samp (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#stddev_samp(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.stdev_samp 函数的示例。在此示例中，使用 stddev_samp 函数来计算所选列的样本标准差。
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")
输出
SMA 在输出代码中添加了 EWI SPRKSCL1159，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
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")
推荐修复方法
Snowpark 拥有等效的 stddev_samp 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
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"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1108¶
备注
此问题代码已 弃用。
消息：不支持 org.apache.spark.sql.DataFrameReader.format。
类别:警告。
描述¶
当 org.apache.spark.sql.DataFrameReader.format (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/DataFrameReader.html#format(source:String):org.apache.spark.sql.DataFrameReader) 具有 Snowpark 不支持的实参时，就会出现此问题。
场景¶
根据您尝试加载的格式类型，分为几种情况。它可以是 supported 或 non-supported 格式。
场景 1¶
输入
该工具会分析尝试加载的格式类型，支持的格式有：
csvjsonorcparquettext
以下示例显示了该工具在传递 csv 值时如何转换 format 方法。
spark.read.format("csv").load(path)
输出
当加载函数有一个参数时，该工具会将 format 方法转换为 csv 方法调用。
spark.read.csv(path)
推荐修复方法
在此示例中，该工具不显示 EWI，这意味着无需修复。
场景 2¶
输入
以下示例显示了该工具在传递 net.snowflake.spark.snowflake 值时如何转换 format 方法。
spark.read.format("net.snowflake.spark.snowflake").load(path)
输出
该工具显示 EWI SPRKSCL1108，表示不支持值 net.snowflake.spark.snowflake。
/*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)
推荐修复方法
对于 not supported 场景，没有具体的修复方法，因为它取决于尝试读取的文件。
场景 3¶
输入
以下示例显示了该工具在传递 csv 时如何转换 format 方法，但改用变量。
val myFormat = "csv"
spark.read.format(myFormat).load(path)
输出
由于该工具无法在运行时确定变量的值，因此会显示 EWI SPRKSCL1163，提不支持该值。
/*EWI: SPRKSCL1108 => 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)
推荐修复方法
替代方案是，您可以检查变量的值并将其作为字符串添加到 format 调用中。
其他建议¶
Snowpark 位置仅接受使用 Snowflake 暂存区 的云位置。
Snowpark 支持的方法的文档可以在 文档 中找到
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1128¶
消息：org.apache.spark.sql.functions.exp 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.exp (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#exp(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.exp 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(1.0, 2.0, 3.0).toDF("value")
val result1 = df.withColumn("exp_value", exp("value"))
val result2 = df.withColumn("exp_value", exp(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1128，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(1.0, 2.0, 3.0).toDF("value")
/*EWI: SPRKSCL1128 => org.apache.spark.sql.functions.exp has a workaround, see documentation for more info*/
val result1 = df.withColumn("exp_value", exp("value"))
/*EWI: SPRKSCL1128 => org.apache.spark.sql.functions.exp has a workaround, see documentation for more info*/
val result2 = df.withColumn("exp_value", exp(col("value")))
推荐修复方法
Snowpark 拥有等效的 exp 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(1.0, 2.0, 3.0).toDF("value")
val result1 = df.withColumn("exp_value", exp(col("value")))
val result2 = df.withColumn("exp_value", exp(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1169¶
消息：方法链接中缺少 Spark 元素。
类别:警告。
描述¶
当 SMA 检测到方法链接中缺少 Spark 元素调用时，就会出现此问题。SMA 需要知道 Spark 元素才能分析该语句。
场景¶
输入
以下是方法链接中缺少加载函数调用的示例。
val reader = spark.read.format("json")
val df = reader.load(path)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1169，以告知您方法链接中缺少负载函数调用，SMA 无法分析该语句。
/*EWI: SPRKSCL1169 => Function 'org.apache.spark.sql.DataFrameReader.load' is missing on the method chaining*/
val reader = spark.read.format("json")
val df = reader.load(path)
推荐修复方法
确保方法链接的所有函数调用都在同一语句中。
val reader = spark.read.format("json").load(path)
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1138¶
消息：org.apache.spark.sql.functions.sinh 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.sinh (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#sinh(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.sinh 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(0.0, 1.0, 2.0, 3.0).toDF("value")
val result1 = df.withColumn("sinh_value", sinh("value"))
val result2 = df.withColumn("sinh_value", sinh(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1138，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(0.0, 1.0, 2.0, 3.0).toDF("value")
/*EWI: SPRKSCL1138 => org.apache.spark.sql.functions.sinh has a workaround, see documentation for more info*/
val result1 = df.withColumn("sinh_value", sinh("value"))
/*EWI: SPRKSCL1138 => org.apache.spark.sql.functions.sinh has a workaround, see documentation for more info*/
val result2 = df.withColumn("sinh_value", sinh(col("value")))
推荐修复方法
Snowpark 拥有等效的 sinh 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(0.0, 1.0, 2.0, 3.0).toDF("value")
val result1 = df.withColumn("sinh_value", sinh(col("value")))
val result2 = df.withColumn("sinh_value", sinh(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1129¶
消息：org.apache.spark.sql.functions.floor 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.floor (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#floor(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.floor 函数的示例，首先使用列名作为实参，然后使用列对象，最后使用两个列对象。
val df = Seq(4.75, 6.22, 9.99).toDF("value")
val result1 = df.withColumn("floor_value", floor("value"))
val result2 = df.withColumn("floor_value", floor(col("value")))
val result3 = df.withColumn("floor_value", floor(col("value"), lit(1)))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1129，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(4.75, 6.22, 9.99).toDF("value")
/*EWI: SPRKSCL1129 => org.apache.spark.sql.functions.floor has a workaround, see documentation for more info*/
val result1 = df.withColumn("floor_value", floor("value"))
/*EWI: SPRKSCL1129 => org.apache.spark.sql.functions.floor has a workaround, see documentation for more info*/
val result2 = df.withColumn("floor_value", floor(col("value")))
/*EWI: SPRKSCL1129 => org.apache.spark.sql.functions.floor has a workaround, see documentation for more info*/
val result3 = df.withColumn("floor_value", floor(col("value"), lit(1)))
推荐修复方法
Snowpark 拥有等效的 floor 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
对于接收列对象和标度的重载，可以使用 callBuiltin 函数调用 Snowflake 内置的 FLOOR 函数。要使用它，你应该将字符串 ** "floor" **作为第一个实参，将列作为第二个实参传递，将标度传递为第三个实参。
val df = Seq(4.75, 6.22, 9.99).toDF("value")
val result1 = df.withColumn("floor_value", floor(col("value")))
val result2 = df.withColumn("floor_value", floor(col("value")))
val result3 = df.withColumn("floor_value", callBuiltin("floor", col("value"), lit(1)))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1168¶
消息：不支持 Spark 元素 包含 给定实参 的实参值。
类别:警告。
描述¶
当 SMA 检测到不支持包含给定参数的 Spark 元素时，就会出现此问题。
场景¶
输入
以下是其参数不受支持的 Spark 元素的示例。
spark.read.format("text").load(path)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1168，以告知您不支持具有给定参数的 Spark 元素。
/*EWI: SPRKSCL1168 => org.apache.spark.sql.DataFrameReader.format(scala.String) with argument(s) value(s) (spark.format) is not supported*/
spark.read.format("text").load(path)
推荐修复方法
对于此场景，没有具体的修复方法。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1139¶
消息：org.apache.spark.sql.functions.sqrt 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.sqrt (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#sqrt(colName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.sqrt 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(4.0, 16.0, 25.0, 36.0).toDF("value")
val result1 = df.withColumn("sqrt_value", sqrt("value"))
val result2 = df.withColumn("sqrt_value", sqrt(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1139，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(4.0, 16.0, 25.0, 36.0).toDF("value")
/*EWI: SPRKSCL1139 => org.apache.spark.sql.functions.sqrt has a workaround, see documentation for more info*/
val result1 = df.withColumn("sqrt_value", sqrt("value"))
/*EWI: SPRKSCL1139 => org.apache.spark.sql.functions.sqrt has a workaround, see documentation for more info*/
val result2 = df.withColumn("sqrt_value", sqrt(col("value")))
推荐修复方法
Snowpark 拥有等效的 sqrt 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(4.0, 16.0, 25.0, 36.0).toDF("value")
val result1 = df.withColumn("sqrt_value", sqrt(col("value")))
val result2 = df.withColumn("sqrt_value", sqrt(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1119¶
消息：org.apache.spark.sql.Column.endsWith 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.Column.endsWith (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/Column.html#endsWith(literal:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.Column.endsWith 函数的示例，首先使用字面量字符串实参，然后使用列对象实参。
val df1 = Seq(
("Alice", "alice@example.com"),
("Bob", "bob@example.org"),
("David", "david@example.com")
).toDF("name", "email")
val result1 = df1.filter(col("email").endsWith(".com"))
val df2 = Seq(
("Alice", "alice@example.com", ".com"),
("Bob", "bob@example.org", ".org"),
("David", "david@example.org", ".com")
).toDF("name", "email", "suffix")
val result2 = df2.filter(col("email").endsWith(col("suffix")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1119，以提示 Snowpark 并非完全支持此函数，但它有替代方案。
val df1 = Seq(
("Alice", "alice@example.com"),
("Bob", "bob@example.org"),
("David", "david@example.com")
).toDF("name", "email")
/*EWI: SPRKSCL1119 => org.apache.spark.sql.Column.endsWith has a workaround, see documentation for more info*/
val result1 = df1.filter(col("email").endsWith(".com"))
val df2 = Seq(
("Alice", "alice@example.com", ".com"),
("Bob", "bob@example.org", ".org"),
("David", "david@example.org", ".com")
).toDF("name", "email", "suffix")
/*EWI: SPRKSCL1119 => org.apache.spark.sql.Column.endsWith has a workaround, see documentation for more info*/
val result2 = df2.filter(col("email").endsWith(col("suffix")))
推荐修复方法
替代方案是，您可以使用 com.snowflake.snowpark.functions.endswith 函数，其中第一个实参是要检查其值的列，第二个实参是用于检查列值的后缀。请注意，如果 Spark 的 endswith 函数的实参是字面量字符串，则应使用 com.snowflake.snowpark.functions.lit 函数将其转换为列对象。
val df1 = Seq(
("Alice", "alice@example.com"),
("Bob", "bob@example.org"),
("David", "david@example.com")
).toDF("name", "email")
val result1 = df1.filter(endswith(col("email"), lit(".com")))
val df2 = Seq(
("Alice", "alice@example.com", ".com"),
("Bob", "bob@example.org", ".org"),
("David", "david@example.org", ".com")
).toDF("name", "email", "suffix")
val result2 = df2.filter(endswith(col("email"), col("suffix")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1148¶
消息：org.apache.spark.sql.functions.toDegrees 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.toDegrees (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#toDegrees(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.toDegrees 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(Math.PI, Math.PI / 2, Math.PI / 4).toDF("angle_in_radians")
val result1 = df.withColumn("angle_in_degrees", toDegrees("angle_in_radians"))
val result2 = df.withColumn("angle_in_degrees", toDegrees(col("angle_in_radians")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1148，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(Math.PI, Math.PI / 2, Math.PI / 4).toDF("angle_in_radians")
/*EWI: SPRKSCL1148 => org.apache.spark.sql.functions.toDegrees has a workaround, see documentation for more info*/
val result1 = df.withColumn("angle_in_degrees", toDegrees("angle_in_radians"))
/*EWI: SPRKSCL1148 => org.apache.spark.sql.functions.toDegrees has a workaround, see documentation for more info*/
val result2 = df.withColumn("angle_in_degrees", toDegrees(col("angle_in_radians")))
推荐修复方法
替代方案是，您可以使用 degrees 函数。对于接收字符串实参的 Spark 重载，还必须使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(Math.PI, Math.PI / 2, Math.PI / 4).toDF("angle_in_radians")
val result1 = df.withColumn("angle_in_degrees", degrees(col("angle_in_radians")))
val result2 = df.withColumn("angle_in_degrees", degrees(col("angle_in_radians")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1158¶
消息：org.apache.spark.sql.functions.skewness 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.skewness (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#skewness(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.skewness 函数的示例。在此示例中，skewness 函数用于计算所选列的偏度。
val df = Seq("1", "2", "3").toDF("elements")
val result1 = skewness(col("elements"))
val result2 = skewness("elements")
输出
SMA 在输出代码中添加了 EWI SPRKSCL1158，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq("1", "2", "3").toDF("elements")
/*EWI: SPRKSCL1158 => org.apache.spark.sql.functions.skewness has a workaround, see documentation for more info*/
val result1 = skewness(col("elements"))
/*EWI: SPRKSCL1158 => org.apache.spark.sql.functions.skewness has a workaround, see documentation for more info*/
val result2 = skewness("elements")
推荐修复方法
Snowpark 拥有等效的 skew 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq("1", "2", "3").toDF("elements")
val result1 = skew(col("elements"))
val result2 = skew(col("elements"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1109¶
备注
此问题代码已 弃用
消息：未对 org.apache.spark.sql.DataFrameReader.option 定义该参数
类别:警告
描述¶
当 SMA 检测到 org.apache.spark.sql.DataFrameReader.option (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/DataFrameReader.html#option(key:String,value:Double):org.apache.spark.sql.DataFrameReader) 的给定参数未定义时，就会出现此问题。
场景¶
输入
以下是 org.apache.spark.sql.DataFrameReader.option 函数的未定义参数示例。
spark.read.option("header", True).json(path)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1109，以告知您尚未定义向 org.apache.spark.sql.DataFrameReader.option 函数提供参数。
/*EWI: SPRKSCL1109 => The parameter header=True is not supported for org.apache.spark.sql.DataFrameReader.option*/
spark.read.option("header", True).json(path)
推荐修复方法
请在 此处 查看 Snowpark 文档，了解读取器格式选项，以确定已定义的选项。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1114¶
消息：org.apache.spark.sql.functions.repeat 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.repeat (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#repeat(str:org.apache.spark.sql.Column,n:Int):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.repeat 函数的示例。
val df = Seq("Hello", "World").toDF("word")
val result = df.withColumn("repeated_word", repeat(col("word"), 3))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1114，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq("Hello", "World").toDF("word")
/*EWI: SPRKSCL1114 => org.apache.spark.sql.functions.repeat has a workaround, see documentation for more info*/
val result = df.withColumn("repeated_word", repeat(col("word"), 3))
推荐修复方法
替代方案是，您可以使用 com.snowflake.snowpark.functions.lit 函数将第二个参数转换为列对象。
val df = Seq("Hello", "World").toDF("word")
val result = df.withColumn("repeated_word", repeat(col("word"), lit(3)))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1145¶
消息：org.apache.spark.sql.functions.sumDistinct 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.sumDistinct (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#sumDistinct(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.sumDistinct 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(
("Alice", 10),
("Bob", 15),
("Alice", 10),
("Alice", 20),
("Bob", 15)
).toDF("name", "value")
val result1 = df.groupBy("name").agg(sumDistinct("value"))
val result2 = df.groupBy("name").agg(sumDistinct(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1145，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(
("Alice", 10),
("Bob", 15),
("Alice", 10),
("Alice", 20),
("Bob", 15)
).toDF("name", "value")
/*EWI: SPRKSCL1145 => org.apache.spark.sql.functions.sumDistinct has a workaround, see documentation for more info*/
val result1 = df.groupBy("name").agg(sumDistinct("value"))
/*EWI: SPRKSCL1145 => org.apache.spark.sql.functions.sumDistinct has a workaround, see documentation for more info*/
val result2 = df.groupBy("name").agg(sumDistinct(col("value")))
推荐修复方法
替代方案是，您可以使用 sum_distinct 函数。对于接收字符串实参的 Spark 重载，还必须使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
("Alice", 10),
("Bob", 15),
("Alice", 10),
("Alice", 20),
("Bob", 15)
).toDF("name", "value")
val result1 = df.groupBy("name").agg(sum_distinct(col("value")))
val result2 = df.groupBy("name").agg(sum_distinct(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1171¶
消息：Snowpark 不支持具有两个以上参数或包含正则表达式模式的拆分函数。有关更多信息，请参阅文档。
类别:警告。
描述¶
当 SMA 检测到 org.apache.spark.sql.functions.split (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#split(str:org.apache.spark.sql.Column,pattern:String,limit:Int):org.apache.spark.sql.Column) 有两个以上的参数或包含正则表达式模式时，就会出现此问题。
场景¶
split 函数用于根据给定模式的匹配项，对给定列进行分割。该 Spark 函数有三个重载。
场景 1¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.split 函数的示例。在此示例中，split 函数有两个参数，第二个实参是字符串，而不是正则表达式模式。
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
val result = df.select(split(col("words"), "Snow"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1171，以告知您 Snowpark 不完全支持此函数。
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
/* EWI: SPRKSCL1171 => Snowpark does not support split functions with more than two parameters or containing regex pattern. See documentation for more info. */
val result = df.select(split(col("words"), "Snow"))
推荐修复方法
Snowpark 拥有等效的 split 函数，该函数接收列对象作为第二个实参。因此，如果 Spark 重载接收字符串作为第二个参数（但不是正则表达式模式），作为替代方案，可以使用 com.snowflake.snowpark.functions.lit 函数将该字符串转换为列对象。
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
val result = df.select(split(col("words"), lit("Snow")))
场景 2¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.split 函数的示例。在此示例中，split 函数有两个参数，第二个实参是正则表达式模式。
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
val result = df.select(split(col("words"), "^([\\d]+-[\\d]+-[\\d])"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1171，以告知您，由于 Snowflake 不支持正则表达式模式，因此 Snowpark 不完全支持此函数。
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
/* EWI: SPRKSCL1171 => Snowpark does not support split functions with more than two parameters or containing regex pattern. See documentation for more info. */
val result = df.select(split(col("words"), "^([\\d]+-[\\d]+-[\\d])"))
推荐修复方法
由于 Snowflake 不支持正则表达式模式，因此，请尝试将该模式替换为非正则表达式模式字符串。
场景 3¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.split 函数的示例。在此示例中，split 函数有两个以上的参数。
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
val result = df.select(split(df("words"), "Snow", 3))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1171，以告知您，由于 Snowflake 没有包含两个以上参数的拆分函数，因此 Snowpark 不完全支持此函数。
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
/* EWI: SPRKSCL1171 => Snowpark does not support split functions with more than two parameters or containing regex pattern. See documentation for more info. */
val result3 = df.select(split(df("words"), "Snow", 3))
推荐修复方法
由于 Snowflake 不支持具有两个以上参数的拆分函数，因此，请尝试使用 Snowflake 支持的拆分函数。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1120¶
消息：org.apache.spark.sql.functions.asin 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.asin (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#asin(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.asin 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(0.5, 0.6, -0.5).toDF("value")
val result1 = df.select(col("value"), asin("value").as("asin_value"))
val result2 = df.select(col("value"), asin(col("value")).as("asin_value"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1120，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(0.5, 0.6, -0.5).toDF("value")
/*EWI: SPRKSCL1120 => org.apache.spark.sql.functions.asin has a workaround, see documentation for more info*/
val result1 = df.select(col("value"), asin("value").as("asin_value"))
/*EWI: SPRKSCL1120 => org.apache.spark.sql.functions.asin has a workaround, see documentation for more info*/
val result2 = df.select(col("value"), asin(col("value")).as("asin_value"))
推荐修复方法
Snowpark 拥有等效的 asin 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(0.5, 0.6, -0.5).toDF("value")
val result1 = df.select(col("value"), asin(col("value")).as("asin_value"))
val result2 = df.select(col("value"), asin(col("value")).as("asin_value"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1130¶
消息：org.apache.spark.sql.functions.greatest 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.greatest (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#greatest(columnName:String,columnNames:String*):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.greatest 函数的示例，首先使用多个列名作为实参，然后使用多个列对象。
val df = Seq(
("apple", 10, 20, 15),
("banana", 5, 25, 18),
("mango", 12, 8, 30)
).toDF("fruit", "value1", "value2", "value3")
val result1 = df.withColumn("greatest", greatest("value1", "value2", "value3"))
val result2 = df.withColumn("greatest", greatest(col("value1"), col("value2"), col("value3")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1130，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(
("apple", 10, 20, 15),
("banana", 5, 25, 18),
("mango", 12, 8, 30)
).toDF("fruit", "value1", "value2", "value3")
/*EWI: SPRKSCL1130 => org.apache.spark.sql.functions.greatest has a workaround, see documentation for more info*/
val result1 = df.withColumn("greatest", greatest("value1", "value2", "value3"))
/*EWI: SPRKSCL1130 => org.apache.spark.sql.functions.greatest has a workaround, see documentation for more info*/
val result2 = df.withColumn("greatest", greatest(col("value1"), col("value2"), col("value3")))
推荐修复方法
Snowpark 拥有等效的 greatest 函数，该函数接收多个列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收多个字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
("apple", 10, 20, 15),
("banana", 5, 25, 18),
("mango", 12, 8, 30)
).toDF("fruit", "value1", "value2", "value3")
val result1 = df.withColumn("greatest", greatest(col("value1"), col("value2"), col("value3")))
val result2 = df.withColumn("greatest", greatest(col("value1"), col("value2"), col("value3")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
描述：>- 未将 Snowpark 和 Snowpark Extensions 添加到项目配置文件中。
SPRKSCL1161¶
消息：无法添加依赖项。
类别:转换错误。
描述¶
当 SMA 在项目配置文件中检测到 SMA 不支持的 Spark 版本时，就会出现此问题，因此 SMA 无法将 Snowpark 和 Snowpark Extensions 依赖项添加到相应的项目配置文件中。如果未添加 Snowpark 依赖项，则迁移后的代码将无法编译。
场景¶
有三种可能的情况：sbt、gradle 和 pom.xml。SMA 尝试通过删除 Spark 依赖项以及添加 Snowpark 和 Snowpark Extensions 依赖项来处理项目配置文件。
场景 1¶
输入
以下是 sbt 项目配置文件的 dependencies 部分的示例。
...
libraryDependencies += "org.apache.spark" % "spark-core_2.13" % "3.5.3"
libraryDependencies += "org.apache.spark" % "spark-sql_2.13" % "3.5.3"
...
输出
由于不支持 Spark 版本，SMA 将 EWI SPRKSCL1161 添加到问题清单中，并且输出保持不变。
...
libraryDependencies += "org.apache.spark" % "spark-core_2.13" % "3.5.3"
libraryDependencies += "org.apache.spark" % "spark-sql_2.13" % "3.5.3"
...
推荐修复方法
手动删除 Spark 依赖项，将 Snowpark 和 Snowpark Extensions 依赖项添加到 sbt 项目配置文件中。
...
libraryDependencies += "com.snowflake" % "snowpark" % "1.14.0"
libraryDependencies += "net.mobilize.snowpark-extensions" % "snowparkextensions" % "0.0.18"
...
确保使用最符合项目要求的 Snowpark 版本。
场景 2¶
输入
以下是 gradle 项目配置文件的 dependencies 部分的示例。
dependencies {
implementation group: 'org.apache.spark', name: 'spark-core_2.13', version: '3.5.3'
implementation group: 'org.apache.spark', name: 'spark-sql_2.13', version: '3.5.3'
...
}
输出
由于不支持 Spark 版本，SMA 将 EWI SPRKSCL1161 添加到问题清单中，并且输出保持不变。
dependencies {
implementation group: 'org.apache.spark', name: 'spark-core_2.13', version: '3.5.3'
implementation group: 'org.apache.spark', name: 'spark-sql_2.13', version: '3.5.3'
...
}
推荐修复方法
手动删除 Spark 依赖项，将 Snowpark 和 Snowpark Extensions 依赖项添加到 gradle 项目配置文件中。
dependencies {
implementation 'com.snowflake:snowpark:1.14.2'
implementation 'net.mobilize.snowpark-extensions:snowparkextensions:0.0.18'
...
}
确保依赖项版本符合项目需求。
场景 3¶
输入
以下是 pom.xml 项目配置文件的 dependencies 部分的示例。
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.13</artifactId>
<version>3.5.3</version>
</dependency>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-sql_2.13</artifactId>
<version>3.5.3</version>
<scope>compile</scope>
</dependency>
...
</dependencies>
输出
由于不支持 Spark 版本，SMA 将 EWI SPRKSCL1161 添加到问题清单中，并且输出保持不变。
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.13</artifactId>
<version>3.5.3</version>
</dependency>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-sql_2.13</artifactId>
<version>3.5.3</version>
<scope>compile</scope>
</dependency>
...
</dependencies>
推荐修复方法
手动删除 Spark 依赖项，将 Snowpark 和 Snowpark Extensions 依赖项添加到 gradle 项目配置文件中。
<dependencies>
<dependency>
<groupId>com.snowflake</groupId>
<artifactId>snowpark</artifactId>
<version>1.14.2</version>
</dependency>
<dependency>
<groupId>net.mobilize.snowpark-extensions</groupId>
<artifactId>snowparkextensions</artifactId>
<version>0.0.18</version>
</dependency>
...
</dependencies>
确保依赖项版本符合项目需求。
其他建议¶
确保输入中包含项目配置文件：
build.sbt
build.gradle
pom.xml
SMA 支持的 Spark 版本为 2.12:3.1.2
您可以在 此处 (https://github.com/snowflakedb/snowpark-java-scala/releases/latest) 查看最新的 Snowpark 版本。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1155¶
警告
自 Spark Conversion Core 版本 4.3.2 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.countDistinct 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.countDistinct (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#countDistinct(columnName:String,columnNames:String*):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.countDistinct 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(
("Alice", 1),
("Bob", 2),
("Alice", 3),
("Bob", 4),
("Alice", 1),
("Charlie", 5)
).toDF("name", "value")
val result1 = df.select(countDistinct("name", "value"))
val result2 = df.select(countDistinct(col("name"), col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1155，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(
("Alice", 1),
("Bob", 2),
("Alice", 3),
("Bob", 4),
("Alice", 1),
("Charlie", 5)
).toDF("name", "value")
/*EWI: SPRKSCL1155 => org.apache.spark.sql.functions.countDistinct has a workaround, see documentation for more info*/
val result1 = df.select(countDistinct("name", "value"))
/*EWI: SPRKSCL1155 => org.apache.spark.sql.functions.countDistinct has a workaround, see documentation for more info*/
val result2 = df.select(countDistinct(col("name"), col("value")))
推荐修复方法
替代方案是，您可以使用 count_distinct 函数。对于接收字符串实参的 Spark 重载，还必须使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
("Alice", 1),
("Bob", 2),
("Alice", 3),
("Bob", 4),
("Alice", 1),
("Charlie", 5)
).toDF("name", "value")
val result1 = df.select(count_distinct(col("name"), col("value")))
val result2 = df.select(count_distinct(col("name"), col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1104¶
此问题代码已 弃用
消息：不支持 Spark Session 生成器选项。
类别:转换错误。
描述¶
如果 SMA 检测到使用了 org.apache.spark.sql.SparkSession.Builder.config (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/SparkSession$$Builder.html#config(conf:org.apache.spark.SparkConf):org.apache.spark.sql.SparkSession.Builder) 函数（该函数用于设置 Spark Session 的选项，但 Snowpark 不支持此函数），就会出现此问题。
场景¶
输入
以下是用于在 Spark Session 中设置选项的 org.apache.spark.sql.SparkSession.Builder.config 函数的示例。
val spark = SparkSession.builder()
.master("local")
.appName("testApp")
.config("spark.sql.broadcastTimeout", "3600")
.getOrCreate()
输出
SMA 在输出代码中添加了 EWI SPRKSCL1104，以告知您 Snowpark 不支持配置方法。然后，无法通过配置函数在 Spark Session 中设置选项，这可能会影响 Spark Session 语句的迁移。
val spark = Session.builder.configFile("connection.properties")
/*EWI: SPRKSCL1104 => SparkBuilder Option is not supported .config("spark.sql.broadcastTimeout", "3600")*/
.create()
推荐修复方法
要创建会话，需要添加适当的 Snowflake Snowpark 配置。
在此示例中，使用了配置变量。
val configs = Map (
"URL" -> "https://<myAccount>.snowflakecomputing.cn:<port>",
"USER" -> <myUserName>,
"PASSWORD" -> <myPassword>,
"ROLE" -> <myRole>,
"WAREHOUSE" -> <myWarehouse>,
"DB" -> <myDatabase>,
"SCHEMA" -> <mySchema>
)
val session = Session.builder.configs(configs).create
此外，还建议使用包含连接信息的 configFile (profile.properties)：
## profile.properties file (a text file)
URL = https://<account_identifier>.snowflakecomputing.cn
USER = <username>
PRIVATEKEY = <unencrypted_private_key_from_the_private_key_file>
ROLE = <role_name>
WAREHOUSE = <warehouse_name>
DB = <database_name>
SCHEMA = <schema_name>
使用 Session.builder.configFile 可以创建会话：
val session = Session.builder.configFile("/path/to/properties/file").create
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1124¶
消息：org.apache.spark.sql.functions.cosh 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到有人使用了 org.apache.spark.sql.functions.cosh (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#cosh(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.cosh 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(0.0, 1.0, 2.0, -1.0).toDF("value")
val result1 = df.withColumn("cosh_value", cosh("value"))
val result2 = df.withColumn("cosh_value", cosh(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1124，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(0.0, 1.0, 2.0, -1.0).toDF("value")
/*EWI: SPRKSCL1124 => org.apache.spark.sql.functions.cosh has a workaround, see documentation for more info*/
val result1 = df.withColumn("cosh_value", cosh("value"))
/*EWI: SPRKSCL1124 => org.apache.spark.sql.functions.cosh has a workaround, see documentation for more info*/
val result2 = df.withColumn("cosh_value", cosh(col("value")))
推荐修复方法
Snowpark 拥有等效的 cosh 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(0.0, 1.0, 2.0, -1.0).toDF("value")
val result1 = df.withColumn("cosh_value", cosh(col("value")))
val result2 = df.withColumn("cosh_value", cosh(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1175¶
消息：Snowpark 不支持双参数 udf 函数。它应该转换为单参数 udf 函数。请查看文档，了解如何手动修改代码以使其在 Snowpark 中运行。
类别:转换错误。
描述¶
当 SMA 检测到源代码中使用了双参数 org.apache.spark.sql.functions.udf (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#udf(f:org.apache.spark.sql.api.java.UDF0%5B_%5D,returnType:org.apache.spark.sql.types.DataType):org.apache.spark.sql.expressions.UserDefinedFunction) 函数时，就会出现此问题，因为 Snowpark 没有等效的双参数 udf 函数，因此输出代码可能无法编译。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.udf 函数的示例。在此示例中，udf 函数有两个参数。
val myFuncUdf = udf(new UDF1[String, Integer] {
override def call(s: String): Integer = s.length()
}, IntegerType)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1175，以告知您，不支持 udf 函数，因为它有两个参数。
/*EWI: SPRKSCL1175 => The two-parameter udf function is not supported in Snowpark. It should be converted into a single-parameter udf function. Please check the documentation to learn how to manually modify the code to make it work in Snowpark.*/
val myFuncUdf = udf(new UDF1[String, Integer] {
override def call(s: String): Integer = s.length()
}, IntegerType)
推荐修复方法
Snowpark 仅支持单参数 udf 函数（不含返回类型参数），因此应该将双参数 udf 函数转换为单参数 udf 函数，以使其在 Snowpark 中运行。
例如，对于上面提到的示例代码，必须手动将其转换为以下代码：
val myFuncUdf = udf((s: String) => s.length())
请注意，在 Snowpark 中创建 udf 时有一些注意事项，可能需要您对代码进行一些额外的手动更改。请在 此处 查看与在 Snowpark 中创建单参数 udf 函数相关的其他建议，以了解更多详细信息。
其他建议¶
要详细了解如何在 Snowpark 中创建用户定义的函数，请参阅以下文档：在 Scala 中为 DataFrames 创建用户定义的函数 (UDFs)
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1001¶
消息：此代码段存在解析错误。在以下位置发现解析错误：行 行号、列 列号。尝试解析 语句 时。此文件未经过转换，因此预计仍会引用 Spark API。
类别:解析错误。
描述¶
当 SMA 检测到文件代码中存在某些无法正确读取或理解的语句时，就会出现此问题，称为 解析错误。此外，当文件出现一个或多个解析错误时，就会出现此问题。
场景¶
输入
以下是无效 Scala 代码的示例。
/#/(%$"$%
Class myClass {
def function1() = { 1 }
}
输出
SMA 在输出代码中添加了 EWI SPRKSCL1001，以告知您该文件的代码存在解析错误。因此，SMA 无法处理出现此错误的文件。
// **********************************************************************************************************************
// EWI: SPRKSCL1001 => This code section has parsing errors
// The parsing error was found at: line 0, column 0. When trying to parse ''.
// This file was not converted, so it is expected to still have references to the Spark API
// **********************************************************************************************************************
/#/(%$"$%
Class myClass {
def function1() = { 1 }
}
推荐修复方法
由于该消息指出了错误语句，因此您可以尝试识别无效语法并将其删除，或注释掉该语句以避免解析错误。
Class myClass {
def function1() = { 1 }
}
// /#/(%$"$%
Class myClass {
def function1() = { 1 }
}
其他建议¶
检查该文件的代码是否为有效的 Scala 代码。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1141¶
消息：org.apache.spark.sql.functions.stddev_pop 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.stddev_pop (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#stddev_pop(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
以下是 org.apache.spark.sql.functions.stddev_pop 函数示例，首先使用列名作为实参，然后使用列对象。
输入
val df = Seq(
("Alice", 23),
("Bob", 30),
("Carol", 27),
("David", 25),
).toDF("name", "age")
val result1 = df.select(stddev_pop("age"))
val result2 = df.select(stddev_pop(col("age")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1141，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(
("Alice", 23),
("Bob", 30),
("Carol", 27),
("David", 25),
).toDF("name", "age")
/*EWI: SPRKSCL1141 => org.apache.spark.sql.functions.stddev_pop has a workaround, see documentation for more info*/
val result1 = df.select(stddev_pop("age"))
/*EWI: SPRKSCL1141 => org.apache.spark.sql.functions.stddev_pop has a workaround, see documentation for more info*/
val result2 = df.select(stddev_pop(col("age")))
推荐修复方法
Snowpark 拥有等效的 stddev_pop 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
("Alice", 23),
("Bob", 30),
("Carol", 27),
("David", 25),
).toDF("name", "age")
val result1 = df.select(stddev_pop(col("age")))
val result2 = df.select(stddev_pop(col("age")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1110¶
备注
此问题代码已 弃用
消息：Reader 方法不是受支持的 方法名称。
类别:警告
描述¶
当 SMA 在 DataFrameReader 方法链接中检测到 Snowflake 不支持的方法时，就会出现此问题。然后，这可能会影响 reader 语句的迁移。
场景¶
输入
以下是 DataFrameReader 方法链接的示例，其中 Snowflake 不支持加载方法。
spark.read.
format("net.snowflake.spark.snowflake").
option("query", s"select * from $tablename")
load()
输出
SMA 在输出代码中添加了 EWI SPRKSCL1110，以告知您 Snowpark 不支持加载方法。然后，这可能会影响 reader 语句的迁移。
session.sql(s"select * from $tablename")
/*EWI: SPRKSCL1110 => Reader method not supported .load()*/
推荐修复方法
请在 此处 查看读取器的 Snowpark 文档，以了解 Snowflake 支持的方法。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1100¶
自 Spark Conversion Core 2.3.22 起，此问题代码已 弃用
消息：不支持重新分区。
类别:解析错误。
描述¶
当 SMA 检测到使用了 Snowpark 不支持的 org.apache.spark.sql.DataFrame.repartition (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/Dataset.html#repartition(partitionExprs:org.apache.spark.sql.Column*):org.apache.spark.sql.Dataset%5BT%5D) 函数时，就会出现此问题。Snowflake 管理集群上的存储和工作负载，因此重新分区操作不适用。
场景¶
输入
以下是 org.apache.spark.sql.DataFrame.repartition 函数的示例，该函数用于返回通过给定分区表达式进行分区的新 DataFrame。
var nameData = Seq("James", "Sarah", "Dylan", "Leila, "Laura", "Peter")
var jobData = Seq("Police", "Doctor", "Actor", "Teacher, "Dentist", "Fireman")
var ageData = Seq(40, 38, 34, 27, 29, 55)
val dfName = nameData.toDF("name")
val dfJob = jobData.toDF("job")
val dfAge = ageData.toDF("age")
val dfRepartitionByExpresion = dfName.repartition($"name")
val dfRepartitionByNumber = dfJob.repartition(3)
val dfRepartitionByBoth = dfAge.repartition(3, $"age")
val joinedDf = dfRepartitionByExpresion.join(dfRepartitionByNumber)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1100，以告知您 Snowpark 不支持此函数。
var nameData = Seq("James", "Sarah", "Dylan", "Leila, "Laura", "Peter")
var jobData = Seq("Police", "Doctor", "Actor", "Teacher, "Dentist", "Fireman")
var ageData = Seq(40, 38, 34, 27, 29, 55)
val dfName = nameData.toDF("name")
val dfJob = jobData.toDF("job")
val dfAge = ageData.toDF("age")
/*EWI: SPRKSCL1100 => Repartition is not supported*/
val dfRepartitionByExpresion = dfName.repartition($"name")
/*EWI: SPRKSCL1100 => Repartition is not supported*/
val dfRepartitionByNumber = dfJob.repartition(3)
/*EWI: SPRKSCL1100 => Repartition is not supported*/
val dfRepartitionByBoth = dfAge.repartition(3, $"age")
val joinedDf = dfRepartitionByExpresion.join(dfRepartitionByNumber)
推荐修复方法
由于 Snowflake 管理集群上的存储和工作负载，因此重新分区操作不适用。这意味着根本不需要在联接之前使用分区。
var nameData = Seq("James", "Sarah", "Dylan", "Leila, "Laura", "Peter")
var jobData = Seq("Police", "Doctor", "Actor", "Teacher, "Dentist", "Fireman")
var ageData = Seq(40, 38, 34, 27, 29, 55)
val dfName = nameData.toDF("name")
val dfJob = jobData.toDF("job")
val dfAge = ageData.toDF("age")
val dfRepartitionByExpresion = dfName
val dfRepartitionByNumber = dfJob
val dfRepartitionByBoth = dfAge
val joinedDf = dfRepartitionByExpresion.join(dfRepartitionByNumber)
其他建议¶
Snowflake 的架构指南 提供了有关 Snowflake 存储管理的见解。
Snowpark Dataframe 参考 可能有助于如何在无需重新分区的情况下调整特定场景。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1151¶
消息：org.apache.spark.sql.functions.var_samp 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.var_samp (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#var_samp(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.var_samp 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(
("A", 10),
("A", 20),
("A", 30),
("B", 40),
("B", 50),
("B", 60)
).toDF("category", "value")
val result1 = df.groupBy("category").agg(var_samp("value"))
val result2 = df.groupBy("category").agg(var_samp(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1151，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(
("A", 10),
("A", 20),
("A", 30),
("B", 40),
("B", 50),
("B", 60)
).toDF("category", "value")
/*EWI: SPRKSCL1151 => org.apache.spark.sql.functions.var_samp has a workaround, see documentation for more info*/
val result1 = df.groupBy("category").agg(var_samp("value"))
/*EWI: SPRKSCL1151 => org.apache.spark.sql.functions.var_samp has a workaround, see documentation for more info*/
val result2 = df.groupBy("category").agg(var_samp(col("value")))
推荐修复方法
Snowpark 拥有等效的 var_samp 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
("A", 10),
("A", 20),
("A", 30),
("B", 40),
("B", 50),
("B", 60)
).toDF("category", "value")
val result1 = df.groupBy("category").agg(var_samp(col("value")))
val result2 = df.groupBy("category").agg(var_samp(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
描述：>- DataFrameReader 方法链接中读取器的格式不是 Snowpark 定义的格式之一。
SPRKSCL1165¶
消息：无法定义 DataFrameReader 方法链接中的读取器格式
类别:警告
描述¶
当 SMA 检测到 DataFrameReader 方法链接中读取器的 format 不是 Snowpark 支持的以下格式之一时，就会出现此问题：avro、csv、json、orc、parquet 和 xml。因此，SMA 无法确定是否定义了设置选项。
场景¶
输入
以下是 DataFrameReader 方法链接的示例，其中 SMA 可以确定读取器的格式。
spark.read.format("net.snowflake.spark.snowflake")
.option("query", s"select * from $tableName")
.load()
输出
SMA 在输出代码中添加了 EWI SPRKSCL1165，以告知您，在给定的 DataFrameReader 方法链接中无法确定读取器的 format。
/*EWI: SPRKSCL1165 => Reader format on DataFrameReader method chaining can't be defined*/
spark.read.option("query", s"select * from $tableName")
.load()
推荐修复方法
请在 此处 查看 Snowpark 文档，以获取有关读取器格式的更多信息。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1134¶
消息：org.apache.spark.sql.functions.log 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.log (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#log(base:Double,columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.log 函数的示例。
val df = Seq(10.0, 20.0, 30.0, 40.0).toDF("value")
val result1 = df.withColumn("log_value", log(10, "value"))
val result2 = df.withColumn("log_value", log(10, col("value")))
val result3 = df.withColumn("log_value", log("value"))
val result4 = df.withColumn("log_value", log(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1134，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(10.0, 20.0, 30.0, 40.0).toDF("value")
/*EWI: SPRKSCL1134 => org.apache.spark.sql.functions.log has a workaround, see documentation for more info*/
val result1 = df.withColumn("log_value", log(10, "value"))
/*EWI: SPRKSCL1134 => org.apache.spark.sql.functions.log has a workaround, see documentation for more info*/
val result2 = df.withColumn("log_value", log(10, col("value")))
/*EWI: SPRKSCL1134 => org.apache.spark.sql.functions.log has a workaround, see documentation for more info*/
val result3 = df.withColumn("log_value", log("value"))
/*EWI: SPRKSCL1134 => org.apache.spark.sql.functions.log has a workaround, see documentation for more info*/
val result4 = df.withColumn("log_value", log(col("value")))
推荐修复方法
以下是 log 函数所有重载的不同替代方案。
1. def log(base:Double, columnName:String):Column
您可以使用 com.snowflake.snowpark.functions.lit 函数将基数转换为列对象，并且使用 com.snowflake.snowpark.functions.col 函数将列名转换为列对象。
val result1 = df.withColumn("log_value", log(lit(10), col("value")))
2. def log(base:Double, a:Column):Column
您可以使用 com.snowflake.snowpark.functions.lit 函数将基数转换为列对象。
val result2 = df.withColumn("log_value", log(lit(10), col("value")))
3.def log(columnName:String):Column
您可以传递 lit(Math.E) 作为第一个实参，并且使用 com.snowflake.snowpark.functions.col 函数将列名转换为列对象，并将其作为第二个实参传递。
val result3 = df.withColumn("log_value", log(lit(Math.E), col("value")))
4. def log(e:Column):Column
您可以传递 lit(Math.E) 作为第一个实参，将列对象作为第二个实参传递。
val result4 = df.withColumn("log_value", log(lit(Math.E), col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1125¶
警告
自 Spark Conversion Core 2.9.0 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.count 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.count (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#count(columnName:String):org.apache.spark.sql.TypedColumn%5BAny,Long%5D) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.count 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(
("Alice", "Math"),
("Bob", "Science"),
("Alice", "Science"),
("Bob", null)
).toDF("name", "subject")
val result1 = df.groupBy("name").agg(count("subject").as("subject_count"))
val result2 = df.groupBy("name").agg(count(col("subject")).as("subject_count"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1125，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(
("Alice", "Math"),
("Bob", "Science"),
("Alice", "Science"),
("Bob", null)
).toDF("name", "subject")
/*EWI: SPRKSCL1125 => org.apache.spark.sql.functions.count has a workaround, see documentation for more info*/
val result1 = df.groupBy("name").agg(count("subject").as("subject_count"))
/*EWI: SPRKSCL1125 => org.apache.spark.sql.functions.count has a workaround, see documentation for more info*/
val result2 = df.groupBy("name").agg(count(col("subject")).as("subject_count"))
推荐修复方法
Snowpark 拥有等效的 count 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
("Alice", "Math"),
("Bob", "Science"),
("Alice", "Science"),
("Bob", null)
).toDF("name", "subject")
val result1 = df.groupBy("name").agg(count(col("subject")).as("subject_count"))
val result2 = df.groupBy("name").agg(count(col("subject")).as("subject_count"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1174¶
消息：Snowpark 支持单参数 udf 函数，但可能需要手动干预。请查看文档，了解如何手动修改代码以使其在 Snowpark 中运行。
类别:警告。
描述¶
当 SMA 检测到代码中使用了单参数 org.apache.spark.sql.functions.udf (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#udf(f:org.apache.spark.sql.api.java.UDF10%5B_,_,_,_,_,_,_,_,_,_,_%5D,returnType:org.apache.spark.sql.types.DataType):org.apache.spark.sql.expressions.UserDefinedFunction) 函数时，就会出现此问题。然后，可能需要手动干预。
Snowpark API 提供了等效的 com.snowflake.snowpark.functions.udf 函数，允许您在 Scala 中使用 lambda 或函数创建用户定义的函数，但是，在 Snowpark 中创建 udf 时有一些注意事项，可能需要您手动更改代码才能使其正常运行。
场景¶
Snowpark 的 udf 函数应能在各种情况下按预期运行，无需人工干预。但是，在某些情况下，您需要手动修改代码才能使其在 Snowpark 中运行。其中一些情况如下所示：
场景 1¶
输入
以下是在具有 App Trait 的对象中创建 UDFs 的示例。
Scala 的 App trait 通过提供在对象定义中自动运行代码的 main 方法来简化可执行程序的创建过程。扩展 App 会将字段的初始化延迟到执行 main 方法，如果 UDFs 依赖于初始化的字段，这可能会影响其定义。这意味着，如果对象扩展了 App，并且 udf 引用了对象字段，则上传到 Snowflake 的 udf 定义将不包含该字段的初始化值。这可能导致 udf 返回 null 值。
例如，在以下代码中，变量 myValue 将在 udf 定义中解析为 null：
object Main extends App {
...
val myValue = 10
val myUdf = udf((x: Int) => x + myValue) // myValue in the `udf` definition will resolve to null
...
}
输出
SMA 在输出代码中添加了 EWI SPRKSCL1174，以告知您，Snowpark 支持单参数 udf 函数，但需要手动干预。
object Main extends App {
...
val myValue = 10
/*EWI: SPRKSCL1174 => The single-parameter udf function is supported in Snowpark but it might require manual intervention. Please check the documentation to learn how to manually modify the code to make it work in Snowpark.*/
val myUdf = udf((x: Int) => x + myValue) // myValue in the `udf` definition will resolve to null
...
}
推荐修复方法
为了避免此问题，建议不要扩展 App，并为代码实施单独的 main 方法。这样可以确保在创建 udf 定义并将其上传到 Snowflake 之前初始化对象字段。
object Main {
...
def main(args: Array[String]): Unit = {
val myValue = 10
val myUdf = udf((x: Int) => x + myValue)
}
...
}
有关此主题的更多详细信息，请参阅 关于在具有 App Trait 的对象中创建 UDFs 的注意事项。
场景 2¶
输入
以下是在 Jupyter Notebook 中创建 UDFs 的示例。
def myFunc(s: String): String = {
...
}
val myFuncUdf = udf((x: String) => myFunc(x))
df1.select(myFuncUdf(col("name"))).show()
输出
SMA 在输出代码中添加了 EWI SPRKSCL1174，以告知您，Snowpark 支持单参数 udf 函数，但需要手动干预。
def myFunc(s: String): String = {
...
}
/*EWI: SPRKSCL1174 => The single-parameter udf function is supported in Snowpark but it might require manual intervention. Please check the documentation to learn how to manually modify the code to make it work in Snowpark.*/
val myFuncUdf = udf((x: String) => myFunc(x))
df1.select(myFuncUdf(col("name"))).show()
推荐修复方法
要在 Jupyter Notebook 中创建 udf，您应该在扩展 Serializable 的类中定义函数的实现。例如，您应该手动将其转换为如下情况：
object ConvertedUdfFuncs extends Serializable {
def myFunc(s: String): String = {
...
}
val myFuncAsLambda = ((x: String) => ConvertedUdfFuncs.myFunc(x))
}
val myFuncUdf = udf(ConvertedUdfFuncs.myFuncAsLambda)
df1.select(myFuncUdf(col("name"))).show()
有关如何在 Jupyter Notebook 中创建 UDFs 的更多详细信息，请参阅 在 Jupyter Notebook 中创建 UDFs。
其他建议¶
要详细了解如何在 Snowpark 中创建用户定义的函数，请参阅以下文档：在 Scala 中为 DataFrames 创建用户定义的函数 (UDFs)
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1000¶
消息：源项目 spark-core 版本为 版本号，Snowpark 支持的 spark-core 版本为 2.12:3.1.2，因此现有映射之间可能存在功能差异。
类别:警告
描述¶
当 SMA 检测到 SMA 不支持的 spark-core 版本时，就会出现此问题。因此，现有映射之间可能存在功能差异，输出可能有意外行为。
其他建议¶
SMA 支持的 spark-core 版本为 2.12:3.1.2。考虑更改源代码的版本。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1140¶
消息：org.apache.spark.sql.functions.stddev 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.stddev (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#stddev(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.stddev 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(
("Alice", 10),
("Bob", 15),
("Charlie", 20),
("David", 25),
).toDF("name", "score")
val result1 = df.select(stddev("score"))
val result2 = df.select(stddev(col("score")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1140，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(
("Alice", 10),
("Bob", 15),
("Charlie", 20),
("David", 25),
).toDF("name", "score")
/*EWI: SPRKSCL1140 => org.apache.spark.sql.functions.stddev has a workaround, see documentation for more info*/
val result1 = df.select(stddev("score"))
/*EWI: SPRKSCL1140 => org.apache.spark.sql.functions.stddev has a workaround, see documentation for more info*/
val result2 = df.select(stddev(col("score")))
推荐修复方法
Snowpark 拥有等效的 stddev 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
("Alice", 10),
("Bob", 15),
("Charlie", 20),
("David", 25),
).toDF("name", "score")
val result1 = df.select(stddev(col("score")))
val result2 = df.select(stddev(col("score")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1111¶
备注
此问题代码已 弃用
消息：不支持 CreateDecimalType。
类别:转换错误。
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.types.DataTypes.CreateDecimalType (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/types/DecimalType.html) 函数时，就会出现此问题。
场景¶
输入
以下是 org.apache.spark.sql.types.DataTypes.CreateDecimalType 函数的使用示例。
var result = DataTypes.createDecimalType(18, 8)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1111，以告知您 Snowpark 不支持 CreateDecimalType 函数。
/*EWI: SPRKSCL1111 => CreateDecimalType is not supported*/
var result = createDecimalType(18, 8)
推荐修复方法
目前还没有推荐的修复方法。
消息：不支持 Spark Session 生成器选项。
类别:转换错误。
描述¶
如果 SMA 检测到使用了 org.apache.spark.sql.SparkSession.Builder.config (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/SparkSession$$Builder.html#config(conf:org.apache.spark.SparkConf):org.apache.spark.sql.SparkSession.Builder) 函数（该函数用于设置 Spark Session 的选项，但 Snowpark 不支持此函数），就会出现此问题。
场景¶
输入
以下是用于在 Spark Session 中设置选项的 org.apache.spark.sql.SparkSession.Builder.config 函数的示例。
val spark = SparkSession.builder()
.master("local")
.appName("testApp")
.config("spark.sql.broadcastTimeout", "3600")
.getOrCreate()
输出
SMA 在输出代码中添加了 EWI SPRKSCL1104，以告知您 Snowpark 不支持配置方法。然后，无法通过配置函数在 Spark Session 中设置选项，这可能会影响 Spark Session 语句的迁移。
val spark = Session.builder.configFile("connection.properties")
/*EWI: SPRKSCL1104 => SparkBuilder Option is not supported .config("spark.sql.broadcastTimeout", "3600")*/
.create()
推荐修复方法
要创建会话，需要添加适当的 Snowflake Snowpark 配置。
在此示例中，使用了配置变量。
val configs = Map (
"URL" -> "https://<myAccount>.snowflakecomputing.cn:<port>",
"USER" -> <myUserName>,
"PASSWORD" -> <myPassword>,
"ROLE" -> <myRole>,
"WAREHOUSE" -> <myWarehouse>,
"DB" -> <myDatabase>,
"SCHEMA" -> <mySchema>
)
val session = Session.builder.configs(configs).create
此外，还建议使用包含连接信息的 configFile (profile.properties)：
## profile.properties file (a text file)
URL = https://<account_identifier>.snowflakecomputing.cn
USER = <username>
PRIVATEKEY = <unencrypted_private_key_from_the_private_key_file>
ROLE = <role_name>
WAREHOUSE = <warehouse_name>
DB = <database_name>
SCHEMA = <schema_name>
使用 Session.builder.configFile 可以创建会话：
val session = Session.builder.configFile("/path/to/properties/file").create
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1101¶
自 Spark Conversion Core 2.3.22 起，此问题代码已 弃用
消息：不支持广播
类别:警告
描述¶
当 SMA 检测到使用了 Snowpark 不支持的 org.apache.spark.sql.functions.broadcast (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#broadcast%5BT%5D(df:org.apache.spark.sql.Dataset%5BT%5D):org.apache.spark.sql.Dataset%5BT%5D) 函数时，就会出现此问题。不支持此函数，因为 Snowflake 不支持 广播变量 (https://spark.apache.org/docs/latest/api/java/org/apache/spark/broadcast/Broadcast.html)。
场景¶
输入
以下是 org.apache.spark.sql.functions.broadcast 函数的示例，该函数用于创建广播对象以在每个 Spark 集群上使用：
var studentData = Seq(
("James", "Orozco", "Science"),
("Andrea", "Larson", "Bussiness"),
)
var collegeData = Seq(
("Arts", 1),
("Bussiness", 2),
("Science", 3)
)
val dfStudent = studentData.toDF("FirstName", "LastName", "CollegeName")
val dfCollege = collegeData.toDF("CollegeName", "CollegeCode")
dfStudent.join(
broadcast(dfCollege),
Seq("CollegeName")
)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1101，以告知您 Snowpark 不支持此函数。
var studentData = Seq(
("James", "Orozco", "Science"),
("Andrea", "Larson", "Bussiness"),
)
var collegeData = Seq(
("Arts", 1),
("Bussiness", 2),
("Science", 3)
)
val dfStudent = studentData.toDF("FirstName", "LastName", "CollegeName")
val dfCollege = collegeData.toDF("CollegeName", "CollegeCode")
dfStudent.join(
/*EWI: SPRKSCL1101 => Broadcast is not supported*/
broadcast(dfCollege),
Seq("CollegeName")
)
推荐修复方法
由于 Snowflake 管理集群上的存储和工作负载，因此广播对象不适用。这意味着根本不可能要求使用广播，但每种情况都需要进一步分析。
推荐的方法是将 Spark 数据框广播替换为 Snowpark 常规数据框或使用数据框方法作为 Join。
对于拟议的输入，修复方法是调整联接以直接使用数据框 collegeDF，而不对数据框使用广播。
var studentData = Seq(
("James", "Orozco", "Science"),
("Andrea", "Larson", "Bussiness"),
)
var collegeData = Seq(
("Arts", 1),
("Bussiness", 2),
("Science", 3)
)
val dfStudent = studentData.toDF("FirstName", "LastName", "CollegeName")
val dfCollege = collegeData.toDF("CollegeName", "CollegeCode")
dfStudent.join(
dfCollege,
Seq("CollegeName")
).show()
其他建议¶
Snowflake 的架构指南 提供了有关 Snowflake 存储管理的见解。
Snowpark Dataframe 参考 可能有助于如何调整特定的广播场景。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1150¶
消息：org.apache.spark.sql.functions.var_pop 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.var_pop (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#var_pop(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.var_pop 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(
("A", 10.0),
("A", 20.0),
("A", 30.0),
("B", 40.0),
("B", 50.0),
("B", 60.0)
).toDF("group", "value")
val result1 = df.groupBy("group").agg(var_pop("value"))
val result2 = df.groupBy("group").agg(var_pop(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1150，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(
("A", 10.0),
("A", 20.0),
("A", 30.0),
("B", 40.0),
("B", 50.0),
("B", 60.0)
).toDF("group", "value")
/*EWI: SPRKSCL1150 => org.apache.spark.sql.functions.var_pop has a workaround, see documentation for more info*/
val result1 = df.groupBy("group").agg(var_pop("value"))
/*EWI: SPRKSCL1150 => org.apache.spark.sql.functions.var_pop has a workaround, see documentation for more info*/
val result2 = df.groupBy("group").agg(var_pop(col("value")))
推荐修复方法
Snowpark 拥有等效的 var_pop 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(
("A", 10.0),
("A", 20.0),
("A", 30.0),
("B", 40.0),
("B", 50.0),
("B", 60.0)
).toDF("group", "value")
val result1 = df.groupBy("group").agg(var_pop(col("value")))
val result2 = df.groupBy("group").agg(var_pop(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
描述：>- org.apache.spark.sql.DataFrameReader.option 函数的参数未定义。
SPRKSCL1164¶
备注
此问题代码已 弃用
消息：未对 org.apache.spark.sql.DataFrameReader.option 定义该参数
类别:警告
描述¶
当 SMA 检测到 org.apache.spark.sql.DataFrameReader.option (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/DataFrameReader.html#option(key:String,value:Double):org.apache.spark.sql.DataFrameReader) 的给定参数未定义时，就会出现此问题。
场景¶
输入
以下是 org.apache.spark.sql.DataFrameReader.option 函数的未定义参数示例。
spark.read.option("header", True).json(path)
输出
SMA 在输出代码中添加了 EWI SPRKSCL1164，以告知您尚未定义向 org.apache.spark.sql.DataFrameReader.option 函数提供参数。
/*EWI: SPRKSCL1164 => The parameter header=True is not supported for org.apache.spark.sql.DataFrameReader.option*/
spark.read.option("header", True).json(path)
推荐修复方法
请在 此处 查看 Snowpark 文档，了解读取器格式选项，以确定已定义的选项。
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1135¶
警告
自 Spark Conversion Core 4.3.2 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.mean 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.mean (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#mean(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.mean 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(1, 3, 10, 1, 3).toDF("value")
val result1 = df.select(mean("value"))
val result2 = df.select(mean(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1135，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(1, 3, 10, 1, 3).toDF("value")
/*EWI: SPRKSCL1135 => org.apache.spark.sql.functions.mean has a workaround, see documentation for more info*/
val result1 = df.select(mean("value"))
/*EWI: SPRKSCL1135 => org.apache.spark.sql.functions.mean has a workaround, see documentation for more info*/
val result2 = df.select(mean(col("value")))
推荐修复方法
Snowpark 拥有等效的 mean 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(1, 3, 10, 1, 3).toDF("value")
val result1 = df.select(mean(col("value")))
val result2 = df.select(mean(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1115¶
警告
自 Spark Conversion Core 版本 4.6.0 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.round 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.round (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#round(e:org.apache.spark.sql.Column,scale:Int):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.round 函数的示例。
val df = Seq(3.9876, 5.673, 8.1234).toDF("value")
val result1 = df.withColumn("rounded_value", round(col("value")))
val result2 = df.withColumn("rounded_value", round(col("value"), 2))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1115，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(3.9876, 5.673, 8.1234).toDF("value")
/*EWI: SPRKSCL1115 => org.apache.spark.sql.functions.round has a workaround, see documentation for more info*/
val result1 = df.withColumn("rounded_value", round(col("value")))
/*EWI: SPRKSCL1115 => org.apache.spark.sql.functions.round has a workaround, see documentation for more info*/
val result2 = df.withColumn("rounded_value", round(col("value"), 2))
推荐修复方法
Snowpark 拥有等效的 round 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收列对象和标度的重载，作为替代方案，可以使用 com.snowflake.snowpark.functions.lit 函数将标度转换为列对象。
val df = Seq(3.9876, 5.673, 8.1234).toDF("value")
val result1 = df.withColumn("rounded_value", round(col("value")))
val result2 = df.withColumn("rounded_value", round(col("value"), lit(2)))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1144¶
消息：无法加载符号表
类别:解析错误
描述¶
当 SMA 执行过程中出现严重错误时，就会出现此问题。由于无法加载符号表，SMA 无法启动评估或转换过程。
其他建议¶
这不太可能是源代码本身存在错误，而更可能是 SMA 处理源代码的方式出现了错误。最佳解决方案是 在 SMA 中 提交问题。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1170¶
备注
此问题代码已 弃用
消息：平台特定密钥不支持 sparkConfig 成员密钥。
类别:转换错误
描述¶
如果您使用的是旧版本，请升级到最新版本。
其他建议¶
将您的应用程序升级到最新版本。
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1121¶
消息：org.apache.spark.sql.functions.atan 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.atan (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#atan(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.atan 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(1.0, 0.5, -1.0).toDF("value")
val result1 = df.withColumn("atan_value", atan("value"))
val result2 = df.withColumn("atan_value", atan(col("value")))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1121，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(1.0, 0.5, -1.0).toDF("value")
/*EWI: SPRKSCL1121 => org.apache.spark.sql.functions.atan has a workaround, see documentation for more info*/
val result1 = df.withColumn("atan_value", atan("value"))
/*EWI: SPRKSCL1121 => org.apache.spark.sql.functions.atan has a workaround, see documentation for more info*/
val result2 = df.withColumn("atan_value", atan(col("value")))
推荐修复方法
Snowpark 拥有等效的 atan 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(1.0, 0.5, -1.0).toDF("value")
val result1 = df.withColumn("atan_value", atan(col("value")))
val result2 = df.withColumn("atan_value", atan(col("value")))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1131¶
消息：org.apache.spark.sql.functions.grouping 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.grouping (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#grouping(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.grouping 函数示例，首先使用列名作为实参，然后使用列对象。
val df = Seq(("Alice", 2), ("Bob", 5)).toDF("name", "age")
val result1 = df.cube("name").agg(grouping("name"), sum("age"))
val result2 = df.cube("name").agg(grouping(col("name")), sum("age"))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1131，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(("Alice", 2), ("Bob", 5)).toDF("name", "age")
/*EWI: SPRKSCL1131 => org.apache.spark.sql.functions.grouping has a workaround, see documentation for more info*/
val result1 = df.cube("name").agg(grouping("name"), sum("age"))
/*EWI: SPRKSCL1131 => org.apache.spark.sql.functions.grouping has a workaround, see documentation for more info*/
val result2 = df.cube("name").agg(grouping(col("name")), sum("age"))
推荐修复方法
Snowpark 拥有等效的 grouping 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq(("Alice", 2), ("Bob", 5)).toDF("name", "age")
val result1 = df.cube("name").agg(grouping(col("name")), sum("age"))
val result2 = df.cube("name").agg(grouping(col("name")), sum("age"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1160¶
备注
自 Spark Conversion Core 4.1.0 起，此问题代码已 弃用
消息：org.apache.spark.sql.functions.sum 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.sum (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#sum(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是生成此 EWI 的 org.apache.spark.sql.functions.sum 函数的示例。在此示例中，sum 函数用于计算所选列的总和。
val df = Seq("1", "2", "3", "4", "5").toDF("elements")
val result1 = sum(col("elements"))
val result2 = sum("elements")
输出
SMA 在输出代码中添加了 EWI SPRKSCL1160，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq("1", "2", "3", "4", "5").toDF("elements")
/*EWI: SPRKSCL1160 => org.apache.spark.sql.functions.sum has a workaround, see documentation for more info*/
val result1 = sum(col("elements"))
/*EWI: SPRKSCL1160 => org.apache.spark.sql.functions.sum has a workaround, see documentation for more info*/
val result2 = sum("elements")
推荐修复方法
Snowpark 拥有等效的 sum 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
val df = Seq("1", "2", "3", "4", "5").toDF("elements")
val result1 = sum(col("elements"))
val result2 = sum(col("elements"))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1154¶
消息：org.apache.spark.sql.functions.ceil 有替代方案，请参阅文档了解更多信息
类别:警告
描述¶
当 SMA 检测到使用了 org.apache.spark.sql.functions.ceil (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/functions$.html#ceil(columnName:String):org.apache.spark.sql.Column) 函数时，就会出现此问题，该函数有替代方案。
场景¶
输入
以下是 org.apache.spark.sql.functions.ceil 函数的示例，首先使用列名作为实参，然后使用列对象，最后使用列对象和标度。
val df = Seq(2.33, 3.88, 4.11, 5.99).toDF("value")
val result1 = df.withColumn("ceil", ceil("value"))
val result2 = df.withColumn("ceil", ceil(col("value")))
val result3 = df.withColumn("ceil", ceil(col("value"), lit(1)))
输出
SMA 在输出代码中添加了 EWI SPRKSCL1154，以告知您 Snowpark 并非完全支持此函数，但它有解决方法。
val df = Seq(2.33, 3.88, 4.11, 5.99).toDF("value")
/*EWI: SPRKSCL1154 => org.apache.spark.sql.functions.ceil has a workaround, see documentation for more info*/
val result1 = df.withColumn("ceil", ceil("value"))
/*EWI: SPRKSCL1154 => org.apache.spark.sql.functions.ceil has a workaround, see documentation for more info*/
val result2 = df.withColumn("ceil", ceil(col("value")))
/*EWI: SPRKSCL1154 => org.apache.spark.sql.functions.ceil has a workaround, see documentation for more info*/
val result3 = df.withColumn("ceil", ceil(col("value"), lit(1)))
推荐修复方法
Snowpark 拥有等效的 ceil 函数，该函数接收列对象作为实参。因此，Snowpark 直接支持接收列对象作为实参的 Spark 重载，不需要进行任何更改。
对于接收字符串实参的重载，作为替代方案，您可以使用 com.snowflake.snowpark.functions.col 函数将字符串转换为列对象。
对于接收列对象和标度的重载，可以使用 callBuiltin 函数调用 Snowflake 内置的 CEIL 函数。要使用它，你应该传递字符串 ** "ceil" ** 作为第一个实参，将列作为第二个实参，将标度作为第三个实参。
val df = Seq(2.33, 3.88, 4.11, 5.99).toDF("value")
val result1 = df.withColumn("ceil", ceil(col("value")))
val result2 = df.withColumn("ceil", ceil(col("value")))
val result3 = df.withColumn("ceil", callBuiltin("ceil", col("value"), lit(1)))
其他建议¶
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。
SPRKSCL1105¶
此问题代码已 弃用
消息：不支持写入器格式值。
类别:转换错误
描述¶
当 org.apache.spark.sql.DataFrameWriter.format (https://spark.apache.org/docs/latest/api/scala/org/apache/spark/sql/DataFrameWriter.html#format(source:String):org.apache.spark.sql.DataFrameWriter%5BT%5D) 具有 Snowpark 不支持的实参时，就会出现此问题。
场景¶
根据您尝试保存的格式类型，分为几种情况。它可以是 supported 或 non-supported 格式。
场景 1¶
输入
该工具会分析尝试保存的格式类型，支持的格式有：
csvjsonorcparquettext
dfWrite.write.format("csv").save(path)
输出
当保存函数有一个参数时，该工具会将 format 方法转换为 csv 方法调用。
dfWrite.write.csv(path)
推荐修复方法
在此示例中，该工具不显示 EWI，这意味着无需修复。
场景 2¶
输入
以下示例显示了该工具在传递 net.snowflake.spark.snowflake 值时如何转换 format 方法。
dfWrite.write.format("net.snowflake.spark.snowflake").save(path)
输出
该工具显示 EWI SPRKSCL1105，表示不支持值 net.snowflake.spark.snowflake。
/*EWI: SPRKSCL1105 => Writer format value is not supported .format("net.snowflake.spark.snowflake")*/
dfWrite.write.format("net.snowflake.spark.snowflake").save(path)
推荐修复方法
对于 not supported 场景，没有具体的修复方法，因为它取决于尝试读取的文件。
场景 3¶
输入
以下示例显示了该工具在传递 csv 时如何转换 format 方法，但改用变量。
val myFormat = "csv"
dfWrite.write.format(myFormat).save(path)
输出
由于该工具无法在运行时确定变量的值，因此会显示 EWI SPRKSCL1163，提不支持该值。
val myFormat = "csv"
/*EWI: SPRKSCL1163 => format_type is not a literal and can't be evaluated*/
dfWrite.write.format(myFormat).load(path)
推荐修复方法
替代方案是，您可以检查变量的值并将其作为字符串添加到 format 调用中。
其他建议¶
Snowpark 位置仅接受使用 Snowflake 暂存区 的云位置。
Snowpark 支持的方法的文档可以在 文档 中找到
如需更多支持，请发送电子邮件至 sma-support@snowflake.com 联系我们，或者 在 SMA 中 提交问题。