Escriba un solo archivo CSV usando spark-csv

Estoy usando https://github.com/databricks/spark-csv , estoy tratando de escribir un solo CSV, pero no puedo, está creando una carpeta.

Necesita una función Scala que tomará parámetros como la ruta y el nombre del archivo y escribirá ese archivo CSV.

Está creando una carpeta con varios archivos, porque cada partición se guarda individualmente. Si necesita un solo archivo de salida (aún en una carpeta), puede repartition(preferiblemente si los datos ascendentes son grandes, pero requieren una reproducción aleatoria):

df
   .repartition(1)
   .write.format("com.databricks.spark.csv")
   .option("header", "true")
   .save("mydata.csv")

o bien coalesce:

df
   .coalesce(1)
   .write.format("com.databricks.spark.csv")
   .option("header", "true")
   .save("mydata.csv")

marco de datos antes de guardar:

Todos los datos se escribirán en mydata.csv/part-00000. Antes de usar esta opción, asegúrese de comprender lo que está sucediendo y cuál es el costo de transferir todos los datos a un solo trabajador . Si utiliza un sistema de archivos distribuido con replicación, los datos se transferirán varias veces: primero se recuperarán a un solo trabajador y luego se distribuirán entre los nodos de almacenamiento.

Como alternativa se puede dejar el código tal como es y utiliza herramientas de uso general como cato HDFSgetmerge simplemente fusionar todas las partes después.

Si está ejecutando Spark con HDFS, he estado resolviendo el problema escribiendo archivos csv normalmente y aprovechando HDFS para realizar la fusión. Estoy haciendo eso en Spark (1.6) directamente:

import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.fs._

def merge(srcPath: String, dstPath: String): Unit =  {
   val hadoopConfig = new Configuration()
   val hdfs = FileSystem.get(hadoopConfig)
   FileUtil.copyMerge(hdfs, new Path(srcPath), hdfs, new Path(dstPath), true, hadoopConfig, null) 
   // the "true" setting deletes the source files once they are merged into the new output
}


val newData = << create your dataframe >>


val outputfile = "/user/feeds/project/outputs/subject"  
var filename = "myinsights"
var outputFileName = outputfile + "/temp_" + filename 
var mergedFileName = outputfile + "/merged_" + filename
var mergeFindGlob  = outputFileName

    newData.write
        .format("com.databricks.spark.csv")
        .option("header", "false")
        .mode("overwrite")
        .save(outputFileName)
    merge(mergeFindGlob, mergedFileName )
    newData.unpersist()

No recuerdo dónde aprendí este truco, pero podría funcionar para ti.

Puede que llegue un poco tarde al juego aquí, pero usar coalesce(1)o repartition(1)puede funcionar para conjuntos de datos pequeños, pero los conjuntos de datos grandes se colocarían todos en una partición en un nodo. Es probable que esto genere errores OOM o, en el mejor de los casos, que se procese lentamente.

Te sugiero que uses la FileUtil.copyMerge()función de la API de Hadoop. Esto fusionará las salidas en un solo archivo.

EDITAR : esto lleva efectivamente los datos al controlador en lugar de a un nodo ejecutor. Coalesce()Estaría bien si un solo ejecutor tiene más RAM para usar que el controlador.

EDIT 2 : copyMerge()se está eliminando en Hadoop 3.0. Consulte el siguiente artículo de desbordamiento de pila para obtener más información sobre cómo trabajar con la versión más reciente: ¿Cómo hacer CopyMerge en Hadoop 3.0?

Si está usando Databricks y puede colocar todos los datos en la RAM de un trabajador (y por lo tanto puede usar .coalesce(1)), puede usar dbfs para buscar y mover el archivo CSV resultante:

val fileprefix= "/mnt/aws/path/file-prefix"

dataset
  .coalesce(1)       
  .write             
//.mode("overwrite") // I usually don't use this, but you may want to.
  .option("header", "true")
  .option("delimiter","\t")
  .csv(fileprefix+".tmp")

val partition_path = dbutils.fs.ls(fileprefix+".tmp/")
     .filter(file=>file.name.endsWith(".csv"))(0).path

dbutils.fs.cp(partition_path,fileprefix+".tab")

dbutils.fs.rm(fileprefix+".tmp",recurse=true)

