Clase DataFrameWriter

Interfaz usada para escribir un dataframe en sistemas de almacenamiento externos (por ejemplo, sistemas de archivos, almacenes de clave-valor, etc.).

Admite Spark Connect

Sintaxis

Use DataFrame.write para acceder a esta interfaz.

Methods

Método	Descripción
mode(saveMode)	Especifica el comportamiento cuando ya existen datos o tablas.
format(source)	Especifica el origen de datos de salida subyacente.
option(key, value)	Agrega una opción de salida para el origen de datos subyacente.
options(**options)	Agrega opciones de salida para el origen de datos subyacente.
partitionBy(*cols)	Divide la salida por las columnas especificadas en el sistema de archivos.
bucketBy(numBuckets, col, *cols)	Buckets the output by the given columns.
sortBy(col, *cols)	Ordena la salida en cada cubo por las columnas especificadas en el sistema de archivos.
clusterBy(*cols)	Agrupa los datos de las columnas especificadas para optimizar el rendimiento de las consultas.
save(path, format, mode, partitionBy, **options)	Guarda el contenido del dataFrame en un origen de datos.
insertInto(tableName, overwrite)	Inserta el contenido del DataFrame en la tabla especificada.
saveAsTable(name, format, mode, partitionBy, **options)	Guarda el contenido de DataFrame como la tabla especificada.
json(path, mode, compression, ...)	Guarda el contenido del dataframe en formato JSON en la ruta de acceso especificada.
parquet(path, mode, partitionBy, compression)	Guarda el contenido del DataFrame en formato Parquet en la ruta de acceso especificada.
text(path, compression, lineSep)	Guarda el contenido del DataFrame en un archivo de texto en la ruta de acceso especificada.
csv(path, mode, compression, sep, ...)	Guarda el contenido del dataframe en formato CSV en la ruta de acceso especificada.
xml(path, rowTag, mode, ...)	Guarda el contenido del dataframe en formato XML en la ruta de acceso especificada.
orc(path, mode, partitionBy, compression)	Guarda el contenido del DataFrame en formato ORC en la ruta de acceso especificada.
excel(path, mode, dataAddress, headerRows)	Guarda el contenido del DataFrame en formato de Excel en la ruta de acceso especificada.
jdbc(url, table, mode, properties)	Guarda el contenido de DataFrame en una tabla de base de datos externa mediante JDBC.

Modos de guardar

El mode() método admite las siguientes opciones:

• append: anexe el contenido de este DataFrame a los datos existentes.
• sobrescribir: sobrescribir los datos existentes.
• error o errorifexists: inicie una excepción si los datos ya existen (valor predeterminado).
• ignore: omita silenciosamente esta operación si los datos ya existen.

Ejemplos

Escribir en orígenes de datos diferentes

# Access DataFrameWriter through DataFrame
df = spark.createDataFrame([{"name": "Alice", "age": 30}])
df.write

# Write to JSON file
df.write.json("path/to/output.json")

# Write to CSV file with options
df.write.option("header", "true").csv("path/to/output.csv")

# Write to Parquet file
df.write.parquet("path/to/output.parquet")

# Write to a table
df.write.saveAsTable("table_name")

Uso de formato y guardado

# Specify format explicitly
df.write.format("json").save("path/to/output.json")

# With options
df.write.format("csv") \
    .option("header", "true") \
    .option("compression", "gzip") \
    .save("path/to/output.csv")

Especificar el modo de guardado

# Overwrite existing data
df.write.mode("overwrite").parquet("path/to/output.parquet")

# Append to existing data
df.write.mode("append").parquet("path/to/output.parquet")

# Ignore if data exists
df.write.mode("ignore").json("path/to/output.json")

# Error if data exists (default)
df.write.mode("error").csv("path/to/output.csv")

Creación de particiones de datos

# Partition by single column
df.write.partitionBy("year").parquet("path/to/output.parquet")

# Partition by multiple columns
df.write.partitionBy("year", "month").parquet("path/to/output.parquet")

# Partition with bucketing
df.write \
    .bucketBy(10, "id") \
    .sortBy("age") \
    .saveAsTable("bucketed_table")

Escribir en JDBC

# Write to database table
df.write.jdbc(
    url="jdbc:postgresql://localhost:5432/mydb",
    table="users",
    mode="overwrite",
    properties={"user": "myuser", "password": "mypassword"}
)

Encadenamiento de métodos

# Chain multiple configuration methods
df.write \
    .format("parquet") \
    .mode("overwrite") \
    .option("compression", "snappy") \
    .partitionBy("year", "month") \
    .save("path/to/output")

Escritura en tablas

# Save as managed table
df.write.saveAsTable("my_table")

# Save as managed table with options
df.write \
    .mode("overwrite") \
    .format("parquet") \
    .partitionBy("year") \
    .saveAsTable("partitioned_table")

# Insert into existing table
df.write.insertInto("existing_table")

# Insert into existing table with overwrite
df.write.insertInto("existing_table", overwrite=True)