Delta Lake supports most of the options provided by Spark DataFrame read and write APIs for performing batch reads and writes on tables.
In this topic:
You can partition data to speed up queries or DML that have predicates involving the partition columns. To partition data when you create a Delta Lake table, specify partition by columns. A common pattern is to partition by date, for example:
You can load a Delta Lake table as a DataFrame by specifying a path:
Delta Lake time travel allows you to query an older snapshot of a Delta Lake table. Time travel has many use cases, including:
- Re-creating analyses, reports, or outputs (for example, the output of a machine learning model). This could be useful for debugging or auditing, especially in regulated industries.
- Writing complex temporal queries.
- Fixing mistakes in your data.
- Providing snapshot isolation for a set of queries for fast changing tables.
This section describes the supported methods for querying older versions of tables, data retention concerns, and provides examples.
There are several ways to query an older version of a Delta Lake table.
DataFrameReader options allow you to create a DataFrame from a Delta Lake table that is fixed to a specific version of the table.
df1 = spark.read.format("delta").option("timestampAsOf", timestamp_string).load("/delta/events") df2 = spark.read.format("delta").option("versionAsOf", version).load("/delta/events")
timestamp_string, only date or timestamp strings are accepted. For example,
A common pattern is to use the latest state of the Delta Lake table throughout the execution of a Databricks job to update downstream applications.
append mode you can atomically add new data to an existing Delta Lake table:
To atomically replace all of the data in a table, you can use
You can selectively overwrite only the data that matches predicates over partition columns. The following command atomically replaces the month of January with the data in
df.write .format("delta") .mode("overwrite") .option("replaceWhere", "date >= '2017-01-01' AND date <= '2017-01-31'") .save("/delta/events")
This sample code writes out the data in
df, validates that it all falls within the specified partitions, and performs an atomic replacement.
Unlike the file APIs in Apache Spark, Delta Lake remembers and enforces the schema of a table. This means that by default overwrites do not replace the schema of an existing table.
For Delta Lake support for updating tables, see Table Deletes, Updates, and Merges.
If you specify other options, such as
partitionBy, in combination with append mode, Delta Lake validates that they match and throws an error for any mismatch. When
partitionBy is not present, appends automatically follow the partitioning of the existing data.
Delta Lake can automatically update the schema of a table as part of a DML transaction (either appending or overwriting), and make the schema compatible with the data being written.
Columns that are present in the DataFrame but missing from the table are automatically added as part of a write transaction when either of the following is true:
The added columns are appended to the end of the struct they are present in. Case is preserved when appending a new column.
Columns that are
NullType are dropped from the DataFrame when writing into Delta (because Parquet doesn’t support
NullType), but are still stored in the schema. When a different data type is received for that column, Delta Lake merges the schema to the new data type. If we receive a
NullType for an existing column, we will keep the old schema, and drop the new column during the write.
NullType in streaming is not supported. Since you must set schemas when using streaming this should be very rare.
NullType is also not accepted for complex types such as
By default, overwriting the data in a table does not overwrite the schema. When overwriting a table using
replaceWhere, you may still want to override the schema of the data being written. You can choose to replace the schema and partitioning of the table by setting:
Delta Lake supports the creation of views on top of Delta Lake tables just like you might with a data source table.
The core challenge when you operate with views is resolving the schemas. If you alter a Delta Lake table schema, you must recreate derivative views to account for any additions to the schema. For instance, if you add a new column to a Delta Lake table, you must make sure that this column is available in the appropriate views built on top of that base table.