Si su archivo no cabe en la RAM del trabajador, puede considerar la sugerencia de chaotic3quilibrium de usar FileUtils.copyMerge () . No he hecho esto y aún no sé si es posible o no, por ejemplo, en S3.

Esta respuesta se basa en respuestas anteriores a esta pregunta, así como en mis propias pruebas del fragmento de código proporcionado. Lo publiqué originalmente en Databricks y lo estoy volviendo a publicar aquí.

La mejor documentación para la opción recursiva de rm de dbfs que he encontrado está en un foro de Databricks .

Una solución que funciona para S3 modificado de Minkymorgan.

Simplemente pase la ruta del directorio temporal particionado (con un nombre diferente al de la ruta final) como el srcPathúnico csv / txt final como destPath Especifique también deleteSourcesi desea eliminar el directorio original.

/**
* Merges multiple partitions of spark text file output into single file. 
* @param srcPath source directory of partitioned files
* @param dstPath output path of individual path
* @param deleteSource whether or not to delete source directory after merging
* @param spark sparkSession
*/
def mergeTextFiles(srcPath: String, dstPath: String, deleteSource: Boolean): Unit =  {
  import org.apache.hadoop.fs.FileUtil
  import java.net.URI
  val config = spark.sparkContext.hadoopConfiguration
  val fs: FileSystem = FileSystem.get(new URI(srcPath), config)
  FileUtil.copyMerge(
    fs, new Path(srcPath), fs, new Path(dstPath), deleteSource, config, null
  )
}

chispas df.write() API de Spark creará múltiples archivos de piezas dentro de la ruta dada ... para forzar a Spark escribir solo un archivo de una sola pieza, el uso en df.coalesce(1).write.csv(...)lugar de df.repartition(1).write.csv(...)coalesce es una transformación estrecha, mientras que la repartición es una transformación amplia, consulte Spark - repartition () vs coalesce ()

df.coalesce(1).write.csv(filepath,header=True) 

creará una carpeta en la ruta de archivo dada con un solo part-0001-...-c000.csvuso de archivo

cat filepath/part-0001-...-c000.csv > filename_you_want.csv 

tener un nombre de archivo fácil de usar

repartición / fusión en 1 partición antes de guardar (aún obtendría una carpeta pero tendría un archivo de parte)

puedes usar rdd.coalesce(1, true).saveAsTextFile(path)

almacenará los datos como un archivo individual en la ruta / part-00000

import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.fs._
import org.apache.spark.sql.{DataFrame,SaveMode,SparkSession}
import org.apache.spark.sql.functions._

Lo resolví usando el siguiente enfoque (hdfs renombrar el nombre del archivo): -

Paso 1: - (Crate Data Frame y escriba en HDFS)

df.coalesce(1).write.format("csv").option("header", "false").mode(SaveMode.Overwrite).save("/hdfsfolder/blah/")

Paso 2: - (Crear configuración de Hadoop)

val hadoopConfig = new Configuration()
val hdfs = FileSystem.get(hadoopConfig)

Paso 3: - (Obtener ruta en la ruta de la carpeta hdfs)

val pathFiles = new Path("/hdfsfolder/blah/")

Paso 4: - (Obtenga los nombres de los archivos Spark de la carpeta hdfs)

val fileNames = hdfs.listFiles(pathFiles, false)
println(fileNames)

setp5: - (crea una lista mutable de Scala para guardar todos los nombres de archivo y agregarlo a la lista)

    var fileNamesList = scala.collection.mutable.MutableList[String]()
    while (fileNames.hasNext) {
      fileNamesList += fileNames.next().getPath.getName
    }
    println(fileNamesList)

Paso 6: - (filtrar el orden de archivos _SUCESS de la lista de nombres de archivos scala)

    // get files name which are not _SUCCESS
    val partFileName = fileNamesList.filterNot(filenames => filenames == "_SUCCESS")

paso 7: - (convierta la lista de scala en una cadena y agregue el nombre de archivo deseado a la cadena de la carpeta hdfs y luego aplique el cambio de nombre)

val partFileSourcePath = new Path("/yourhdfsfolder/"+ partFileName.mkString(""))
    val desiredCsvTargetPath = new Path(/yourhdfsfolder/+ "op_"+ ".csv")
    hdfs.rename(partFileSourcePath , desiredCsvTargetPath)

