Diyelim ki şöyle bir şey yapıyorum:

val df = sqlContext.load("com.databricks.spark.csv", Map("path" -> "cars.csv", "header" -> "true"))
df.printSchema()

root
 |-- year: string (nullable = true)
 |-- make: string (nullable = true)
 |-- model: string (nullable = true)
 |-- comment: string (nullable = true)
 |-- blank: string (nullable = true)

df.show()
year make  model comment              blank
2012 Tesla S     No comment
1997 Ford  E350  Go get one now th...

Ama gerçekten yearas istedim Int(ve belki de diğer bazı sütunları dönüştürmek).

Gelebileceğim en iyi şey

df.withColumn("year2", 'year.cast("Int")).select('year2 as 'year, 'make, 'model, 'comment, 'blank)
org.apache.spark.sql.DataFrame = [year: int, make: string, model: string, comment: string, blank: string]

bu biraz kıvrık.

R'den geliyorum ve yazmaya alışkınım, ör.

df2 <- df %>%
   mutate(year = year %>% as.integer,
          make = make %>% toupper)

Muhtemelen bir şey özlüyorum, çünkü Spark / Scala'da bunu yapmanın daha iyi bir yolu olmalı ...

Düzenleme: En yeni sürüm

Kıvılcım 2.x beri kullanabilirsiniz .withColumn. Dokümanları buradan kontrol edin:

https://spark.apache.org/docs/latest/api/scala/index.html#org.apache.spark.sql.Dataset@withColumn(colName:String,col:org.apache.spark.sql.Column) : org.apache.spark.sql.DataFrame

En eski cevap

Spark 1.4 sürümünden beri, sütunda DataType ile cast yöntemini uygulayabilirsiniz:

import org.apache.spark.sql.types.IntegerType
val df2 = df.withColumn("yearTmp", df.year.cast(IntegerType))
    .drop("year")
    .withColumnRenamed("yearTmp", "year")

Sql ifadeleri kullanıyorsanız şunları da yapabilirsiniz:

val df2 = df.selectExpr("cast(year as int) year", 
                        "make", 
                        "model", 
                        "comment", 
                        "blank")

Daha fazla bilgi için dokümanları kontrol edin: http://spark.apache.org/docs/1.6.0/api/scala/#org.apache.spark.sql.DataFrame

[EDIT: Mart 2016: oylar için teşekkürler! Gerçi gerçekten, bu şimdiye dayalı çözümler düşünmek, iyi cevap değil withColumn, withColumnRenamedve castmsemelman tarafından öne sürülen, Martin Senne ve diğerleri] daha basit ve temizdir.

Yaklaşımınızın iyi olduğunu düşünüyorum, bir Spark'ın DataFrame(değişmez) bir Satır RDD'si olduğunu hatırlayın , bu yüzden asla bir sütunu gerçekten değiştirmiyoruz , sadece DataFrameher seferinde yeni bir şema ile yeni oluşturuyoruz .

Aşağıdaki şemaya sahip orijinal bir df'niz olduğunu varsayarsak:

scala> df.printSchema
root
 |-- Year: string (nullable = true)
 |-- Month: string (nullable = true)
 |-- DayofMonth: string (nullable = true)
 |-- DayOfWeek: string (nullable = true)
 |-- DepDelay: string (nullable = true)
 |-- Distance: string (nullable = true)
 |-- CRSDepTime: string (nullable = true)

Ve bir veya birkaç sütunda tanımlanan bazı UDF'ler:

import org.apache.spark.sql.functions._

val toInt    = udf[Int, String]( _.toInt)
val toDouble = udf[Double, String]( _.toDouble)
val toHour   = udf((t: String) => "%04d".format(t.toInt).take(2).toInt ) 
val days_since_nearest_holidays = udf( 
  (year:String, month:String, dayOfMonth:String) => year.toInt + 27 + month.toInt-12
 )

Sütun türlerini değiştirmek, hatta diğerinden yeni bir DataFrame oluşturmak şu şekilde yazılabilir:

val featureDf = df
.withColumn("departureDelay", toDouble(df("DepDelay")))
.withColumn("departureHour",  toHour(df("CRSDepTime")))
.withColumn("dayOfWeek",      toInt(df("DayOfWeek")))              
.withColumn("dayOfMonth",     toInt(df("DayofMonth")))              
.withColumn("month",          toInt(df("Month")))              
.withColumn("distance",       toDouble(df("Distance")))              
.withColumn("nearestHoliday", days_since_nearest_holidays(
              df("Year"), df("Month"), df("DayofMonth"))
            )              
.select("departureDelay", "departureHour", "dayOfWeek", "dayOfMonth", 
        "month", "distance", "nearestHoliday")            

hangi verir:

scala> df.printSchema
root
 |-- departureDelay: double (nullable = true)
 |-- departureHour: integer (nullable = true)
 |-- dayOfWeek: integer (nullable = true)
 |-- dayOfMonth: integer (nullable = true)
 |-- month: integer (nullable = true)
 |-- distance: double (nullable = true)
 |-- nearestHoliday: integer (nullable = true)

Bu, kendi çözümünüze oldukça yakın. Basitçe, tür değişikliklerini ve diğer dönüşümleri ayrı olarak tutmak udf valkodu daha okunabilir ve yeniden kullanılabilir hale getirir.

Gibi castoperasyon Spark için kullanılabilir Column'ın (ve şahsen lehine değil olarak udf' @ tarafından önerilen s Svendbu noktada), hakkında:

