scala - repetidos - excel buscar datos iguales en una columna

¿Cómo evitar columnas duplicadas después de unir?

Question

Tengo dos marcos de datos con las siguientes columnas:

df1.columns
//  Array(ts, id, X1, X2)

y

df2.columns
//  Array(ts, id, Y1, Y2)

Despues de hacer

val df_combined = df1.join(df2, Seq(ts,id))

Termino con las siguientes columnas: Array(ts, id, X1, X2, ts, id, Y1, Y2) . Podría esperar que las columnas comunes se eliminen. ¿Hay algo adicional que deba hacerse?

Answer 1

Este es un comportamiento esperado. DataFrame.join método DataFrame.join es equivalente a una unión SQL como esta

SELECT * FROM a JOIN b ON joinExprs

Si desea ignorar las columnas duplicadas, simplemente suéltelas o seleccione columnas de interés después. Si desea DataFrames la DataFrames puede usar el acceso a estos utilizando DataFrames padre:

val a: DataFrame = ???
val b: DataFrame = ???
val joinExprs: Column = ???

a.join(b, joinExprs).select(a("id"), b("foo"))
// drop equivalent 
a.alias("a").join(b.alias("b"), joinExprs).drop(b("id")).drop(a("foo"))

o use alias:

// As for now aliases don''t work with drop
a.alias("a").join(b.alias("b"), joinExprs).select($"a.id", $"b.foo")

Para equi-une existe una sintaxis de acceso directo especial que toma una secuencia de cadenas :

val usingColumns: Seq[String] = ???

a.join(b, usingColumns)

o como una sola cadena

val usingColumn: String = ???

a.join(b, usingColumn)

que mantienen solo una copia de las columnas utilizadas en una condición de unión.

Answer 2

Este es un comportamiento normal de SQL, lo que estoy haciendo para esto:

• Soltar o renombrar columnas de origen
• Haz la unión
• Suelte la columna renombrada si hay alguna

Aquí estoy reemplazando la columna "nombre completo":

Algún código en Java:

this
    .sqlContext
    .read()
    .parquet(String.format("hdfs:///user/blablacar/data/year=%d/month=%d/day=%d", year, month, day))
    .drop("fullname")
    .registerTempTable("data_original");

this
    .sqlContext
    .read()
    .parquet(String.format("hdfs:///user/blablacar/data_v2/year=%d/month=%d/day=%d", year, month, day))
    .registerTempTable("data_v2");

 this
    .sqlContext
    .sql(etlQuery)
    .repartition(1)
    .write()
    .mode(SaveMode.Overwrite)
    .parquet(outputPath);

Donde está la consulta:

SELECT
    d.*,
   concat_ws(''_'', product_name, product_module, name) AS fullname
FROM
    {table_source} d
LEFT OUTER JOIN
    {table_updates} u ON u.id = d.id

Esto es algo que solo puede hacer con Spark, creo (suelte la columna de la lista), ¡muy, muy útil!

Answer 3

He estado atrapado con esto por un tiempo, y solo recientemente se me ocurrió una solución que es bastante fácil.

Decir que es

scala> val a  = Seq(("a", 1), ("b", 2)).toDF("key", "vala")
a: org.apache.spark.sql.DataFrame = [key: string, vala: int]

scala> a.show
+---+----+
|key|vala|
+---+----+
|  a|   1|
|  b|   2|
+---+----+
and 
scala> val b  = Seq(("a", 1)).toDF("key", "valb")
b: org.apache.spark.sql.DataFrame = [key: string, valb: int]

scala> b.show
+---+----+
|key|valb|
+---+----+
|  a|   1|
+---+----+

y puedo hacer esto para seleccionar solo el valor en el marco de datos a:

scala> a.join(b, a("key") === b("key"), "left").select(a.columns.map(a(_)) : _*).show
+---+----+
|key|vala|
+---+----+
|  a|   1|
|  b|   2|
+---+----+

