Comment créer un DataFrame à partir d'un fichier texte dans Spark

J'ai un fichier texte sur HDFS et je veux le convertir en un bloc de Données dans Spark.

Je suis à l'aide de l'Étincelle Contexte de charger le fichier et essayez de générer les différentes colonnes à partir de ce fichier.

val myFile = sc.textFile("file.txt")
val myFile1 = myFile.map(x=>x.split(";"))

Après avoir fait cela, je suis en train de l'opération suivante.

myFile1.toDF()

Je suis un des problèmes puisque les éléments dans myFile1 RDD sont maintenant de type tableau.

Comment puis-je résoudre ce problème?

Je vous suggère de modifier la question du titre, afin de représenter la question avec plus de précision.
Pouvez-vous m'aider avec un titre adéquat? J'ai essayé de le garder aussi simple que je le peux.

OriginalL'auteur Rahul | 2016-04-21

14

Mise à jour - Étincelle de 1,6, vous pouvez simplement utiliser les données csv source:
```
spark: SparkSession = //create the Spark Session
val df = spark.read.csv("file.txt")
```
Vous pouvez également utiliser les options diverses pour contrôler le CSV de l'analyse, par exemple:
```
val df = spark.read.option("header", "false").csv("file.txt")
```
Pour Spark version < 1.6:
Le plus simple est d'utiliser spark-csv - l'inclure dans vos dépendances et suivre le README, il permet de définir un séparateur personnalisé (;), peut lire CSV en-têtes (si vous en avez), et il est possible de déduire le schéma types (avec le coût d'un contrôle supplémentaire des données).

Alternativement, si vous connaissez le schéma, vous pouvez créer un cas de classe qui la représente et de cartographier vos RDD éléments dans les instances de cette classe avant de se transformer en un DataFrame, par exemple:
```
case class Record(id: Int, name: String)

val myFile1 = myFile.map(x=>x.split(";")).map {
  case Array(id, name) => Record(id.toInt, name)
} 

myFile1.toDF() //DataFrame will have columns "id" and "name"
```
Merci beaucoup! Il a travaillé pour moi.

OriginalL'auteur Tzach Zohar

J'ai donné les différentes façons de créer DataFrame de fichier texte

val conf = new SparkConf().setAppName(appName).setMaster("local")
val sc = SparkContext(conf)

raw fichier texte

val file = sc.textFile("C:\\vikas\\spark\\Interview\\text.txt")
val fileToDf = file.map(_.split(",")).map{case Array(a,b,c) => 
(a,b.toInt,c)}.toDF("name","age","city")
fileToDf.foreach(println(_))

étincelle session sans schéma

import org.apache.spark.sql.SparkSession
val sparkSess = 
SparkSession.builder().appName("SparkSessionZipsExample")
.config(conf).getOrCreate()

val df = sparkSess.read.option("header", 
"false").csv("C:\\vikas\\spark\\Interview\\text.txt")
df.show()

étincelle session avec le schéma

import org.apache.spark.sql.types._
val schemaString = "name age city"
val fields = schemaString.split(" ").map(fieldName => StructField(fieldName, 
StringType, nullable=true))
val schema = StructType(fields)

val dfWithSchema = sparkSess.read.option("header", 
"false").schema(schema).csv("C:\\vikas\\spark\\Interview\\text.txt")
dfWithSchema.show()

à l'aide de sql contexte

import org.apache.spark.sql.SQLContext

val fileRdd = 
sc.textFile("C:\\vikas\\spark\\Interview\\text.txt").map(_.split(",")).map{x 
=> org.apache.spark.sql.Row(x:_*)}
val sqlDf = sqlCtx.createDataFrame(fileRdd,schema)
sqlDf.show()

OriginalL'auteur Vikas Singh

4

Si vous souhaitez utiliser le toDF méthode, vous devez convertir votre RDD de Array[String] dans un RDD d'une classe de cas. Par exemple, vous avez à faire:
```
case class Test(id:String,filed2:String)
val myFile = sc.textFile("file.txt")
val df= myFile.map( x => x.split(";") ).map( x=> Test(x(0),x(1)) ).toDF()
```
Merci pour votre réponse Marque. Il doit avoir une coche verte mais Tzach eu la même réponse qu'une fraction de seconde avant et j'ai fini par accepter sa solution. +1 pour votre aide.

OriginalL'auteur mgaido

val df = spark.read.textFile("abc.txt")

case class Abc (amount:Int, types: String, id:Int)  //columns and data types

val df2 = df.map(rec=>Amount(rec(0).toInt, rec(1), rec(2).toInt))
rdd2.printSchema

root
 |-- amount: integer (nullable = true)
 |-- types: string (nullable = true)
 |-- id: integer (nullable = true)

OriginalL'auteur Vishal

1

Vous ne serez pas en mesure de le convertir en bloc de données jusqu'à l'utilisation de la conversion implicite.
```
val sqlContext = new SqlContext(new SparkContext())

import sqlContext.implicits._
```
Après cela seulement, vous pouvez convertir cette trame de données
```
case class Test(id:String,filed2:String)
val myFile = sc.textFile("file.txt")
val df= myFile.map( x => x.split(";") ).map( x=> Test(x(0),x(1)) ).toDF()
```
Ce fut la clé, il n'est nulle part explicitement documentées.
Ses pas directement mentionné, mais vous pouvez trouver de référence ici .. spark.apache.org/docs/2.3.0/sql-programming-guide.html

OriginalL'auteur Abhijit

Je sais je suis très en retard pour répondre à cela, mais je suis venu avec une réponse différente:

val rdd = sc.textFile("/home/training/mydata/file.txt")

val text = rdd.map(lines=lines.split(",")).map(arrays=>(ararys(0),arrays(1))).toDF("id","name").show

OriginalL'auteur Ankita

Vous pouvez lire un fichier de disposer d'un RDD et ensuite affecter schéma. Deux façons courantes de création de schéma sont soit à l'aide d'un cas ou une catégorie d'objet de Schéma [mes préférences]. Suit la rapide des bouts de code que vous pouvez utiliser.

Classe de cas de l'approche

case class Test(id:String,name:String)
val myFile = sc.textFile("file.txt")
val df= myFile.map( x => x.split(";") ).map( x=> Test(x(0),x(1)) ).toDF()

Schéma Approche

import org.apache.spark.sql.types._
val schemaString = "id name"
val fields = schemaString.split(" ").map(fieldName => StructField(fieldName, StringType, nullable=true))
val schema = StructType(fields)

val dfWithSchema = sparkSess.read.option("header","false").schema(schema).csv("file.txt")
dfWithSchema.show()

La deuxième est ma préférée, depuis la classe de cas a une limitation de max 22 champs de et ce sera un problème si votre fichier comporte plus de 22 des champs!

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.