Estoy usando esto en Python para obtener un solo archivo:

df.toPandas().to_csv("/tmp/my.csv", sep=',', header=True, index=False)

Esta respuesta amplía la respuesta aceptada, brinda más contexto y proporciona fragmentos de código que puede ejecutar en Spark Shell en su máquina.

Más contexto sobre la respuesta aceptada

La respuesta aceptada puede darle la impresión de que el código de muestra genera un solo mydata.csvarchivo y ese no es el caso. Demostremos:

val df = Seq("one", "two", "three").toDF("num")
df
  .repartition(1)
  .write.csv(sys.env("HOME")+ "/Documents/tmp/mydata.csv")

Esto es lo que se genera:

Documents/
  tmp/
    mydata.csv/
      _SUCCESS
      part-00000-b3700504-e58b-4552-880b-e7b52c60157e-c000.csv

NB mydata.csves una carpeta en la respuesta aceptada, ¡no es un archivo!

Cómo generar un solo archivo con un nombre específico

Podemos usar Spark-Daria para escribir un solo mydata.csvarchivo.

import com.github.mrpowers.spark.daria.sql.DariaWriters
DariaWriters.writeSingleFile(
    df = df,
    format = "csv",
    sc = spark.sparkContext,
    tmpFolder = sys.env("HOME") + "/Documents/better/staging",
    filename = sys.env("HOME") + "/Documents/better/mydata.csv"
)

Esto generará el archivo de la siguiente manera:

Documents/
  better/
    mydata.csv

Rutas S3

Deberá pasar las rutas s3a DariaWriters.writeSingleFilepara usar este método en S3:

DariaWriters.writeSingleFile(
    df = df,
    format = "csv",
    sc = spark.sparkContext,
    tmpFolder = "s3a://bucket/data/src",
    filename = "s3a://bucket/data/dest/my_cool_file.csv"
)

Ver aquí para obtener más información.

Evitar copyMerge

copyMerge se eliminó de Hadoop 3. La DariaWriters.writeSingleFileimplementación utiliza fs.rename, como se describe aquí . Spark 3 todavía usaba Hadoop 2 , por lo que las implementaciones de copyMerge funcionarán en 2020. No estoy seguro de cuándo Spark se actualizará a Hadoop 3, pero es mejor evitar cualquier enfoque de copyMerge que haga que su código se rompa cuando Spark actualice Hadoop.

Código fuente

Busque el DariaWritersobjeto en el código fuente de spark-daria si desea inspeccionar la implementación.

Implementación de PySpark

Es más fácil escribir un solo archivo con PySpark porque puede convertir el DataFrame en un Pandas DataFrame que se escribe como un solo archivo por defecto.

from pathlib import Path
home = str(Path.home())
data = [
    ("jellyfish", "JALYF"),
    ("li", "L"),
    ("luisa", "LAS"),
    (None, None)
]
df = spark.createDataFrame(data, ["word", "expected"])
df.toPandas().to_csv(home + "/Documents/tmp/mydata-from-pyspark.csv", sep=',', header=True, index=False)

Limitaciones

El DariaWriters.writeSingleFileenfoque Scala y el df.toPandas()enfoque Python solo funcionan para pequeños conjuntos de datos. Los conjuntos de datos enormes no se pueden escribir como archivos individuales. Escribir datos como un solo archivo no es óptimo desde la perspectiva del rendimiento porque los datos no se pueden escribir en paralelo.

al usar Listbuffer podemos guardar datos en un solo archivo:

import java.io.FileWriter
import org.apache.spark.sql.SparkSession
import scala.collection.mutable.ListBuffer
    val text = spark.read.textFile("filepath")
    var data = ListBuffer[String]()
    for(line:String <- text.collect()){
      data += line
    }
    val writer = new FileWriter("filepath")
    data.foreach(line => writer.write(line.toString+"\n"))
    writer.close()

Hay una forma más de usar Java

import java.io._

def printToFile(f: java.io.File)(op: java.io.PrintWriter => Unit) 
  {
     val p = new java.io.PrintWriter(f);  
     try { op(p) } 
     finally { p.close() }
  } 

printToFile(new File("C:/TEMP/df.csv")) { p => df.collect().foreach(p.println)}