Freigeben über

DataFrameWriter-Klasse

Schnittstelle zum Schreiben eines DataFrames in externe Speichersysteme (z. B. Dateisysteme, Schlüsselwertspeicher usw.).

Unterstützt Spark Connect

Syntax

Wird DataFrame.write verwendet, um auf diese Schnittstelle zuzugreifen.

Methodik

Methode Beschreibung
mode(saveMode) Gibt das Verhalten an, wenn Daten oder Tabellen bereits vorhanden sind.
format(source) Gibt die zugrunde liegende Ausgabedatenquelle an.
option(key, value) Fügt eine Ausgabeoption für die zugrunde liegende Datenquelle hinzu.
options(**options) Fügt Ausgabeoptionen für die zugrunde liegende Datenquelle hinzu.
partitionBy(*cols) Partitioniert die Ausgabe durch die angegebenen Spalten im Dateisystem.
bucketBy(numBuckets, col, *cols) Buckets the output by the given columns.
sortBy(col, *cols) Sortiert die Ausgabe in jedem Bucket nach den angegebenen Spalten im Dateisystem.
clusterBy(*cols) Gruppiert die Daten nach den angegebenen Spalten, um die Abfrageleistung zu optimieren.
save(path, format, mode, partitionBy, **options) Speichert den Inhalt des DataFrame in einer Datenquelle.
insertInto(tableName, overwrite) Fügt den Inhalt des DataFrame in die angegebene Tabelle ein.
saveAsTable(name, format, mode, partitionBy, **options) Speichert den Inhalt des DataFrame als angegebene Tabelle.
json(path, mode, compression, ...) Speichert den Inhalt des DataFrame im JSON-Format am angegebenen Pfad.
parquet(path, mode, partitionBy, compression) Speichert den Inhalt des DataFrame im Parkettformat am angegebenen Pfad.
text(path, compression, lineSep) Speichert den Inhalt des DataFrame in einer Textdatei im angegebenen Pfad.
csv(path, mode, compression, sep, ...) Speichert den Inhalt des DataFrame im CSV-Format am angegebenen Pfad.
xml(path, rowTag, mode, ...) Speichert den Inhalt des DataFrame im XML-Format am angegebenen Pfad.
orc(path, mode, partitionBy, compression) Speichert den Inhalt des DataFrame im ORC-Format am angegebenen Pfad.
excel(path, mode, dataAddress, headerRows) Speichert den Inhalt des DataFrame im Excel-Format am angegebenen Pfad.
jdbc(url, table, mode, properties) Speichert den Inhalt des DataFrames über VORGANG in einer externen Datenbanktabelle.

Speichermodi

Die mode() Methode unterstützt die folgenden Optionen:

  • append: Append contents of this DataFrame to existing data.
  • überschreiben: Überschreiben vorhandener Daten.
  • error or errorifexists: Throw an exception if data already exists (default).
  • ignorieren: Ignorieren Sie diesen Vorgang im Hintergrund, wenn bereits Daten vorhanden sind.

Beispiele

Schreiben in verschiedene Datenquellen

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

Verwenden von Format und Speichern

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

Angeben des Speichermodus

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

Partitionieren von Daten

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

Schreiben an TEXT

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

Methodenketten

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

Schreiben in Tabellen

# 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)
  • Last updated on