Apache Spark DataFrame में कॉनमेटेट कॉलम

Question

Apache Spark DataFrame में हम दो कॉलम कैसे जोड़ सकते हैं? क्या स्पार्क एसक्यूएल में कोई फ़ंक्शन है जिसका हम उपयोग कर सकते हैं?

Answer 1

कच्चे SQL के साथ आप उपयोग कर सकते हैं CONCAT:

• पायथन में

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

• स्काला में

  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")

स्पार्क 1.5.0 के बाद से आप concatडेटाफ़्रेम एपीआई के साथ फ़ंक्शन का उपयोग कर सकते हैं :

• पायथन में:

  from pyspark.sql.functions import concat, col, lit
  
  df.select(concat(col("k"), lit(" "), col("v")))

• स्काला में:

  import org.apache.spark.sql.functions.{concat, lit}
  
  df.select(concat($"k", lit(" "), $"v"))

concat_wsएक फ़ंक्शन भी है जो पहले तर्क के रूप में एक स्ट्रिंग विभाजक लेता है।

Answer 2

यहां बताया गया है कि आप कस्टम नामकरण कैसे कर सकते हैं

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()

देता है,

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

नया कॉलम बनाएं

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|
+--------+--------+-------------+

Comments

lit_

— muon

Answer 3

स्पार्क स्काला में स्ट्रिंग कॉलम को जोड़ने का एक विकल्प उपयोग कर रहा है concat।

अशक्त मूल्यों की जांच करना आवश्यक है । क्योंकि यदि स्तंभों में से एक शून्य है, तो परिणाम अन्य स्तंभों की जानकारी होने पर भी शून्य होगा।

उपयोग करना concatऔर 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"))))

उपयोग करना concatऔर select:

val newDf = df.selectExpr("concat(nvl(COL1, ''), nvl(COL2, '')) as NEW_COLUMN")

दोनों दृष्टिकोणों के साथ आपके पास एक NEW_COLUMN होगा जो मान कॉलम का एक संयोजन है: COL1 और COL2 आपके मूल df से।

Comments

मैंने pyspark में आपके तरीके की कोशिश की, लेकिन यह काम नहीं किया, चेतावनी दी कि "कोल कॉलम होना चाहिए"।

— सैमसन

@ सैमसन माफ करना, मैंने केवल

— स्कैला

@IgnacioAlorre यदि आप concat_wsइसके बजाय उपयोग कर रहे हैं concat, तो आप NULL के लिए जाँच से बच सकते हैं।

— अस्वत के

Answer 4

यदि आप इसे DF का उपयोग करके करना चाहते हैं, तो आप मौजूदा स्तंभों के आधार पर एक नया कॉलम जोड़ने के लिए udf का उपयोग कर सकते हैं।

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()

Answer 5

स्पार्क 2.3 ( स्पार्क -22771 ) से स्पार्क एसक्यूएल कॉन्टेक्टेशन ऑपरेटर को सपोर्ट करता है ||।

उदाहरण के लिए;

val df = spark.sql("select _c1 || _c2 as concat_column from <table_name>")

Answer 6

यहाँ 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|
+------------+

Answer 7

जब आप डेटाफ़्रेम में स्तंभों की संख्या या नाम नहीं जानते, तो इसके लिए एक सुझाव दिया गया है।

val dfResults = dfSource.select(concat_ws(",",dfSource.columns.map(c => col(c)): _*))

Answer 8

concat (* कॉलम)

v1.5 और उच्चतर

एक ही कॉलम में एक साथ कई इनपुट कॉलम को समेटता है। फ़ंक्शन स्ट्रिंग्स, बाइनरी और संगत सरणी कॉलम के साथ काम करता है।

उदाहरण के लिए: new_df = df.select(concat(df.a, df.b, df.c))

---

कॉन्कैट_व्स (एसईपी, * कोल्स)

v1.5 और उच्चतर

इसी तरह concatलेकिन निर्दिष्ट विभाजक का उपयोग करता है।

उदाहरण के लिए: new_df = df.select(concat_ws('-', df.col1, df.col2))

---

map_concat (* कॉलम)

v2.4 और उच्चतर

नक्शे को सम्‍मिलित करने के लिए उपयोग किया जाता है, सभी दिए गए मानचित्रों के मिलन को लौटाता है।

उदाहरण के लिए: new_df = df.select(map_concat("map1", "map2"))

---

स्ट्रिंग कॉनैट ऑपरेटर का उपयोग करना ( ||):

v2.3 और उच्चतर

उदाहरण के लिए: df = spark.sql("select col_a || col_b || col_c as abc from table_x")

संदर्भ: स्पार्क एसक्यूएल डॉक

Answer 9

स्पार्क 2.3.0 में, आप यह कर सकते हैं:

spark.sql( """ select '1' || column_a from table_a """)

Answer 10

जावा में आप कई कॉलम को समेटने के लिए ऐसा कर सकते हैं। नमूना कोड आपको एक परिदृश्य प्रदान करना है और बेहतर समझ के लिए इसका उपयोग कैसे करना है।

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;
    }
}

उपरोक्त कोड "_" से एक कॉलम बनाने के लिए, "_" द्वारा अलग किया गया col1, col2, col3 को "concatenatedCol" नाम से बनाया गया है।

Answer 11

क्या हमारे पास नीचे की प्रक्रिया के अनुरूप जावा सिंटैक्स है

val dfResults = dfSource.select(concat_ws(",",dfSource.columns.map(c => col(c)): _*))

Answer 12

एक और तरीका है इसे sqlContext का उपयोग करते हुए pySpark में ...

#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'))

Answer 13

वास्तव में, कस्टम फंक्शन को लागू करने की आवश्यकता के बिना आपके कॉन्फिडेंस को पूरा करने के लिए आपके लिए कुछ सुंदर इनबिल्ट एब्स्ट्रक्शन हैं। चूँकि आपने स्पार्क एसक्यूएल का उल्लेख किया है, इसलिए मैं अनुमान लगा रहा हूँ कि आप इसे स्पार्क के माध्यम से घोषित कमांड के रूप में पारित करने का प्रयास कर रहे हैं। एससीएल ()। यदि ऐसा है, तो आप SQL कमांड पास करते हुए सीधे आगे के तरीके से पूरा कर सकते हैं जैसे: SELECT CONCAT(col1, '<delimiter>', col2, ...) AS concat_column_name FROM <table_name>;

इसके अलावा, स्पार्क 2.3.0 से, आप निम्न पंक्तियों में कमांड का उपयोग कर सकते हैं: SELECT col1 || col2 AS concat_column_name FROM <table_name>;

जिसमें, आपका पसंदीदा परिसीमन है (खाली स्थान भी हो सकता है) और वह अस्थायी या स्थायी तालिका है जिसे आप पढ़ने की कोशिश कर रहे हैं।

Answer 14

हम साथ ही SelectExpr का सरल उपयोग कर सकते हैं। df1.selectExpr ("*", "ऊपरी (_2 || _3) नए के रूप में")