Różnica między === nieważną i IsNull w Spark DataDrame

Question

Jestem nieco mylić z tą różnicą, gdy używamy

df.filter(col("c1") === null) and df.filter(col("c1").isNull) 

samo dataframe jestem coraz liczy w === zerowa ale zerowej liczby w IsNull. Pomóż mi zrozumieć różnicę. Dziękujemy

Answer 1

Przede wszystkim nie używaj kodu null w swoim kodzie Scala, chyba że naprawdę musisz z powodu kompatybilności.

Jeśli chodzi o twoje pytanie, jest to zwykły kod SQL. col("c1") === null jest interpretowany jako c1 = NULL, a ponieważ NULL oznacza niezdefiniowane wartości, wynik jest niezdefiniowany dla dowolnej wartości, w tym samej NULL.

spark.sql("SELECT NULL = NULL").show 

+-------------+ 
|(NULL = NULL)| 
+-------------+ 
|   null| 
+-------------+ 

spark.sql("SELECT NULL != NULL").show 

+-------------------+ 
|(NOT (NULL = NULL))| 
+-------------------+ 
|    null| 
+-------------------+ 

spark.sql("SELECT TRUE != NULL").show 

+------------------------------------+ 
|(NOT (true = CAST(NULL AS BOOLEAN)))| 
+------------------------------------+ 
|        null| 
+------------------------------------+ 

spark.sql("SELECT TRUE = NULL").show 

+------------------------------+ 
|(true = CAST(NULL AS BOOLEAN))| 
+------------------------------+ 
|       null| 
+------------------------------+ 

wyłącznie ważny metod, aby sprawdzić NULL są:

• IS NULL:

  spark.sql("SELECT NULL IS NULL").show 
  

  +--------------+ 
  |(NULL IS NULL)| 
  +--------------+ 
  |   true| 
  +--------------+ 
  

  spark.sql("SELECT TRUE IS NULL").show 
  

  +--------------+ 
  |(true IS NULL)| 
  +--------------+ 
  |   false| 
  +--------------+ 
  

• IS NOT NULL:

  spark.sql("SELECT NULL IS NOT NULL").show 
  

  +------------------+ 
  |(NULL IS NOT NULL)| 
  +------------------+ 
  |    false| 
  +------------------+ 
  

  spark.sql("SELECT TRUE IS NOT NULL").show 
  

  +------------------+ 
  |(true IS NOT NULL)| 
  +------------------+ 
  |    true| 
  +------------------+ 
  

realizowane w DataFrame DSL jako Column.isNull i Column.isNotNull odpowiednio.

Answer 2

Zazwyczaj najlepszym sposobem, aby rzucić światło na nieoczekiwane wyniki w Spark Dataframes jest spojrzenie na plan wyjaśniający. Rozważmy następujący przykład:

import org.apache.spark.sql.{DataFrame, SparkSession} 
import org.apache.spark.sql.functions._ 

object Example extends App { 

    val session = SparkSession.builder().master("local[*]").getOrCreate() 
    case class Record(c1: String, c2: String) 
    val data = List(Record("a", "b"), Record(null, "c")) 
    val rdd = session.sparkContext.parallelize(data) 
    import session.implicits._ 

    val df: DataFrame = rdd.toDF 
    val filtered = df.filter(col("c1") === null) 
    println(filtered.count()) // <-- outputs 0, not expected 

    val filtered2 = df.filter(col("c1").isNull) 
    println(filtered2.count()) 
    println(filtered2) // <- outputs 1, as expected 

    filtered.explain(true) 
    filtered2.explain(true) 
} 

Pierwszy wyjaśnić Plan pokazuje:

== Physical Plan == 
*Filter (isnotnull(c1#2) && null) 
+- Scan ExistingRDD[c1#2,c2#3] 
== Parsed Logical Plan == 
'Filter isnull('c1) 
+- LogicalRDD [c1#2, c2#3] 

Ten filtr klauzula wygląda bezsensowne. Dzięki temu && do null nigdy nie zostanie rozwiązane na true.

Drugi wyjaśnić Plan wygląda następująco:

== Physical Plan == 
*Filter isnull(c1#2) 
+- Scan ExistingRDD[c1#2,c2#3] 

Tutaj filtr ma co oczekiwać i chcą.