Snowpark Migration Accelerator: Spark용 문제 코드 - Scala¶
SPRKSCL1126¶
메시지: org.apache.sql.functions.covar_pop에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.covar_pop 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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에는 2개의 열 오브젝트를 인자로 받는 동등한 covar_pop 함수가 있습니다. 따라서 2개의 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원되며 변경이 필요하지 않습니다.
2개의 문자열 인자를 받는 오버로드의 경우 해결 방법으로 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 요소의 사용을 감지했을 때 발생하며, 이 문제에는 관련 오류 코드가 없습니다. 이 메시지는 지원되지 않는 모든 Spark 요소에 대해 SMA 가 사용하는 일반적인 오류 코드입니다.
시나리오¶
입력
아래는 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
권장 수정
이는 지원되지 않는 다양한 함수에 적용되는 일반적인 오류 코드이므로 1개의 구체적인 수정 사항이 없습니다. 적절한 작업은 사용 중인 특정 요소에 따라 달라집니다.
해당 요소가 지원되지 않는다고 해서 반드시 해결 방법이나 해결 방법을 찾을 수 없다는 의미는 아니라는 점에 유의하십시오. SMA 자체에서 해결책을 찾을 수 없다는 의미일 뿐입니다.
추가 권장 사항¶
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1143¶
메시지: 기호 테이블을 로딩하는 동안 오류가 발생했습니다
카테고리: 변환 오류
설명¶
이 문제는 SMA 기호 테이블의 기호를 로딩하는 데 오류가 있을 때 표시됩니다. 기호 테이블은 SMA 의 기본 아키텍처의 일부로, 보다 복잡한 변환을 가능하게 합니다.
추가 권장 사항¶
이는 소스 코드 자체의 오류라기보다는 SMA 가 소스 코드를 처리하는 방법의 오류일 가능성이 높습니다. 가장 좋은 해결 방법은 SMA에 문제를 게시하는 것입니다.
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1153¶
경고
이 문제 코드는 Spark Conversion Core Version 4.3.2 이후로 사용 중단 되었습니다.
메시지: org.apache.sql.functions.max에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.max 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 이후로 사용 중단 되었습니다.
메시지: 분해는 지원되지 않습니다
카테고리: 경고
설명¶
이 문제는 Snowpark가 지원하지 않는 org.apache.sql.functions.explode 함수의 사용을 SMA 가 감지할 때 발생합니다.
시나리오¶
입력
다음은 데이터 세트의 배열 필드에 대한 통합 정보를 가져오는 데 사용되는 org.apache.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에서 지원되지 않으므로 데이터 스큐 함수를 대신 사용할 수 있습니다.
다음 수정 사항은 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.sql.functions.min에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.min 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 받는 오버로드의 경우 해결 방법으로 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.sql.functions.tanh에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.tanh 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 Version 2.40.1 이후로 사용 중단 되었습니다.
메시지: org.apache.sql.functions.split에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.split 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 이 EWI 를 생성하는 org.apache.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))
권장 수정
2개의 인자를 받는 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.sql.functions.corr에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.corr 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 org.apache.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에는 2개의 열 오브젝트를 인자로 받는 corr 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원되며 변경이 필요하지 않습니다.
2개의 문자열 인자를 받는 오버로드의 경우 해결 방법으로 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 는 출력 코드에 EWISPRKSCL1173 을 추가하여 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 임베디드 Snowpark Migration Accelerator: 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.sql.functions.grouping_id에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.grouping_id 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 여러 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 여러 개의 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원되며 변경이 필요하지 않습니다.
여러 문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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¶
경고
이 문제 코드는 사용 중단 되었습니다
메시지: 작성기 옵션은 지원되지 않습니다.
카테고리: 변환 오류입니다.
설명¶
이 문제는 도구가 작성기 문에서 Snowpark에서 지원하지 않는 옵션의 사용을 감지할 때 표시됩니다.
시나리오¶
입력
다음은 작성기 문에 옵션을 추가하는 데 사용되는 org.apache.spark.sql.DataFrameWriter.option 의 예입니다.
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.sql.functions.kurtosis에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 에서 org.apache.spark.sql.functions.kurtosis 함수의 사용을 감지할 때 나타나며, 이 함수에는 해결 방법이 있습니다.
시나리오¶
입력
다음은 이 EWI 를 생성하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.tan에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.tan 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.translate에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.translate 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 이 EWI 를 생성하는 org.apache.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.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.sql.functions.cos에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.cos 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.Metadata 를 매개 변수로 org.apache.spark.sql.types.StructField.apply 를 감지할 때 표시됩니다. 이는 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에는 2개의 매개 변수를 받는 동등한 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.sql.functions.least에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.least 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 여러 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 여러 개의 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원되며 변경이 필요하지 않습니다.
여러 문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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¶
경고
이 문제 코드는 사용 중단 되었습니다
메시지: 작성기 저장은 지원되지 않습니다.
카테고리: 변환 오류입니다.
설명¶
이 문제는 도구가 작성기 문에서 Snowpark에서 지원하지 않는 작성기 저장 방법의 사용을 감지할 때 표시됩니다.
시나리오¶
입력
다음은 DataFrame 내용을 저장하는 데 사용되는 org.apache.spark.sql.DataFrameWriter.save 의 예입니다.
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.sql.functions.degrees에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.degrees 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.covar_samp에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.covar_samp 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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에는 2개의 열 오브젝트를 인자로 받는 동등한 covar_samp 함수가 있습니다. 따라서 2개의 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원되며 변경이 필요하지 않습니다.
2개의 문자열 인자를 받는 오버로드의 경우 해결 방법으로 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.sql.functions.next_day에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.next_day 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 두 번째 인자로 문자열을 사용한 다음 열 오브젝트를 사용한 org.apache.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에는 2개의 열 오브젝트를 인자로 받는 next_day 함수와 동등한 함수가 있습니다. 따라서 2개의 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원되며 변경이 필요하지 않습니다.
열 오브젝트와 문자열을 수신하는 오버로드의 경우 해결 방법으로 com.Snowflake.snowpark.functions.lit 함수를 사용하여 문자열을 열 오브젝트로 변환할 수 있습니다.
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 의 문제 보고 옵션을 사용하여 특정 요소에서 변환 오류가 발생했음을 보고하고 도움이 될 수 있는 추가 정보를 포함하십시오.
SMA 에 정의되지 않은 요소라고 해서 반드시 Snowpark에서 지원되지 않는다는 의미는 아니라는 점에 유의하십시오. Snowpark 설명서 에서 동등한 요소가 있는지 확인해야 합니다.
추가 권장 사항¶
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1152¶
메시지: org.apache.sql.functions.variance에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.variance 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
아래는 먼저 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 메서드는 _ method name _을 지원하지 않습니다.
카테고리: 변환 오류
설명¶
이 문제는 SparkBuilder 메서드 체이닝에서 Snowflake가 지원하지 않는 메서드를 SMA 가 감지할 때 표시됩니다. 따라서 리더 문의 마이그레이션에 영향을 미칠 수 있습니다.
다음은 지원되지 않는 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 을 추가하여 마스터, 앱 이름 및 enableHiveSupport 메서드가 Snowpark에서 지원되지 않음을 알립니다. 그러면 Spark 세션 문의 마이그레이션에 영향을 미칠 수 있습니다.
val spark = Session.builder.configFile("connection.properties")
/*EWI: SPRKSCL1103 => SparkBuilder Method is not supported .master("local")*/
/*EWI: SPRKSCL1103 => SparkBuilder Method is not supported .appName("testApp")*/
/*EWI: SPRKSCL1103 => SparkBuilder method is not supported .enableHiveSupport()*/
.create
권장 수정
세션을 생성하려면 적절한 Snowflake Snowpark 구성을 추가해야 합니다.
이 예제에서는 config 변수가 사용됩니다.
val configs = Map (
"URL" -> "https://<myAccount>.snowflakecomputing.com:<port>",
"USER" -> <myUserName>,
"PASSWORD" -> <myPassword>,
"ROLE" -> <myRole>,
"WAREHOUSE" -> <myWarehouse>,
"DB" -> <myDatabase>,
"SCHEMA" -> <mySchema>
)
val session = Session.builder.configs(configs).create
또한 연결 정보와 함께 configFile(profile.properties)을 사용하는 것이 좋습니다.
## profile.properties file (a text file)
URL = https://<account_identifier>.snowflakecomputing.com
USER = <username>
PRIVATEKEY = <unencrypted_private_key_from_the_private_key_file>
ROLE = <role_name>
WAREHOUSE = <warehouse_name>
DB = <database_name>
SCHEMA = <schema_name>
그리고 Session.builder.configFile 을 사용하여 세션을 생성할 수 있습니다.
val session = Session.builder.configFile("/path/to/properties/file").create
추가 권장 사항¶
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1137¶
메시지: org.apache.sql.functions.sin에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.sin 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 에 Snowpark에서 지원하지 않는 인자가 있을 때 표시됩니다.
시나리오¶
로딩하려는 형식의 유형에 따라 몇 가지 시나리오가 있습니다. 지원되는 또는 지원되지 않는 형식일 수 있습니다.
시나리오 1¶
입력
이 도구는 로딩하려는 형식의 유형을 분석하며, 지원되는 형식은 다음과 같습니다.
csvjsonorcparquettext
아래 예는 csv 값을 전달할 때 도구가 format 메서드를 변환하는 방법을 보여줍니다.
spark.read.format("csv").load(path)
출력
이 도구는 로딩 함수에 1개의 매개 변수가 있는 경우 format 메서드를 csv 메서드 호출로 변환합니다.
spark.read.csv(path)
권장 수정
이 경우 도구에 EWI 가 표시되지 않으므로 수정할 필요가 없습니다.
시나리오 2¶
입력
아래 예제는 net.Snowflake.spark.Snowflake 값을 전달할 때 도구가 format 메서드를 변환하는 방법을 보여줍니다.
spark.read.format("net.snowflake.spark.snowflake").load(path)
출력
이 도구는 net.Snowflake.spark.Snowflake 값이 지원되지 않음을 나타내는 EWI SPRKSCL1166 을 표시합니다.
/*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)
권장 수정
지원되지 않는 시나리오의 경우 읽을 파일에 따라 종속성이 달라지므로 특별한 수정 사항이 없습니다.
시나리오 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.sql.functions.trunc에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.trunc 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 EWI 를 생성하는 org.apache.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.sql.functions.toRadians에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.toRadians 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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.sql.functions.stddev_samp에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.stddev_samp 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 EWI 를 생성하는 org.apache.sql.functions.stddev_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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 에 Snowpark에서 지원하지 않는 인자가 있을 때 표시됩니다.
시나리오¶
로딩하려는 형식의 유형에 따라 몇 가지 시나리오가 있습니다. 지원되는 또는 지원되지 않는 형식일 수 있습니다.
시나리오 1¶
입력
이 도구는 로딩하려는 형식의 유형을 분석하며, 지원되는 형식은 다음과 같습니다.
csvjsonorcparquettext
아래 예는 csv 값을 전달할 때 도구가 format 메서드를 변환하는 방법을 보여줍니다.
spark.read.format("csv").load(path)
출력
이 도구는 로딩 함수에 1개의 매개 변수가 있는 경우 format 메서드를 csv 메서드 호출로 변환합니다.
spark.read.csv(path)
권장 수정
이 경우 도구에 EWI 가 표시되지 않으므로 수정할 필요가 없습니다.
시나리오 2¶
입력
아래 예제는 net.Snowflake.spark.Snowflake 값을 전달할 때 도구가 format 메서드를 변환하는 방법을 보여줍니다.
spark.read.format("net.snowflake.spark.snowflake").load(path)
출력
이 도구는 net.Snowflake.spark.Snowflake 값이 지원되지 않음을 나타내는 EWI SPRKSCL1108 을 표시합니다.
/*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)
권장 수정
지원되지 않는 시나리오의 경우 읽을 파일에 따라 종속성이 달라지므로 특별한 수정 사항이 없습니다.
시나리오 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.sql.functions.exp에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.exp 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.sinh에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.sinh 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.floor에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.floor 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
아래는 org.apache.sql.functions.floor 함수의 예시로, 처음에는 열 이름을 인자로 사용하고, 그 다음에는 열 오브젝트, 마지막으로 2개의 열 오브젝트로 사용합니다.
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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 com.Snowflake.snowpark.functions.col 함수를 사용하여 문자열을 열 오브젝트로 변환할 수 있습니다.
열 오브젝트와 스케일을 수신하는 오버로드의 경우 callBuiltin 함수를 사용하여 FLOOR 함수에 내장된 Snowflake를 호출할 수 있습니다. 이를 사용하려면 문자열 “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¶
메시지: 인자 값 _ given arguments _가 있는 _ 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.sql.functions.sqrt에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.sqrt 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.Column.endsWith에는 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.Column.endsWith 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 리터럴 문자열 인자와 열 오브젝트 인자를 함께 사용하는 org.apache.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.sql.functions.toDegrees에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.toDegrees 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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.sql.functions.skewness에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.skewness 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 이 EWI 를 생성하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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의 매개 변수가 정의되지 않았음을 감지할 때 표시됩니다.
시나리오¶
입력
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.sql.functions.repeat에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.sql.functions.repeat 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 이 EWI 를 생성하는 org.apache.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.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.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는 매개 변수가 2개 이상이거나 정규식 패턴을 포함하는 분할 함수를 지원하지 않습니다. 자세한 내용은 설명서를 참조하십시오.
카테고리: 경고.
설명¶
이 문제는 org.apache.spark.sql.functions.split에 2개 이상의 매개 변수가 있거나 정규식 패턴을 포함하는 것을 SMA 가 감지할 때 나타납니다.
시나리오¶
split 함수는 지정된 패턴의 일치 항목을 중심으로 지정된 열을 분리하는 데 사용됩니다. 이 Spark 함수에는 3가지 오버로드가 있습니다.
시나리오 1¶
입력
다음은 이 EWI 를 생성하는 org.apache.sql.functions.split 함수의 예입니다. 이 예제에서 split 함수에는 2개의 매개 변수가 있으며 두 번째 인자는 정규식 패턴이 아닌 문자열입니다.
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.sql.functions.split 함수의 예입니다. 이 예제에서 split 함수에는 2개의 매개 변수가 있고 두 번째 인자는 정규식 패턴입니다.
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
val result = df.select(split(col("words"), "^([\\d]+-[\\d]+-[\\d])"))
출력
SMA 는 출력 코드에 EWI SPRKSCL1171 을 추가하여 이 함수가 Snowpark에서 정규식 패턴을 지원하지 않으므로 Snowflake에 의해 이 함수가 완전히 지원되지 않음을 알려줍니다.
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.sql.functions.split 함수의 예입니다. 이 예제에서 split 함수에는 2개 이상의 매개 변수가 있습니다.
val df = Seq("Snowflake", "Snowpark", "Snow", "Spark").toDF("words")
val result = df.select(split(df("words"), "Snow", 3))
출력
SMA 는 출력 코드에 EWI SPRKSCL1171 을 추가하여 이 함수가 Snowpark에서 완전히 지원되지 않음을 알려주는데, 이는 Snowflake에 2개 이상의 매개 변수가 있는 분할 함수가 없기 때문입니다.
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는 매개 변수가 2개 이상인 분할 함수를 지원하지 않으므로 Snowflake에서 지원하는 분할 함수를 사용하십시오.
추가 권장 사항¶
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1120¶
메시지: org.apache.sql.functions.asin에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.asin 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.greatest에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 org.apache.spark.sql.functions.greatest 함수의 사용을 감지할 때 발생하며, 해결 방법이 있습니다.
시나리오¶
입력
다음은 여러 열 이름을 인자로 사용한 다음 여러 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원되며 변경이 필요하지 않습니다.
여러 문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 Extension이 프로젝트 구성 파일에 추가되지 않았습니다.
SPRKSCL1161¶
메시지: 종속성을 추가하지 못했습니다.
카테고리: 변환 오류입니다.
설명¶
이 문제는 SMA 가 프로젝트 구성 파일에서 SMA 가 지원되지 않는 Spark 버전을 감지하여 SMA 가 해당 프로젝트 구성 파일에 Snowpark 및 Snowpark Extensions 종속성을 추가할 수 없기 때문에 발생합니다. Snowpark 종속성을 추가하지 않으면 마이그레이션된 코드가 컴파일되지 않습니다.
시나리오¶
가능한 시나리오는 sbt, gradle 및 pom.xml의 3가지입니다. SMA 는 프로젝트 구성 파일을 처리하기 위해 Spark 종속성을 제거하고 Snowpark 및 Snowpark Extension 종속성을 추가하려고 시도합니다.
시나리오 1¶
입력
다음은 sbt 프로젝트 구성 파일에서 종속성 섹션의 예입니다.
...
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 종속성을 제거하고 sbt 프로젝트 구성 파일에 Snowpark 및 Snowpark Extension 종속성을 추가합니다.
...
libraryDependencies += "com.snowflake" % "snowpark" % "1.14.0"
libraryDependencies += "net.mobilize.snowpark-extensions" % "snowparkextensions" % "0.0.18"
...
프로젝트의 요구 사항을 가장 잘 충족하는 Snowpark 버전을 사용하십시오.
시나리오 2¶
입력
다음은 gradle 프로젝트 구성 파일에서 종속성 섹션의 예입니다.
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 종속성을 제거하고 gradle 프로젝트 구성 파일에 Snowpark 및 Snowpark Extension 종속성을 추가합니다.
dependencies {
implementation 'com.snowflake:snowpark:1.14.2'
implementation 'net.mobilize.snowpark-extensions:snowparkextensions:0.0.18'
...
}
종속성 버전이 프로젝트 요구 사항에 맞는지 확인하십시오.
시나리오 3¶
입력
다음은 pom.xml 프로젝트 구성 파일에서 종속성 섹션의 예입니다.
<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 종속성을 제거하고 gradle 프로젝트 구성 파일에 Snowpark 및 Snowpark Extension 종속성을 추가합니다.
<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입니다
최신 Snowpark 버전은 여기 에서 확인할 수 있습니다.
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1155¶
경고
이 문제 코드는 Spark Conversion Core Version 4.3.2 이후로 사용 중단 되었습니다.
메시지: org.apache.sql.functions.countDistinct에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.countDistinct 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 세션 빌더 옵션이 지원되지 않습니다.
카테고리: 변환 오류입니다.
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.SparkSession.Builder.config 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
아래는 Spark 세션에서 옵션을 설정하는 데 사용되는 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에서 지원되지 않음을 알려줍니다. 그러면 config 함수를 통해 Spark 세션에서 옵션을 설정할 수 없으며 Spark 세션 문 마이그레이션에 영향을 미칠 수 있습니다.
val spark = Session.builder.configFile("connection.properties")
/*EWI: SPRKSCL1104 => SparkBuilder Option is not supported .config("spark.sql.broadcastTimeout", "3600")*/
.create()
권장 수정
세션을 생성하려면 적절한 Snowflake Snowpark 구성을 추가해야 합니다.
이 예제에서는 config 변수가 사용됩니다.
val configs = Map (
"URL" -> "https://<myAccount>.snowflakecomputing.com:<port>",
"USER" -> <myUserName>,
"PASSWORD" -> <myPassword>,
"ROLE" -> <myRole>,
"WAREHOUSE" -> <myWarehouse>,
"DB" -> <myDatabase>,
"SCHEMA" -> <mySchema>
)
val session = Session.builder.configs(configs).create
또한 연결 정보와 함께 configFile(profile.properties)을 사용하는 것이 좋습니다.
## profile.properties file (a text file)
URL = https://<account_identifier>.snowflakecomputing.com
USER = <username>
PRIVATEKEY = <unencrypted_private_key_from_the_private_key_file>
ROLE = <role_name>
WAREHOUSE = <warehouse_name>
DB = <database_name>
SCHEMA = <schema_name>
그리고 Session.builder.configFile 을 사용하여 세션을 생성할 수 있습니다.
val session = Session.builder.configFile("/path/to/properties/file").create
추가 권장 사항¶
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1124¶
메시지: org.apache.sql.functions.cosh에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.cosh 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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¶
메시지: 두 매개 변수 udf 함수는 Snowpark에서 지원되지 않습니다. 단일 매개 변수 udf 함수로 변환해야 합니다. Snowpark에서 작동하도록 코드를 수동으로 수정하는 방법을 알아보려면 설명서를 확인하십시오.
카테고리: 변환 오류입니다.
설명¶
이 문제는 SMA 가 소스 코드에서 두 매개 변수 org.apache.sql.functions.udf 함수의 사용을 감지할 때 나타나는데, Snowpark에 해당하는 두 매개 변수 udf 함수가 없기 때문에 출력 코드가 컴파일되지 않을 수 있습니다.
시나리오¶
입력
다음은 EWI 를 생성하는 org.apache.sql.functions.udf 함수의 예입니다. 이 예제에서 udf 함수에는 2개의 매개 변수가 있습니다.
val myFuncUdf = udf(new UDF1[String, Integer] {
override def call(s: String): Integer = s.length()
}, IntegerType)
출력
SMA 는 출력 코드에 EWI SPRKSCL1175 를 추가하여 udf 함수가 2개의 매개 변수가 있으므로 지원되지 않음을 알립니다.
/*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 가 파일의 코드에서 올바르게 읽거나 이해할 수 없는 문장을 감지했을 때 발생하며, 구문 분석 오류 라고 합니다. 또한 이 문제는 파일에 1개 이상의 구문 분석 오류가 있을 때 표시됩니다.
시나리오¶
입력
다음은 잘못된 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.sql.functions.stddev_pop에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.stddev_pop 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
아래는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 메서드는 _ 메서드 이름 _을 지원하지 않습니다.
카테고리: 경고
설명¶
이 문제는 DataFrameReader 메서드 체이닝에서 Snowflake가 지원하지 않는 메서드를 SMA 가 감지할 때 표시됩니다. 그러면 리더 문의 마이그레이션에 영향을 미칠 수 있습니다.
시나리오¶
입력
아래는 로딩 메서드가 Snowflake에서 지원되지 않는 DataFrameReader 메서드 체인 예시입니다.
spark.read.
format("net.snowflake.spark.snowflake").
option("query", s"select * from $tablename")
load()
출력
SMA 는 출력 코드에 EWI SPRKSCL1110 을 추가하여 로딩 방식이 Snowpark에서 지원되지 않음을 알립니다. 그러면 리더 문의 마이그레이션에 영향을 미칠 수 있습니다.
session.sql(s"select * from $tablename")
/*EWI: SPRKSCL1110 => Reader method not supported .load()*/
권장 수정
Snowflake에서 지원하는 방법을 알아보려면 여기 에서 리더용 Snowpark 설명서를 확인하십시오.
추가 권장 사항¶
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1100¶
이 문제 코드는 Spark Conversion Core 2.3.22 이후로 사용 중단 되었습니다.
메시지: 파티션 재분할은 지원되지 않습니다.
카테고리: 구문 분석 오류.
설명¶
이 문제는 Snowpark가 지원하지 않는 org.apache.spark.sql.DataFrame.repartition 함수의 사용을 SMA 가 감지할 때 발생합니다. Snowflake는 클러스터의 저장소와 작업 부하를 관리하여 재분할 작업을 적용할 수 없도록 합니다.
시나리오¶
입력
다음은 지정된 파티션 식에 의해 파티션된 새로운 DataFrame 을 반환하는 데 사용되는 org.apache.spark.sql.DataFrame.repartition 함수의 예입니다.
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 데이터프레임 참조 는 특정 시나리오를 다시 분할할 필요 없이 적용하는 방법에 유용할 수 있습니다.
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1151¶
메시지: org.apache.sql.functions.var_samp에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.var_samp 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 메서드 체인에 대한 리더 형식을 정의할 수 없습니다
카테고리: 경고
설명¶
이 문제는 DataFrameReader 메서드 체인에서 형식 의 리더가 Snowpark의 avro, csv, json, orc, parquet 및 xml 중 하나가 아님을 SMA 가 감지할 때 나타납니다. 따라서 SMA 가 설정 옵션이 정의되어 있는지 여부를 확인할 수 없습니다.
시나리오¶
입력
아래는 DataFrameReader 메서드 체인 예시로, SMA 가 리더의 형식을 결정할 수 있습니다.
spark.read.format("net.snowflake.spark.snowflake")
.option("query", s"select * from $tableName")
.load()
출력
SMA 는 EWI SPRKSCL1165 를 출력 코드에 추가하여, 지정된 DataFrameReader 메서드 연결에서 리더의 형식 을 결정할 수 없음을 알립니다.
/*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.sql.functions.log에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.log 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
다음은 이 EWI 를 생성하는 org.apache.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")))
권장 수정
다음은 로그 함수의 모든 오버로드에 대한 다양한 해결 방법입니다.
1. def log(base: Double, columnName: String): 열
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): 열
com.Snowflake.snowpark.functions.lit 함수를 사용하여 베이스를 열 오브젝트로 변환할 수 있습니다.
val result2 = df.withColumn("log_value", log(lit(10), col("value")))
3.def log(columnName: String): 열
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): 열
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.sql.functions.count에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.count 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
다음은 열 이름을 인자로 사용한 다음 열 오브젝트와 함께 사용하는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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¶
메시지: 단일 매개 변수 udf 함수는 Snowpark에서 지원되지만 수동 개입이 필요할 수 있습니다. Snowpark에서 작동하도록 코드를 수동으로 수정하는 방법을 알아보려면 설명서를 확인하십시오.
카테고리: 경고.
설명¶
이 문제는 SMA 가 코드에서 단일 매개 변수 org.apache.sql.functions.udf 함수의 사용을 감지할 때 표시됩니다. 그런 다음 수동 개입이 필요할 수 있습니다.
Snowpark API 는 Lambda 또는 Scala의 함수에서 사용자 정의 함수를 생성할 수 있는 com.Snowflake.snowpark.functions.udf 함수를 제공하지만, 올바르게 작동하려면 코드를 일부 수동으로 변경해야 할 수 있으므로 udf 를 생성할 때 몇 가지 주의 사항이 있습니다.
시나리오¶
Snowpark udf 함수는 수동 개입 없이도 다양한 경우에 의도한 대로 작동해야 합니다. 그러나 Snowpark에서 작동하도록 하기 위해 코드를 수동으로 수정해야 하는 몇 가지 시나리오가 있습니다. 이러한 시나리오 중 일부는 아래에 목록에 나와 있습니다.
시나리오 1¶
입력
아래는 App Trait을 사용하여 오브젝트에 UDFs 를 생성하는 예제입니다.
Scala의 App 특성은 오브젝트 정의 내에서 코드를 자동으로 실행하는 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 를 추가하여 단일 매개 변수 udf 함수가 Snowpark에서 지원되지만, 수동 개입이 필요하다는 것을 알립니다.
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 Notebooks에서 UDFs 를 생성하는 예제입니다.
def myFunc(s: String): String = {
...
}
val myFuncUdf = udf((x: String) => myFunc(x))
df1.select(myFuncUdf(col("name"))).show()
출력
SMA 는 출력 코드에 EWI SPRKSCL1174 를 추가하여 단일 매개 변수 udf 함수가 Snowpark에서 지원되지만, 수동 개입이 필요하다는 것을 알립니다.
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 노트북에서 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 Notebooks에서 UDFs 를 생성하는 방법에 대한 자세한 내용은 Jupyter Notebooks에서 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.sql.functions.stddev에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.stddev 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
아래는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 함수의 사용을 감지할 때 발생합니다.
시나리오¶
입력
DataTypes.CreateDecimalType 함수의 사용 예는 다음과 같습니다.
var result = DataTypes.createDecimalType(18, 8)
출력
SMA 는 출력 코드에 EWI SPRKSCL1111 를 추가하여 CreateDecimalType 함수가 Snowpark에서 지원되지 않음을 알려줍니다.
/*EWI: SPRKSCL1111 => CreateDecimalType is not supported*/
var result = createDecimalType(18, 8)
권장 수정
아직 권장되는 수정 사항은 없습니다.
메시지: Spark 세션 빌더 옵션이 지원되지 않습니다.
카테고리: 변환 오류입니다.
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.SparkSession.Builder.config 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
아래는 Spark 세션에서 옵션을 설정하는 데 사용되는 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에서 지원되지 않음을 알려줍니다. 그러면 config 함수를 통해 Spark 세션에서 옵션을 설정할 수 없으며 Spark 세션 문 마이그레이션에 영향을 미칠 수 있습니다.
val spark = Session.builder.configFile("connection.properties")
/*EWI: SPRKSCL1104 => SparkBuilder Option is not supported .config("spark.sql.broadcastTimeout", "3600")*/
.create()
권장 수정
세션을 생성하려면 적절한 Snowflake Snowpark 구성을 추가해야 합니다.
이 예제에서는 config 변수가 사용됩니다.
val configs = Map (
"URL" -> "https://<myAccount>.snowflakecomputing.com:<port>",
"USER" -> <myUserName>,
"PASSWORD" -> <myPassword>,
"ROLE" -> <myRole>,
"WAREHOUSE" -> <myWarehouse>,
"DB" -> <myDatabase>,
"SCHEMA" -> <mySchema>
)
val session = Session.builder.configs(configs).create
또한 연결 정보와 함께 configFile(profile.properties)을 사용하는 것이 좋습니다.
## profile.properties file (a text file)
URL = https://<account_identifier>.snowflakecomputing.com
USER = <username>
PRIVATEKEY = <unencrypted_private_key_from_the_private_key_file>
ROLE = <role_name>
WAREHOUSE = <warehouse_name>
DB = <database_name>
SCHEMA = <schema_name>
그리고 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 이후로 사용 중단 되었습니다.
메시지: 브로드캐스트는 지원되지 않습니다
카테고리: 경고
설명¶
이 문제는 Snowpark가 지원하지 않는 org.apache.spark.sql.functions.broadcast 함수의 사용을 SMA 가 감지할 때 발생합니다. 이 함수는 Snowflake가 브로드캐스트 변수 를 지원하지 않기 때문에 지원되지 않습니다.
시나리오¶
입력
다음은 각 Spark 클러스터에서 사용할 브로드캐스트 오브젝트를 생성하는 데 사용되는 org.apache.sql.functions.broadcast 함수의 예입니다.
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 데이터프레임 참조 가 유용할 수 있습니다.
추가 지원이 필요하면 sma-support@Snowflake.com 또는 SMA에 문제를 게시할 수 있습니다.
SPRKSCL1150¶
메시지: org.apache.sql.functions.var_pop에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.var_pop 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
아래는 org.apache.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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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의 매개 변수가 정의되지 않았음을 감지할 때 표시됩니다.
시나리오¶
입력
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.sql.functions.mean에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.mean 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
다음은 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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 Version 4.6.0 이후 사용 중단 되었습니다.
메시지: org.apache.sql.functions.round에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.round 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
다음은 EWI 를 생성하는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
열 오브젝트와 스케일을 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.atan에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.atan 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
아래는 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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.grouping에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.grouping 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
아래는 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 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.sum에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.sum 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
다음은 이 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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 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.sql.functions.ceil에 해결 방법이 있습니다. 자세한 내용은 설명서를 참조하십시오
카테고리: 경고
설명¶
이 문제는 SMA 가 Spark Session의 옵션을 설정하는 org.apache.spark.sql.functions.ceil 함수의 사용을 감지했지만, Snowpark에서 지원하지 않을 때 발생합니다.
시나리오¶
입력
아래는 org.apache.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 함수와 동등한 함수가 있습니다. 따라서 열 오브젝트를 인자로 받는 Spark 오버로드는 Snowpark에서 직접 지원하며 변경이 필요하지 않습니다.
문자열 인자를 수신하는 오버로드의 경우 해결 방법으로 com.Snowflake.snowpark.functions.col 함수를 사용하여 문자열을 열 오브젝트로 변환할 수 있습니다.
열 오브젝트와 스케일을 수신하는 오버로드의 경우 callBuiltin 함수를 사용하여 CEIL 함수에 내장된 Snowflake를 호출할 수 있습니다. 이를 사용하려면 문자열 “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 에 Snowpark에서 지원하지 않는 인자가 있을 때 표시됩니다.
시나리오¶
저장하려는 형식의 유형에 따라 몇 가지 시나리오가 있습니다. 지원되는 또는 지원되지 않는 형식일 수 있습니다.
시나리오 1¶
입력
이 도구는 저장하려는 형식의 유형을 분석하며, 지원되는 형식은 다음과 같습니다.
csvjsonorcparquettext
dfWrite.write.format("csv").save(path)
출력
이 도구는 로딩 함수에 1개의 매개 변수가 있는 경우 format 메서드를 csv 메서드 호출로 저장합니다.
dfWrite.write.csv(path)
권장 수정
이 경우 도구에 EWI 가 표시되지 않으므로 수정할 필요가 없습니다.
시나리오 2¶
입력
아래 예제는 net.Snowflake.spark.Snowflake 값을 전달할 때 도구가 format 메서드를 변환하는 방법을 보여줍니다.
dfWrite.write.format("net.snowflake.spark.snowflake").save(path)
출력
이 도구는 net.Snowflake.spark.Snowflake 값이 지원되지 않음을 나타내는 EWI SPRKSCL1105 을 표시합니다.
/*EWI: SPRKSCL1105 => Writer format value is not supported .format("net.snowflake.spark.snowflake")*/
dfWrite.write.format("net.snowflake.spark.snowflake").save(path)
권장 수정
지원되지 않는 시나리오의 경우 읽을 파일에 따라 종속성이 달라지므로 특별한 수정 사항이 없습니다.
시나리오 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에 문제를 게시할 수 있습니다.