df.select( df("year").cast(IntegerType).as("year"), ... )

İstenen tipte yayınlamak için? Düzgün bir yan etki olarak, bu anlamda dökülebilir / "dönüştürülemez" değerler olur null.

Buna yardımcı bir yöntem olarak ihtiyacınız olması durumunda şunları kullanın:

object DFHelper{
  def castColumnTo( df: DataFrame, cn: String, tpe: DataType ) : DataFrame = {
    df.withColumn( cn, df(cn).cast(tpe) )
  }
}

hangi gibi kullanılır:

import DFHelper._
val df2 = castColumnTo( df, "year", IntegerType )

İlk olarak , yazı yazmak istiyorsanız, o zaman bu:

import org.apache.spark.sql
df.withColumn("year", $"year".cast(sql.types.IntegerType))

Aynı sütun adıyla, sütun yenisiyle değiştirilir. Adım ekleme ve silme işlemi yapmanız gerekmez.

İkinci hakkında Scala vs R .
Bu, RI'ye en çok benzeyen koddur:

val df2 = df.select(
   df.columns.map {
     case year @ "year" => df(year).cast(IntegerType).as(year)
     case make @ "make" => functions.upper(df(make)).as(make)
     case other         => df(other)
   }: _*
)

Kod uzunluğu R'lerden biraz daha uzun olmasına rağmen. Bu dilin ayrıntı düzeyi ile ilgisi yoktur. R ise mutate, R dataframe için özel bir fonksiyon ise Scala onun ifade gücü kolayca ad-hoc bir teşekkür yapabilirsiniz.
Kelime olarak, belirli çözümlerden kaçınır, çünkü dil tasarımı, kendi etki alanı dilinizi hızlı ve kolay bir şekilde oluşturmanıza yetecek kadar iyidir.

yan not: df.columnsşaşırtıcı bir şekilde Array[String]bunun yerine Array[Column], belki de Python pandaların veri çerçevesine benzemesini istiyorlar.

selectExprBiraz daha temiz hale getirmek için kullanabilirsiniz :

df.selectExpr("cast(year as int) as year", "upper(make) as make",
    "model", "comment", "blank")

DataFrame'in veri tipini String'den Integer'a değiştirmek için Java kodu

df.withColumn("col_name", df.col("col_name").cast(DataTypes.IntegerType))

Sadece (String veri tipi) tamsayıya yayınlanacaktır.

Yılı dizeden int'e dönüştürmek için csv okuyucuya aşağıdaki seçeneği ekleyebilirsiniz: "inferSchema" -> "true", bkz. DataBricks belgeleri

Bu sadece gerçekten sqlserver gibi bir jdbc sürücüsüne kaydetme sorunları yaşıyorsanız çalışır, ancak sözdizimi ve türleri ile karşılaşacağınız hatalar için gerçekten yararlıdır.

