Dela via

DataFrameWriter-klass

Gränssnitt som används för att skriva en DataFrame till externa lagringssystem (t.ex. filsystem, nyckelvärdeslager osv.).

Stöder Spark Connect

Syntax

Använd DataFrame.write för att komma åt det här gränssnittet.

Methods

Metod Beskrivning
mode(saveMode) Anger beteendet när data eller tabell redan finns.
format(source) Anger den underliggande utdatakällan.
option(key, value) Lägger till ett utdataalternativ för den underliggande datakällan.
options(**options) Lägger till utdataalternativ för den underliggande datakällan.
partitionBy(*cols) Partitioner utdata av de angivna kolumnerna i filsystemet.
bucketBy(numBuckets, col, *cols) Bucketar utdata från de angivna kolumnerna.
sortBy(col, *cols) Sorterar utdata i varje bucket efter de angivna kolumnerna i filsystemet.
clusterBy(*cols) Klusslar data efter de angivna kolumnerna för att optimera frågeprestanda.
save(path, format, mode, partitionBy, **options) Sparar innehållet i DataFrame till en datakälla.
insertInto(tableName, overwrite) Infogar innehållet i DataFrame i den angivna tabellen.
saveAsTable(name, format, mode, partitionBy, **options) Sparar innehållet i DataFrame som den angivna tabellen.
json(path, mode, compression, ...) Sparar innehållet i DataFrame i JSON-format på den angivna sökvägen.
parquet(path, mode, partitionBy, compression) Sparar innehållet i DataFrame i Parquet-format på den angivna sökvägen.
text(path, compression, lineSep) Sparar innehållet i DataFrame i en textfil på den angivna sökvägen.
csv(path, mode, compression, sep, ...) Sparar innehållet i DataFrame i CSV-format på den angivna sökvägen.
xml(path, rowTag, mode, ...) Sparar innehållet i DataFrame i XML-format på den angivna sökvägen.
orc(path, mode, partitionBy, compression) Sparar innehållet i DataFrame i ORC-format på den angivna sökvägen.
excel(path, mode, dataAddress, headerRows) Sparar innehållet i DataFrame i Excel-format på den angivna sökvägen.
jdbc(url, table, mode, properties) Sparar innehållet i DataFrame i en extern databastabell via JDBC.

Spara lägen

Metoden mode() stöder följande alternativ:

  • tillägg: Lägg till innehållet i dataramen till befintliga data.
  • skriv över: Skriv över befintliga data.
  • error or errorifexists: Throw an exception if data already exists (standard).
  • ignorera: Ignorera den här åtgärden tyst om det redan finns data.

Exempel

Skriva till olika datakällor

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

Använda format och spara

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

Ange spara läge

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

Partitionering av data

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

Skriva till JDBC

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

Metodlänkning

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

Skriva till tabeller

# 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