Answer 4

La mejor práctica es hacer que el nombre de la columna sea diferente en ambos DF antes de unirse a ellos y soltarlos en consecuencia.

df1.columns = [id, edad, ingresos] df2.column = [id, age_group]

df1.join (df2, on = df1.id == df2.id, how = ''inner''). write.saveAsTable (''table_name'')

// devolverá el error mientras que el error para columnas duplicadas

// prueba esto

df1.join (df2.withColumnRenamed (''id'', ''id_2''), on = df1.id == df2.id_2, how = ''inner''). drop (''id_2'')

Answer 5

La respuesta simple (de las Preguntas frecuentes de Databricks sobre este asunto ) es realizar la unión donde las columnas unidas se expresan como una matriz de cadenas (o una cadena) en lugar de un predicado.

A continuación se muestra un ejemplo adaptado de las Preguntas frecuentes de Databricks, pero con dos columnas de unión para responder a la pregunta del póster original.

Aquí está el marco de datos izquierdo :

val llist = Seq(("bob", "b", "2015-01-13", 4), ("alice", "a", "2015-04-23",10))

val left = llist.toDF("firstname","lastname","date","duration")

left.show()

/*
+---------+--------+----------+--------+
|firstname|lastname|      date|duration|
+---------+--------+----------+--------+
|      bob|       b|2015-01-13|       4|
|    alice|       a|2015-04-23|      10|
+---------+--------+----------+--------+
*/

Aquí está el marco de datos correcto :

val right = Seq(("alice", "a", 100),("bob", "b", 23)).toDF("firstname","lastname","upload")

right.show()

/*
+---------+--------+------+
|firstname|lastname|upload|
+---------+--------+------+
|    alice|       a|   100|
|      bob|       b|    23|
+---------+--------+------+
*/

Aquí hay una solución incorrecta , donde las columnas de unión se definen como el predicado left("firstname")===right("firstname") && left("lastname")===right("lastname") .

El resultado incorrecto es que las columnas de nombre y lastname están duplicadas en el marco de datos unidos:

left.join(right, left("firstname")===right("firstname") &&
                 left("lastname")===right("lastname")).show

/*
+---------+--------+----------+--------+---------+--------+------+
|firstname|lastname|      date|duration|firstname|lastname|upload|
+---------+--------+----------+--------+---------+--------+------+
|      bob|       b|2015-01-13|       4|      bob|       b|    23|
|    alice|       a|2015-04-23|      10|    alice|       a|   100|
+---------+--------+----------+--------+---------+--------+------+
*/

La solución correcta es definir las columnas de unión como una matriz de cadenas Seq("firstname", "lastname") . El marco de datos de salida no tiene columnas duplicadas:

left.join(right, Seq("firstname", "lastname")).show

/*
+---------+--------+----------+--------+------+
|firstname|lastname|      date|duration|upload|
+---------+--------+----------+--------+------+
|      bob|       b|2015-01-13|       4|    23|
|    alice|       a|2015-04-23|      10|   100|
+---------+--------+----------+--------+------+
*/

Answer 6

Simplemente puedes usar esto

df1.join(df2, Seq("ts","id"),"TYPE-OF-JOIN")

Aquí puede ser TYPE-OF-JOIN

• izquierda
• derecho
• interior
• fullouter

Por ejemplo, tengo dos marcos de datos como este:

// df1
word   count1
w1     10   
w2     15  
w3     20

// df2
word   count2
w1     100   
w2     150  
w5     200

Si te unes a fullouter, entonces el resultado es así

df1.join(df2, Seq("word"),"fullouter").show()

word   count1  count2
w1     10      100
w2     15      150
w3     20      null
w5     null    200

Answer 7

prueba esto,

val df_combined = df1.join(df2, df1("ts") === df2("ts") && df1("id") === df2("id")).drop(df2("ts")).drop(df2("id"))