import org.apache.spark.sql.jdbc.{JdbcDialects, JdbcType, JdbcDialect}
import org.apache.spark.sql.jdbc.JdbcType
val SQLServerDialect = new JdbcDialect {
  override def canHandle(url: String): Boolean = url.startsWith("jdbc:jtds:sqlserver") || url.contains("sqlserver")

  override def getJDBCType(dt: DataType): Option[JdbcType] = dt match {
    case StringType => Some(JdbcType("VARCHAR(5000)", java.sql.Types.VARCHAR))
    case BooleanType => Some(JdbcType("BIT(1)", java.sql.Types.BIT))
    case IntegerType => Some(JdbcType("INTEGER", java.sql.Types.INTEGER))
    case LongType => Some(JdbcType("BIGINT", java.sql.Types.BIGINT))
    case DoubleType => Some(JdbcType("DOUBLE PRECISION", java.sql.Types.DOUBLE))
    case FloatType => Some(JdbcType("REAL", java.sql.Types.REAL))
    case ShortType => Some(JdbcType("INTEGER", java.sql.Types.INTEGER))
    case ByteType => Some(JdbcType("INTEGER", java.sql.Types.INTEGER))
    case BinaryType => Some(JdbcType("BINARY", java.sql.Types.BINARY))
    case TimestampType => Some(JdbcType("DATE", java.sql.Types.DATE))
    case DateType => Some(JdbcType("DATE", java.sql.Types.DATE))
    //      case DecimalType.Fixed(precision, scale) => Some(JdbcType("NUMBER(" + precision + "," + scale + ")", java.sql.Types.NUMERIC))
    case t: DecimalType => Some(JdbcType(s"DECIMAL(${t.precision},${t.scale})", java.sql.Types.DECIMAL))
    case _ => throw new IllegalArgumentException(s"Don't know how to save ${dt.json} to JDBC")
  }
}

JdbcDialects.registerDialect(SQLServerDialect)

Beş değer ve dönüştürmek içeren basit bir veri kümesi oluşturmak intiçin stringtip:

val df = spark.range(5).select( col("id").cast("string") )

Bunun benim için çok daha okunabilir olduğunu düşünüyorum.

import org.apache.spark.sql.types._
df.withColumn("year", df("year").cast(IntegerType))

Bu, yıl sütununuzu IntegerTypegeçici sütunlar oluşturarak ve bu sütunları bırakarak dönüştürecektir . Başka bir veri tipine dönüştürmek istiyorsanız, org.apache.spark.sql.typespaketin içindeki türleri kontrol edebilirsiniz .

1.4.1 kıvılcımında döküm, FYI, döküm yönteminin kullanılmasını öneren cevaplar bozuldu.

örneğin, bigint'e yayınlandığında "8182175552014127960" değerine sahip bir dize sütunu olan bir veri çerçevesi "8182175552014128100" değerine sahipse

    df.show
+-------------------+
|                  a|
+-------------------+
|8182175552014127960|
+-------------------+

    df.selectExpr("cast(a as bigint) a").show
+-------------------+
|                  a|
+-------------------+
|8182175552014128100|
+-------------------+

Bu hatayı bulmadan önce birçok sorunla karşı karşıya kaldık çünkü üretimde bigint sütunlarımız vardı.

df.select($"long_col".cast(IntegerType).as("int_col"))

Spark Sql 2.4.0 kullanarak şunları yapabilirsiniz:

spark.sql("SELECT STRING(NULLIF(column,'')) as column_string")

Aşağıdaki kodu kullanabilirsiniz.

df.withColumn("year", df("year").cast(IntegerType))

Yıl sütununu sütuna dönüştürür IntegerType.

Bu yöntem eski sütunu bırakır ve aynı değerlere ve yeni veri türüne sahip yeni sütunlar oluşturur. DataFrame oluşturulduğunda orijinal veri türlerim: -

root
 |-- id: integer (nullable = true)
 |-- flag1: string (nullable = true)
 |-- flag2: string (nullable = true)
 |-- name: string (nullable = true)
 |-- flag3: string (nullable = true)

Bundan sonra ben veri türünü değiştirmek için aşağıdaki kodu koştu: -

df=df.withColumnRenamed(<old column name>,<dummy column>) // This was done for both flag1 and flag3
df=df.withColumn(<old column name>,df.col(<dummy column>).cast(<datatype>)).drop(<dummy column>)

Bundan sonra sonucum şu şekilde çıktı: -

root
 |-- id: integer (nullable = true)
 |-- flag2: string (nullable = true)
 |-- name: string (nullable = true)
 |-- flag1: boolean (nullable = true)
 |-- flag3: boolean (nullable = true)

