cómo filtrar un valor nulo de spark dataframe

O como df.filter($"friend_id".isNotNull)

df.where(df.col("friend_id").isNull)

Encontré una buena solución para eliminar las filas con cualquier valor nulo:

Dataset<Row> filtered = df.filter(row -> !row.anyNull());

En caso de que uno esté interesado en el otro caso, simplemente llame a row.anyNull(). (Spark 2.1.0 usando Java API)

Hay dos formas de hacerlo: crear la condición de filtro 1) Manualmente 2) Dinámicamente.

Ejemplo de DataFrame:

val df = spark.createDataFrame(Seq(
  (0, "a1", "b1", "c1", "d1"),
  (1, "a2", "b2", "c2", "d2"),
  (2, "a3", "b3", null, "d3"),
  (3, "a4", null, "c4", "d4"),
  (4, null, "b5", "c5", "d5")
)).toDF("id", "col1", "col2", "col3", "col4")

+---+----+----+----+----+
| id|col1|col2|col3|col4|
+---+----+----+----+----+
|  0|  a1|  b1|  c1|  d1|
|  1|  a2|  b2|  c2|  d2|
|  2|  a3|  b3|null|  d3|
|  3|  a4|null|  c4|  d4|
|  4|null|  b5|  c5|  d5|
+---+----+----+----+----+

1) Crear condición de filtro manualmente es decir, usando DataFrame where o filter función

df.filter(col("col1").isNotNull && col("col2").isNotNull).show

O

df.where("col1 is not null and col2 is not null").show

Resultado:

+---+----+----+----+----+
| id|col1|col2|col3|col4|
+---+----+----+----+----+
|  0|  a1|  b1|  c1|  d1|
|  1|  a2|  b2|  c2|  d2|
|  2|  a3|  b3|null|  d3|
+---+----+----+----+----+

2) Crear condición de filtro dinámicamente: Esto es útil cuando no queremos que ninguna columna tenga valor nulo y hay un gran número de columnas, que es sobre todo el caso.

Crear la condición de filtro manualmente en estos casos perderá mucho tiempo. En el siguiente código estamos incluyendo todas las columnas dinámicamente usando la función map y reduce en las columnas DataFrame:

val filterCond = df.columns.map(x=>col(x).isNotNull).reduce(_ && _)

Cómo se ve filterCond:

filterCond: org.apache.spark.sql.Column = (((((id IS NOT NULL) AND (col1 IS NOT NULL)) AND (col2 IS NOT NULL)) AND (col3 IS NOT NULL)) AND (col4 IS NOT NULL))

Filtrado:

val filteredDf = df.filter(filterCond)

Resultado:

+---+----+----+----+----+
| id|col1|col2|col3|col4|
+---+----+----+----+----+
|  0|  a1|  b1|  c1|  d1|
|  1|  a2|  b2|  c2|  d2|
+---+----+----+----+----+

De la pista de Michael Kopaniov, a continuación obras

df.where(df("id").isNotNull).show

Aquí hay una solución para spark en Java. Para seleccionar filas de datos que contengan nulos. Cuando tiene datos del conjunto de datos, lo hace:

Dataset<Row> containingNulls =  data.where(data.col("COLUMN_NAME").isNull())

Para filtrar los datos sin nulos que hacer:

Dataset<Row> withoutNulls = data.where(data.col("COLUMN_NAME").isNotNull())

A menudo los dataframes contienen columnas de tipo String donde en lugar de null tenemos strings vacíos como "". Para filtrar tales datos también lo hacemos:

Dataset<Row> withoutNullsAndEmpty = data.where(data.col("COLUMN_NAME").isNotNull().and(data.col("COLUMN_NAME").notEqual("")))

Utilizo el siguiente código para resolver mi pregunta. Funciona. Pero como todos sabemos, trabajo alrededor de la milla de un país para resolverlo. Entonces, ¿hay un atajo para eso? Gracias

def filter_null(field : Any) : Int = field match {
    case null => 0
    case _    => 1
}

val test = train_event_join.join(
    user_friends_pair,
    train_event_join("user_id") === user_friends_pair("user_id") &&
    train_event_join("event_owner") === user_friends_pair("friend_id"),
    "left"
).select(
    train_event_join("user_id"),
    train_event_join("event_id"),
    train_event_join("invited"),
    train_event_join("day_diff"),
    train_event_join("interested"),
    train_event_join("event_owner"),
    user_friends_pair("friend_id")
).rdd.map{
    line => (
        line(0).toString.toLong,
        line(1).toString.toLong,
        line(2).toString.toLong,
        line(3).toString.toLong,
        line(4).toString.toLong,
        line(5).toString.toLong,
        filter_null(line(6))
        )
    }.toDF("user_id", "event_id", "invited", "day_diff", "interested", "event_owner", "creator_is_friend")