Concaténer des colonnes dans Apache Spark DataFrame

Comment concaténer deux colonnes dans un Apache Spark DataFrame?
Est-il une fonction dans Spark SQL que l'on peut utiliser?

Vous avez quelques réponses ici, simplement en demandant à être accepté 😉

InformationsquelleAutor Nipun | 2015-07-16

137

Avec raw SQL, vous pouvez utiliser CONCAT:

En Python

df = sqlContext.createDataFrame([("foo", 1), ("bar", 2)], ("k", "v"))
df.registerTempTable("df")
sqlContext.sql("SELECT CONCAT(k, ' ',  v) FROM df")

En Scala

import sqlContext.implicits._

val df = sc.parallelize(Seq(("foo", 1), ("bar", 2))).toDF("k", "v")
df.registerTempTable("df")
sqlContext.sql("SELECT CONCAT(k, ' ',  v) FROM df")

Depuis Étincelle 1.5.0 vous pouvez utiliser concat fonction avec DataFrame API:

En Python :

from pyspark.sql.functions import concat, col, lit

df.select(concat(col("k"), lit(" "), col("v")))

En Scala :

import org.apache.spark.sql.functions.{concat, lit}

df.select(concat($"k", lit(" "), $"v"))

Il est également concat_ws fonction qui prend une chaîne de caractères séparateur comme premier argument.

InformationsquelleAutor zero323

Voici comment vous pouvez faire la coutume de nommage

import pyspark
from pyspark.sql import functions as sf
sc = pyspark.SparkContext()
sqlc = pyspark.SQLContext(sc)
df = sqlc.createDataFrame([('row11','row12'), ('row21','row22')], ['colname1', 'colname2'])
df.show()

donne,

+--------+--------+
|colname1|colname2|
+--------+--------+
|   row11|   row12|
|   row21|   row22|
+--------+--------+

créer une nouvelle colonne en concaténant:

df = df.withColumn('joined_column', 
                    sf.concat(sf.col('colname1'),sf.lit('_'), sf.col('colname2')))
df.show()

+--------+--------+-------------+
|colname1|colname2|joined_column|
+--------+--------+-------------+
|   row11|   row12|  row11_row12|
|   row21|   row22|  row21_row22|
+--------+--------+-------------+

lit crée une colonne de _

InformationsquelleAutor muon

17

Une option pour concaténer des chaînes de colonnes dans Spark Scala est à l'aide de concat.

Il est nécessaire de vérifier les valeurs null. Parce que si l'une des colonnes est null, le résultat sera nul, même si l'un des autres colonnes ne possèdent de l'information.

À l'aide de concat et withColumn:
```
val newDf =
  df.withColumn(
    "NEW_COLUMN",
    concat(
      when(col("COL1").isNotNull, col("COL1")).otherwise(lit("null")),
      when(col("COL2").isNotNull, col("COL2")).otherwise(lit("null"))))
```
À l'aide de concat et select:
```
val newDf = df.selectExpr("concat(nvl(COL1, ''), nvl(COL2, '')) as NEW_COLUMN")
```
Avec les deux méthodes, vous aurez une NEW_COLUMN dont la valeur est une concaténation des colonnes: COL1 et COL2 d'origine df.

InformationsquelleAutor Ignacio Alorre

Si vous voulez le faire à l'aide de DF, vous pouvez utiliser une fonction pour ajouter une nouvelle colonne reposant sur des colonnes.

val sqlContext = new SQLContext(sc)
case class MyDf(col1: String, col2: String)

//here is our dataframe
val df = sqlContext.createDataFrame(sc.parallelize(
    Array(MyDf("A", "B"), MyDf("C", "D"), MyDf("E", "F"))
))

//Define a udf to concatenate two passed in string values
val getConcatenated = udf( (first: String, second: String) => { first + " " + second } )

//use withColumn method to add a new column called newColName
df.withColumn("newColName", getConcatenated($"col1", $"col2")).select("newColName", "col1", "col2").show()

InformationsquelleAutor Danish Shrestha

Ici est une autre manière de faire pour pyspark:

#import concat and lit functions from pyspark.sql.functions 
from pyspark.sql.functions import concat, lit

#Create your data frame
countryDF = sqlContext.createDataFrame([('Ethiopia',), ('Kenya',), ('Uganda',), ('Rwanda',)], ['East Africa'])

#Use select, concat, and lit functions to do the concatenation
personDF = countryDF.select(concat(countryDF['East Africa'], lit('n')).alias('East African'))

#Show the new data frame
personDF.show()

----------RESULT-------------------------

84
+------------+
|East African|
+------------+
|   Ethiopian|
|      Kenyan|
|     Ugandan|
|     Rwandan|
+------------+

InformationsquelleAutor Teddy Belay

6

De Spark 2.3(SPARK-22771) Spark SQL prend en charge l'opérateur de concaténation de ||.

Par exemple;
```
val df = spark.sql("select _c1 || _c2 as concat_column from <table_name>")
```
InformationsquelleAutor Krishas
5

Voici une suggestion pour quand vous ne connaissez pas le numéro ou le nom des colonnes dans le Dataframe.
```
val dfResults = dfSource.select(concat_ws(",",dfSource.columns.map(c => col(c)): _*))
```
InformationsquelleAutor wones0120
2

Spark 2.3.0, vous pouvez le faire:
```
spark.sql( """ select '1' || column_a from table_a """)
```
InformationsquelleAutor Charlie 木匠

Une autre façon de faire dans pySpark à l'aide de sqlContext...

#Suppose we have a dataframe:
df = sqlContext.createDataFrame([('row1_1','row1_2')], ['colname1', 'colname2'])

# Now we can concatenate columns and assign the new column a name 
df = df.select(concat(df.colname1, df.colname2).alias('joined_colname'))

InformationsquelleAutor Gur

En Java, vous pouvez le faire pour concaténer plusieurs colonnes. L'exemple de code est de vous fournir un scénario et comment l'utiliser pour une meilleure compréhension.

SparkSession spark = JavaSparkSessionSingleton.getInstance(rdd.context().getConf());
Dataset<Row> reducedInventory = spark.sql("select * from table_name")
                        .withColumn("concatenatedCol",
                                concat(col("col1"), lit("_"), col("col2"), lit("_"), col("col3")));


class JavaSparkSessionSingleton {
    private static transient SparkSession instance = null;

    public static SparkSession getInstance(SparkConf sparkConf) {
        if (instance == null) {
            instance = SparkSession.builder().config(sparkConf)
                    .getOrCreate();
        }
        return instance;
    }
}

Le code ci-dessus concaténées col1,col2,col3 séparés par des "_" pour créer une colonne avec le nom "concatenatedCol".

InformationsquelleAutor wandermonk

Vous devez vous connecter pour publier un commentaire.