Spark sql'de döküm kullanarak bir sütunun veri türünü değiştirebilirsiniz. tablo adı tablodur ve yalnızca iki sütun vardır sütun1 ve sütun2 ve sütun1 veri türü değiştirilir. ex-spark.sql ("cast (çift olarak sütun1) column1NewName, tablodan sütun2'yi seçin") Veri türünüzü iki kez yazın.

Adlarıyla verilen düzinelerce sütunu yeniden adlandırmanız gerekirse, aşağıdaki örnek @dnlbrky yaklaşımını alır ve aynı anda birkaç sütuna uygular:

df.selectExpr(df.columns.map(cn => {
    if (Set("speed", "weight", "height").contains(cn)) s"cast($cn as double) as $cn"
    else if (Set("isActive", "hasDevice").contains(cn)) s"cast($cn as boolean) as $cn"
    else cn
}):_*)

Yayınlanmamış sütunlar değiştirilmez. Tüm sütunlar orijinal sıralarında kalır.

Çok fazla cevap ve çok ayrıntılı açıklamalar yok

Aşağıdaki sözdizimi çalışır Databricks Notebook'u Spark 2.4 ile kullanma

from pyspark.sql.functions import *
df = df.withColumn("COL_NAME", to_date(BLDFm["LOAD_DATE"], "MM-dd-yyyy"))

Sahip olduğunuz giriş biçimini belirtmeniz gerektiğini (benim durumumda "AA-gg-yyyy") ve to_date bir kıvılcım sql işlevi olduğundan içe aktarmanın zorunlu olduğunu unutmayın.

Ayrıca bu sözdizimini denedim, ancak uygun bir döküm yerine null değerleri var:

df = df.withColumn("COL_NAME", df["COL_NAME"].cast("Date"))

(Not Sözdizimsel olarak doğru olması için parantez ve tırnak kullanmak zorundayım)


PS: Bu bir sözdizimi orman gibi olduğunu itiraf etmeliyim, giriş noktaları birçok olası yolları vardır ve resmi API referansları uygun örnekler eksik.

Başka bir çözüm aşağıdaki gibidir:

1) "inferSchema" yı Yanlış olarak saklayın

2) Satırdaki 'Harita' işlevlerini çalıştırırken, 'asString'i (row.getString ...) okuyabilirsiniz.

//Read CSV and create dataset
Dataset<Row> enginesDataSet = sparkSession
            .read()
            .format("com.databricks.spark.csv")
            .option("header", "true")
            .option("inferSchema","false")
            .load(args[0]);

JavaRDD<Box> vertices = enginesDataSet
            .select("BOX","BOX_CD")
            .toJavaRDD()
            .map(new Function<Row, Box>() {
                @Override
                public Box call(Row row) throws Exception {
                    return new Box((String)row.getString(0),(String)row.get(1));
                }
            });

Neden sadece http://spark.apache.org/docs/latest/api/python/pyspark.sql.html#pyspark.sql.Column.cast altında açıklandığı gibi yapmıyorsunuz?

df.select(df.year.cast("int"),"make","model","comment","blank")

    val fact_df = df.select($"data"(30) as "TopicTypeId", $"data"(31) as "TopicId",$"data"(21).cast(FloatType).as( "Data_Value_Std_Err")).rdd
    //Schema to be applied to the table
    val fact_schema = (new StructType).add("TopicTypeId", StringType).add("TopicId", StringType).add("Data_Value_Std_Err", FloatType)

    val fact_table = sqlContext.createDataFrame(fact_df, fact_schema).dropDuplicates()

Diğer yol:

// Generate a simple dataset containing five values and convert int to string type

val df = spark.range(5).select( col("id").cast("string")).withColumnRenamed("id","value")

Tek bir sütun adı belirtmeden belirli bir türde birden çok sütunu diğerine değiştirmek istiyorsanız

/* Get names of all columns that you want to change type. 
In this example I want to change all columns of type Array to String*/
    val arrColsNames = originalDataFrame.schema.fields.filter(f => f.dataType.isInstanceOf[ArrayType]).map(_.name)

//iterate columns you want to change type and cast to the required type
val updatedDataFrame = arrColsNames.foldLeft(originalDataFrame){(tempDF, colName) => tempDF.withColumn(colName, tempDF.col(colName).cast(DataTypes.StringType))}

//display

updatedDataFrame.show(truncate = false)