# Exploring Type Widening in Delta Lake 3.2.0: A Deep Dive

> Delta Lake 3.2.0 introduces type widening, a feature that simplifies schema evolution by allowing data type changes without rewriting data. This article explores how type widening works, its benefits, and common pitfalls to avoid.

**Category:** delta-lake  
**Published:** 2026-05-09T12:00:40.690038Z  
**Canonical:** https://allaboutspark.com/posts/exploring-type-widening-delta-lake-3-2-0
**Tags:** delta lake, schema evolution, type widening, data engineering

---

## Introduction to Type Widening in Delta Lake 3.2.0

Delta Lake 3.2.0 brings a host of new features aimed at enhancing performance and interoperability, but one of the most intriguing additions is type widening. This feature addresses a common challenge in data engineering: evolving data schemas. As data grows and changes, so too must the schemas that describe it. Type widening allows you to change the data type of a column to a wider type, such as evolving an `INT` column to a `LONG`, without the need to rewrite existing data[1][2]. This capability not only streamlines schema evolution but also ensures that data ingestion and processing remain seamless.

## Understanding Type Widening

Type widening in Delta Lake is designed to handle schema updates more gracefully by allowing certain data type changes automatically during write operations. This feature supports a limited set of type changes in Delta Lake 3.2.0, with more options available in later versions[2]. For instance, you can change a `byte` to a `short` or `int`, and an `int` to a `long` or `decimal`. However, some changes, such as promoting an integer to a `decimal` or `double`, must be done manually to avoid unintended data transformations[2].

The process of type widening can be enabled on a table by setting the `delta.enableTypeWidening` property to `true`. This can be done either during table creation or on an existing table[2]. Once enabled, type widening works in conjunction with schema evolution to automatically adjust data types during ingestion, provided certain conditions are met. These include having type widening enabled on the target table and ensuring the source column type is wider than the target column type[2].

## Walking Through Type Widening

Let's explore how you can implement type widening in a Delta Lake table. Suppose you have a table `fct_orders` with a column `order_id` of type `INT`, and you want to change it to `LONG` to accommodate larger values.

First, ensure that type widening is enabled on your table:

```sql
ALTER TABLE fct_orders SET TBLPROPERTIES ('delta.enableTypeWidening' = 'true');
```

With type widening enabled, you can now alter the column type:

```sql
ALTER TABLE fct_orders ALTER COLUMN order_id TYPE LONG;
```

This command updates the table schema without rewriting the underlying Parquet files, making the operation efficient and quick[2].

For automatic type widening during data ingestion, ensure that schema evolution is enabled in your write operations:

```python
from pyspark.sql import SparkSession

spark = SparkSession.builder \
    .appName("DeltaTypeWidening") \
    .config("spark.sql.extensions", "io.delta.sql.DeltaSparkSessionExtension") \
    .config("spark.sql.catalog.spark_catalog", "org.apache.spark.sql.delta.catalog.DeltaCatalog") \
    .getOrCreate()

# Assuming df is your DataFrame with a wider type for order_id
(df.write \
    .format("delta") \
    .mode("append") \
    .option("mergeSchema", "true") \
    .save("/path/to/fct_orders"))
```

In this example, the `mergeSchema` option allows the DataFrame's schema to be merged with the table schema, enabling type widening during the write operation[2].

## Common Mistakes and How to Avoid Them

While type widening simplifies schema evolution, there are pitfalls to be aware of. One common mistake is attempting to automatically widen types that require manual intervention, such as converting an `int` to a `decimal`. This can lead to data loss if not handled correctly, as Spark will truncate the fractional part of the values by default[2]. Always verify that the type change is supported automatically or apply it manually if necessary.

Another issue arises when type widening is not enabled on a table, leading to schema enforcement errors during write operations. Ensure that the `delta.enableTypeWidening` property is set to `true` before attempting any type changes.

## When to Use Type Widening

Type widening is particularly useful in scenarios where data schemas are expected to evolve over time, such as in ETL pipelines that ingest data from various sources with differing schemas. It allows for seamless integration and processing of data without the overhead of rewriting existing data.

However, it's not always the right tool. If your data types are stable and unlikely to change, the added complexity of managing type widening may not be justified. Additionally, for changes that involve significant data transformations, such as converting integers to decimals, manual intervention is required to ensure data integrity.

In conclusion, type widening in Delta Lake 3.2.0 offers a powerful mechanism for managing schema evolution efficiently. By understanding its capabilities and limitations, you can leverage this feature to maintain robust and adaptable data pipelines.[1][2][3]

---

## Sources

1. [Delta Lake 3.2 | Delta Lake](https://delta.io/blog/delta-lake-3-2/)
2. [Delta type widening | Delta Lake](https://docs.delta.io/delta-type-widening/)
3. [How does Delta Lake manage feature compatibility? | Delta Lake](https://docs.delta.io/versioning/)
4. [Storage configuration | Delta Lake](https://docs.delta.io/delta-storage/)
5. [Quick Start | Delta Lake](https://docs.delta.io/quick-start/)
6. [Drop Delta table features | Delta Lake](https://docs.delta.io/delta-drop-feature/)
7. [Releases | Delta Lake](https://docs.delta.io/releases/)
8. [Use row tracking for Delta tables | Delta Lake](https://docs.delta.io/delta-row-tracking/)