¿Cómo agregar una columna constante en un Spark DataFrame?
Quiero agregar una columna en a DataFramecon algún valor arbitrario (que es el mismo para cada fila). Recibo un error cuando uso withColumnlo siguiente:
dt.withColumn('new_column', 10).head(5)
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-50-a6d0257ca2be> in <module>()
1 dt = (messages
2 .select(messages.fromuserid, messages.messagetype, floor(messages.datetime/(1000*60*5)).alias("dt")))
----> 3 dt.withColumn('new_column', 10).head(5)
/Users/evanzamir/spark-1.4.1/python/pyspark/sql/dataframe.pyc in withColumn(self, colName, col)
1166 [Row(age=2, name=u'Alice', age2=4), Row(age=5, name=u'Bob', age2=7)]
1167 """
-> 1168 return self.select('*', col.alias(colName))
1169
1170 @ignore_unicode_prefix
AttributeError: 'int' object has no attribute 'alias'
Parece que puedo engañar a la función para que funcione como quiero sumando y restando una de las otras columnas (para que sumen cero) y luego sumando el número que quiero (10 en este caso):
dt.withColumn('new_column', dt.messagetype - dt.messagetype + 10).head(5)
[Row(fromuserid=425, messagetype=1, dt=4809600.0, new_column=10),
Row(fromuserid=47019141, messagetype=1, dt=4809600.0, new_column=10),
Row(fromuserid=49746356, messagetype=1, dt=4809600.0, new_column=10),
Row(fromuserid=93506471, messagetype=1, dt=4809600.0, new_column=10),
Row(fromuserid=80488242, messagetype=1, dt=4809600.0, new_column=10)]
Esto es sumamente complicado, ¿verdad? ¿Supongo que hay una forma más legítima de hacer esto?
Chispa 2.2+
Spark 2.2 introduce typedLitsoporte Seq, Mapy Tuples( SPARK-19254 ) y se deben admitir las siguientes llamadas (Scala):
import org.apache.spark.sql.functions.typedLit
df.withColumn("some_array", typedLit(Seq(1, 2, 3)))
df.withColumn("some_struct", typedLit(("foo", 1, 0.3)))
df.withColumn("some_map", typedLit(Map("key1" -> 1, "key2" -> 2)))
Chispa 1.3+ ( lit), 1.4+ ( array, struct), 2.0+ ( map):
El segundo argumento para DataFrame.withColumndebería ser a, Columnpor lo que debes usar un literal:
from pyspark.sql.functions import lit
df.withColumn('new_column', lit(10))
Si necesita columnas complejas, puede construirlas usando bloques como array:
from pyspark.sql.functions import array, create_map, struct
df.withColumn("some_array", array(lit(1), lit(2), lit(3)))
df.withColumn("some_struct", struct(lit("foo"), lit(1), lit(.3)))
df.withColumn("some_map", create_map(lit("key1"), lit(1), lit("key2"), lit(2)))
Se pueden utilizar exactamente los mismos métodos en Scala.
import org.apache.spark.sql.functions.{array, lit, map, struct}
df.withColumn("new_column", lit(10))
df.withColumn("map", map(lit("key1"), lit(1), lit("key2"), lit(2)))
Para proporcionar nombres para structsusar aliasen cada campo:
df.withColumn(
"some_struct",
struct(lit("foo").alias("x"), lit(1).alias("y"), lit(0.3).alias("z"))
)
o casten todo el objeto
df.withColumn(
"some_struct",
struct(lit("foo"), lit(1), lit(0.3)).cast("struct<x: string, y: integer, z: double>")
)
También es posible, aunque más lento, utilizar una UDF.
Nota :
Se pueden utilizar las mismas construcciones para pasar argumentos constantes a UDF o funciones SQL.
En Spark 2.2 hay dos formas de agregar un valor constante en una columna en DataFrame:
1) Usandolit
2) Usando typedLit.
La diferencia entre los dos es que typedLittambién puede manejar tipos Scala parametrizados, por ejemplo, List, Seq y Map.
Marco de datos de muestra:
val df = spark.createDataFrame(Seq((0,"a"),(1,"b"),(2,"c"))).toDF("id", "col1")
+---+----+
| id|col1|
+---+----+
| 0| a|
| 1| b|
+---+----+
1) Usando lit: Agregar un valor de cadena constante en una nueva columna llamada newcol:
import org.apache.spark.sql.functions.lit
val newdf = df.withColumn("newcol",lit("myval"))
Resultado:
+---+----+------+
| id|col1|newcol|
+---+----+------+
| 0| a| myval|
| 1| b| myval|
+---+----+------+
2) Usando typedLit:
import org.apache.spark.sql.functions.typedLit
df.withColumn("newcol", typedLit(("sample", 10, .044)))
Resultado:
+---+----+-----------------+
| id|col1| newcol|
+---+----+-----------------+
| 0| a|[sample,10,0.044]|
| 1| b|[sample,10,0.044]|
| 2| c|[sample,10,0.044]|
+---+----+-----------------+
Como se han descrito en las otras respuestas, litse typedLitmuestra cómo agregar columnas constantes a DataFrames. lites una función importante de Spark que usará con frecuencia, pero no para agregar columnas constantes a DataFrames.
Normalmente lo utilizará litpara crear org.apache.spark.sql.Columnobjetos porque ese es el tipo de columna requerido por la mayoría de los archivos org.apache.spark.sql.functions.
Suponga que tiene un DataFrame con una some_datecolumna DateType y desea agregar una columna con los días entre el 31 de diciembre de 2020 y some_date.
Aquí está su marco de datos:
+----------+
| some_date|
+----------+
|2020-09-23|
|2020-01-05|
|2020-04-12|
+----------+
A continuación se explica cómo calcular los días hasta el final del año:
val diff = datediff(lit(Date.valueOf("2020-12-31")), col("some_date"))
df
.withColumn("days_till_yearend", diff)
.show()
+----------+-----------------+
| some_date|days_till_yearend|
+----------+-----------------+
|2020-09-23| 99|
|2020-01-05| 361|
|2020-04-12| 263|
+----------+-----------------+
También puedes usar litpara crear una year_endcolumna y calcular algo days_till_yearendasí:
import java.sql.Date
df
.withColumn("yearend", lit(Date.valueOf("2020-12-31")))
.withColumn("days_till_yearend", datediff(col("yearend"), col("some_date")))
.show()
+----------+----------+-----------------+
| some_date| yearend|days_till_yearend|
+----------+----------+-----------------+
|2020-09-23|2020-12-31| 99|
|2020-01-05|2020-12-31| 361|
|2020-04-12|2020-12-31| 263|
+----------+----------+-----------------+
La mayoría de las veces, no es necesario utilizar litpara agregar una columna constante a un DataFrame. Solo necesita usar litpara convertir un tipo Scala en un org.apache.spark.sql.Columnobjeto porque eso es lo que requiere la función.
Vea la datedifffirma de la función:
Como puede ver, datediffrequiere dos argumentos de columna.
