From 27ff62c56bd7e4cef924ca18041823dce4db5bcc Mon Sep 17 00:00:00 2001 From: Andrew Lamb Date: Tue, 10 Nov 2026 12:50:44 -0500 Subject: [PATCH] Draft blog post for DataFusion 56.0.0 release Co-Authored-By: Claude Fable 5.2 --- content/blog/2026-11-10-datafusion-56.0.0.md | 615 +++++++++++++++++++ 1 file changed, 615 insertions(+) create mode 100644 content/blog/2026-11-10-datafusion-56.0.0.md diff --git a/content/blog/2026-11-10-datafusion-56.0.0.md b/content/blog/2026-11-10-datafusion-56.0.0.md new file mode 100644 index 00000000..fb84adbd --- /dev/null +++ b/content/blog/2026-11-10-datafusion-56.0.0.md @@ -0,0 +1,615 @@ +--- +layout: post +title: Apache DataFusion 56.0.0 Released +date: 2026-11-10 +author: pmc +categories: [release] +--- + + + +[TOC] + + + +We are proud to announce the release of [DataFusion 56.0.0]. This post +highlights some of the many improvements since [DataFusion 55.0.0], such as +`ASOF` joins, SQL registration of external catalogs, Avro and ALP write support, +better support for extension types such as `UUID`, Variant, and geospatial +types, and many performance and stability improvements. The complete list of +changes is available in the [changelog]. This release represents roughly 11 +weeks of development and 1200 commits. Thanks to the [247 contributors] (another +new record!) for making it possible. + +[DataFusion 56.0.0]: https://crates.io/crates/datafusion/56.0.0 +[DataFusion 55.0.0]: https://datafusion.apache.org/blog/2026/08/25/datafusion-55.0.0/ +[changelog]: https://github.com/apache/datafusion/blob/branch-56/dev/changelog/56.0.0.md +[247 contributors]: https://github.com/apache/datafusion/blob/branch-56/dev/changelog/56.0.0.md#credits + + + +## New Features โœจ + +### `ASOF` Joins + +DataFusion 56 adds `ASOF JOIN`, closing [#318], one of the oldest open feature +requests in the project. An `ASOF` join matches each row on the left with the +*closest* row on the right rather than requiring an exact match. Such joins are +ubiquitous in time-series workloads: finding the most recent quote for each +trade, or aligning two sensors that sample at different rates. + +DataFusion follows the [Snowflake `ASOF JOIN` syntax]. For example, to find the +most recent price at or before each trade: + +```sql +SELECT t.symbol, t.ts, t.quantity, p.price +FROM trades AS t +ASOF JOIN prices AS p +MATCH_CONDITION (t.ts >= p.ts) +ON t.symbol = p.symbol; +``` + + + +The `MATCH_CONDITION` selects which row is "closest" and supports `>=`, `>`, +`<=`, and `<`, so you can look backwards or forwards in time. The optional `ON` +(or `USING`) clause restricts matches to rows with equal keys, such as the same +`symbol`. Every left row is preserved, and the right columns are `NULL` when no +match is found. `ASOF` joins are also available in the DataFrame API ([#23831]). + +This first version requires the right input to fit in memory; see the +[`ASOF JOIN` documentation] for the full semantics and current limitations. +Thanks to [@Xuanwo] for driving this long-awaited feature from design through +implementation, and to [@jayzhan211] and [@Kristofferjoha] for follow-on +improvements. + +[Snowflake `ASOF JOIN` syntax]: https://docs.snowflake.com/en/sql-reference/constructs/asof-join +[`ASOF JOIN` documentation]: https://datafusion.apache.org/user-guide/sql/select.html#asof-join + +### Extension Types: `UUID`, `JSON`, and More + +[Arrow extension types] let systems attach a logical type, such as UUID, JSON, +Variant, or a geometry, to a column stored using one of the standard Arrow +physical types. Building on the foundations described in +[Implementing User Defined Types and Custom Metadata in DataFusion], DataFusion +56 makes extension types work far better end to end: + +- **`UUID` and `JSON` SQL types**: the SQL types `UUID` and `JSON` now map to + the Arrow [canonical extension types] `arrow.uuid` and `arrow.json` + ([#21714]). +- **Readable type names**: `DESCRIBE`, `SHOW COLUMNS`, and + `information_schema.columns` show the extension type name rather than the + storage type ([#26893]). +- **Parquet files keep their types**: columns with extension types in Parquet + files are now read as that extension type with the default settings + ([#26854]). +- **Types survive queries**: extension types are now preserved through casts + ([#23169]), `min` / `max` ([#26939]), `coalesce` ([#24865]), scalar + subqueries ([#24939]), and `INSERT` ([#24971]). + +For example, a `UUID` column now looks like a `UUID`, rather than a 16 byte +binary column: + +```sql +> CREATE TABLE users (id UUID, name VARCHAR); +> DESCRIBE users; ++-------------+-----------+-------------+ +| column_name | data_type | is_nullable | ++-------------+-----------+-------------+ +| id | UUID | YES | +| name | Utf8View | YES | ++-------------+-----------+-------------+ +``` + + + +Thanks to [@cblp], [@cyberbeam524], [@paleolimbot], [@james-willis], +[@M-Tesla], and [@osipovartem] for this work. + +The more important consequence is that the DataFusion ecosystem can now add +entirely new data types *without* changes to the DataFusion core, as the next +two sections show. + +[Arrow extension types]: https://arrow.apache.org/docs/format/Columnar.html#extension-types +[canonical extension types]: https://arrow.apache.org/docs/format/CanonicalExtensions.html +[Implementing User Defined Types and Custom Metadata in DataFusion]: https://datafusion.apache.org/blog/2025/09/21/custom-types-using-metadata + +### Semi-Structured Data with `datafusion-variant` + + + +[Variant] is a type for storing semi-structured data, similar to JSON, where each +value can hold objects, arrays, and primitive values, with different fields and +types in each row. Variant values use an efficient binary encoding and are part +of the Parquet, Iceberg, Delta Lake, and Spark ecosystems (see +[Variant Type in Apache Parquet for Semi-Structured Data] for background). + +The [datafusion-variant] crate adds a `VARIANT` SQL type and Spark-compatible +functions to DataFusion 56. Register it on a `SessionContext`: + +```rust +let mut ctx = SessionContext::new(); +datafusion_variant::register_all(&mut ctx)?; +``` + +and you can then load, query, and store semi-structured data using SQL: + +```sql +CREATE TABLE events AS +SELECT parse_json(json_data) AS event +FROM (VALUES + ('{"service":"api","status":200,"latency_ms":12,"tags":["cached"]}'), + ('{"service":"api","status":500,"latency_ms":85,"error":null}'), + ('{"service":"api","status":504,"error":"Somethings not working"}') +) AS input(json_data); + +-- Extract fields with the Spark-style `:` operator +SELECT event:service::VARCHAR, + event:latency_ms::BIGINT +FROM events +WHERE event:status::BIGINT >= 400; +``` + +```text ++----------------------+-------------------------+ +| events.event:service | events.event:latency_ms | ++----------------------+-------------------------+ +| api | 85 | +| api | NULL | ++----------------------+-------------------------+ +``` + +Variant columns can be written to and read from Parquet files with the normal +`COPY` and `SELECT` statements, including *shredding* commonly used fields into +typed Parquet columns for faster queries: + +```sql +COPY events TO 'shredded_events.parquet' STORED AS PARQUET +OPTIONS ('variant.shredding' '{"event": "STRUCT"}'); +``` + +The crate is under active development and aims to match Apache Spark's Variant +behavior; see the [datafusion-variant roadmap] and the DataFusion +[Variant epic][#26517] for what is planned next. + + + +[Variant]: https://parquet.apache.org/docs/file-format/types/variantencoding/ +[Variant Type in Apache Parquet for Semi-Structured Data]: https://parquet.apache.org/blog/2026/02/27/variant-type-in-apache-parquet-for-semi-structured-data/ +[datafusion-variant]: https://github.com/datafusion-contrib/datafusion-variant +[datafusion-variant roadmap]: https://github.com/datafusion-contrib/datafusion-variant/issues/69 + +### Geospatial Data with `geodatafusion` + + + +[geodatafusion] provides spatial extensions for DataFusion, built on the +[GeoArrow] extension types and modeled after the [PostGIS] SQL API. It includes +more than a hundred `ST_*` functions, readers and writers for formats such as +[GeoParquet], [FlatGeobuf], and GeoJSON, and Python bindings. + +As with Variant, a single call registers the spatial functions: + +```rust +let ctx = SessionContext::new(); +geodatafusion::register(&ctx); +``` + +and geometries can then be queried using familiar PostGIS-style SQL: + +```sql +SELECT ST_Distance(ST_Point(0, 0), ST_Point(3, 4)) AS dist; + +SELECT ST_Area(ST_GeomFromText('POLYGON((0 0, 4 0, 4 4, 0 4, 0 0))')); +``` + + + +Together, `datafusion-variant` and `geodatafusion` illustrate what the extension +type work makes possible: sophisticated new data types, with their own SQL +syntax, functions, and file format integrations, built and released +independently by the community. If you need a type that DataFusion does not +have, you can now build it. + +[geodatafusion]: https://github.com/datafusion-contrib/geodatafusion +[GeoArrow]: https://geoarrow.org/ +[PostGIS]: https://postgis.net/docs/reference.html +[GeoParquet]: https://geoparquet.org/ +[FlatGeobuf]: https://flatgeobuf.org/ + +### External Catalogs in SQL + +Connecting DataFusion to an external catalog, such as an Iceberg REST catalog, +previously required writing Rust code. DataFusion 56 adds +`CREATE EXTERNAL CATALOG` and `DROP CATALOG` statements ([#25112]), so catalogs +can be attached with SQL in the same way as external tables: + +```sql +CREATE EXTERNAL CATALOG my_catalog +STORED AS ICEBERG +LOCATION 's3://bucket/warehouse' +OPTIONS ('catalog.uri' 'http://rest-catalog:8181', 'warehouse' 'my_catalog'); + +SELECT * FROM my_catalog.sales.orders LIMIT 10; +``` + +DataFusion does not include catalog implementations itself. Instead, libraries +such as table format integrations register a [`CatalogProviderFactory`] for +each `STORED AS` type, and users can then attach catalogs without any +additional code; see the [`CREATE EXTERNAL CATALOG` documentation] for details. + +To make working with multiple catalogs more practical, `information_schema` +queries are now scoped to a single catalog, as the SQL standard specifies +([#25887]): `my_catalog.information_schema.tables` lists only the tables in +`my_catalog`, and an unqualified `information_schema` refers to the default +catalog. + +Thanks to [@pepijnve] and [@TTyChud] for this work. + +[`CatalogProviderFactory`]: https://docs.rs/datafusion/56.0.0/datafusion/catalog/trait.CatalogProviderFactory.html +[`CREATE EXTERNAL CATALOG` documentation]: https://datafusion.apache.org/user-guide/sql/ddl.html#create-external-catalog + +### File Format Improvements + +**Writing Avro**: DataFusion has been able to read [Apache Avro] files for a +long time, and DataFusion 56 can now write them too ([#24925]): + +```sql +COPY (SELECT * FROM orders) TO 'orders.avro' STORED AS AVRO; +``` + +**ALP Encoding for Parquet**: [ALP] (Adaptive Lossless floating-Point) is a new +Parquet encoding that often stores `FLOAT` and `DOUBLE` columns much more +compactly. DataFusion 56 reads ALP-encoded files and can write them +([#27036]): + +```sql +SET datafusion.execution.parquet.encoding = 'alp'; +COPY measurements TO 'measurements.parquet' STORED AS PARQUET; +``` + + + +**Hive Null Partitions**: Hive-compatible writers such as Spark store rows with +a null partition value in a directory named `__HIVE_DEFAULT_PARTITION__`. +DataFusion previously failed to read such tables, or returned the directory +name as a string. DataFusion 56 reads these values as `NULL`, as Hive, Spark +and Impala do ([#26310]). + +**Other Improvements**: New options control the target size of output files in +bytes (`datafusion.execution.soft_max_bytes_per_output_file`, [#24924]) and +write distinct value counts to Parquet statistics ([#25576]), and Arrow IPC +files gain format options ([#26155]). + +Thanks to [@pepijnve], [@Surajsuthar], [@xanderbailey], [@Tpt], and +[@Rich-T-kid] for this work. + +[Apache Avro]: https://avro.apache.org/ +[ALP]: https://github.com/apache/parquet-format/blob/master/Encodings.md + +### More SQL + +**`MATERIALIZED` CTEs**: By default, DataFusion inlines Common Table +Expressions (CTEs), so a CTE that is referenced several times is evaluated +several times. DataFusion 56 supports the Postgres +`WITH ... AS [NOT] MATERIALIZED` syntax to evaluate a CTE once and reuse the +result ([#25580]): + +```sql +WITH r AS MATERIALIZED (SELECT random() AS v) +SELECT a.v = b.v FROM r a, r b; +-- true: the CTE runs once and both references see the same value +``` + +**Other SQL Improvements**: DataFusion 56 also supports the `MAP` type in SQL +statements such as `CREATE TABLE` ([#24397]), multi-column `NOT IN` subqueries +with correct `NULL` semantics ([#19857]), column references as the percentile +argument of percentile functions ([#25337]), decimal inputs to +`percentile_cont` and `median` ([#24419]), `timezone`, `timezone_hour`, and +`timezone_minute` in `date_part` ([#25163]), and shows `MERGE INTO` details in +`EXPLAIN` ([#26038]). + +Thanks to [@adriangb], [@nuno-faria], [@viirya], [@dd-annarose], [@theirix], +and [@wirybeaver] for this work. + +### `datafusion-cli` Improvements + +`datafusion-cli` adds `parquet_file_metadata` and `parquet_page_index` table +functions for inspecting Parquet files ([#25640]), and can optionally register +the Spark-compatible functions from the [datafusion-spark crate] ([#24179]). +Thanks to [@jay-dee7] and [@goutamadwant]. + + + +### Versioned Documentation + +The [DataFusion documentation] previously described only the unreleased `main` +branch, which made it hard to tell which features were available in the version +you were actually using. The site now has a version picker and publishes a +snapshot of the documentation for each release ([#17071], [#24792]). Thanks to +[@yiaany] for this work and [@Omega359] for the original request. + +[DataFusion documentation]: https://datafusion.apache.org/ + +## Performance Improvements ๐Ÿš€ + +DataFusion 56 continues to get faster across the board. Here is a +representative sample of the improvements in this release. + + + +| Improvement | Representative Result | Area | +|-----------------------------------------------------|--------------------------------------------------------------------|-------------| +| `IN` / `NOT IN` subqueries in the `SELECT` list | [533 ms โ†’ 2 ms][#25338] | Subqueries | +| Ordered `ARRAY_AGG` and `STRING_AGG` | [10.5x faster, 59% less memory][#24392] | Aggregation | +| `GROUP BY` on fully sorted keys | [2.8x - 5x faster][#25150] *(micro)* | Aggregation | +| `array_agg(DISTINCT ...)` with many groups | [up to 36x faster][#26357] *(micro)* | Aggregation | +| Dynamic filters across join keys | [up to 2.3x faster on Join Order Benchmark queries][#25255] | Joins | +| Sort-merge joins with many matches per key | [~35% faster][#26277] *(micro)* | Joins | +| Nested loop join memory | [2x lower peak memory][#25371] | Joins | +| `LAST_VALUE ... IGNORE NULLS` | [13.15 ms โ†’ 111 ยตs][#26533] *(micro)* | Window | +| Planning `SELECT`s with many aggregates | [5.9x faster for 1000 aggregates][#25739] | Planning | +| Compiling the `datafusion` crate | [~10x faster][#24329] | Build | + +### Faster TopK and `LIMIT` Queries + +Queries that return only a few rows keep getting faster. DataFusion 56 can +evaluate `ORDER BY ... LIMIT` *before* an outer join when the sort columns come +from the preserved side, so far fewer rows are joined ([#21621]). For example, +this query now joins only three orders rather than every order: + +```sql +SELECT o.id, o.total, c.name +FROM orders AS o LEFT JOIN customers AS c ON o.customer_id = c.id +ORDER BY o.total DESC +LIMIT 3; +``` + +Parquet scans can also now stop after reading only the *pages* that are +guaranteed to satisfy a `LIMIT` query's filter ([#25000]), and custom table +providers can implement `OFFSET` pushdown, which is useful for paging through +results ([#25404]). Thanks to [@SubhamSinghal], [@peterxcli], and [@martin-g]. + +### Faster Joins + +Dynamic filters created by a join are now applied to *other* tables that are +joined on the same key, and pushed through nested loop joins, skipping more +data at the scan ([#25255], [#25030]). Other join improvements include faster +sort-merge joins ([#26277]), a nested loop join that needs half the memory +([#25371]), faster range joins ([#24579]), and rewriting joins against a single +constant row into filters ([#26404]). Thanks to [@jayzhan211], [@yashrb24], +[@andygrove], [@2010YOUY01], and [@xudong963]. + +### Faster Aggregations and Subqueries + +Aggregations over already sorted inputs now avoid hashing entirely +([#25150], [#26370]), and ordered `ARRAY_AGG` and `STRING_AGG` are over 10x +faster while using less than half the memory ([#24392]). `IN` and `NOT IN` +subqueries used as expressions (for example in the `SELECT` list) are now +planned as a single join, which makes some queries hundreds of times faster +([#25338]). Thanks to [@QinXi-ai], [@geoffreyclaude], [@lyne7-sc], +[@zhuqi-lucas], and [@adriangb]. + +### Faster Functions and Expressions + +As in previous releases, many functions are faster, including `upper`, `lower`, +`translate`, `replace`, `left`, `right`, `levenshtein`, and many array +functions, and `IN` list evaluation improved further with specializations for +more types (epic [#19241]). Thanks to [@neilconway], [@geoffreyclaude], +[@andygrove], [@Rich-T-kid], and [@comphead]. + +### Faster Builds + +It is not only queries that are faster: a series of changes reduced the time to +compile the core `datafusion` crate by ~10x, with similar improvements for +several other crates ([#24329], [#24325], [#24330], [#24326]). Thanks to +[@Dandandan]. + +## Stability Improvements ๐Ÿ›ก๏ธ + +**Correctness**: As a foundational piece of technology, it is important that +DataFusion's results can be relied on. During this release cycle the community +systematically collected and fixed bugs that produced incorrect results (see +epic [#26672]), and agreed to slow down new features in order to stabilize the +release ([#26865]). DataFusion 56 also verifies the final physical plan and +reports which optimizer rule produced an invalid plan ([#26461]). + + + +**Larger-Than-Memory Queries**: Queries that spill to disk when memory runs out +are more robust. Aggregations with very large groups (such as `array_agg` over +a few keys) no longer fail after spilling ([#25853]), spill files for string +and dictionary data are smaller ([#23565], [#27015]), and memory accounting is +more accurate in several operators ([#24744], [#25188], [#26074]). Thanks to +[@andygrove], [@cetra3], [@brancz], and [@kosiew]. + +## Upgrade Guide and Changelog ๐Ÿ“– + +DataFusion 56 upgrades to Arrow and Parquet 60 and `object_store` 0.14, and the +minimum supported Rust version is now 1.95.0. Upgrading should be +straightforward for most users, though there are some breaking changes and a +few changes in query behavior, such as how the session time zone applies to +timestamp operations and how `information_schema` queries are scoped. See the +[Upgrade Guide] for details and migration snippets, and the [changelog] for the +full list of changes. + +## About DataFusion + +[Apache DataFusion] is an extensible query engine, written in [Rust], that uses +[Apache Arrow] as its in-memory format. DataFusion is used by developers to +create new, fast, data-centric systems such as databases, dataframe libraries, +and machine learning and streaming applications. While [DataFusion's primary +design goal] is to accelerate the creation of other data-centric systems, it +provides a reasonable experience directly out of the box as a [dataframe +library], [Python library], and [command-line SQL tool]. + +DataFusion's core thesis is that, as a community, together we can build much +more advanced technology than any of us as individuals or companies could build +alone. Without DataFusion, highly performant vectorized query engines would +remain the domain of a few large companies and world-class research +institutions. With DataFusion, we can all build on top of a shared foundation +and focus on what makes our projects unique. + +## How to Get Involved + +DataFusion is not a project built or driven by a single person, company, or +foundation. Rather, our community of users and contributors works together to +build a shared technology that none of us could have built alone. + +If you are interested in joining us, we would love to have you. You can try out +DataFusion on some of your own data and projects and let us know how it goes, +contribute suggestions, documentation, bug reports, or a PR with documentation, +tests, or code. A list of open issues suitable for beginners is [here], and you +can find out how to reach us on the [communication doc]. + +[Apache DataFusion]: https://datafusion.apache.org/ +[Rust]: https://www.rust-lang.org/ +[Apache Arrow]: https://arrow.apache.org +[DataFusion's primary design goal]: https://datafusion.apache.org/user-guide/introduction.html#project-goals +[dataframe library]: https://datafusion.apache.org/user-guide/dataframe.html +[Python library]: https://datafusion.apache.org/python/ +[command-line SQL tool]: https://datafusion.apache.org/user-guide/cli/ +[Upgrade Guide]: https://datafusion.apache.org/library-user-guide/upgrading/56.0.0.html +[here]: https://github.com/apache/datafusion/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22 +[communication doc]: https://datafusion.apache.org/contributor-guide/communication.html +[datafusion-spark crate]: https://docs.rs/datafusion-spark/latest/datafusion_spark/index.html + +[@2010YOUY01]: https://github.com/2010YOUY01 +[@adriangb]: https://github.com/adriangb +[@andygrove]: https://github.com/andygrove +[@brancz]: https://github.com/brancz +[@cblp]: https://github.com/cblp +[@cetra3]: https://github.com/cetra3 +[@comphead]: https://github.com/comphead +[@cyberbeam524]: https://github.com/cyberbeam524 +[@Dandandan]: https://github.com/Dandandan +[@dd-annarose]: https://github.com/dd-annarose +[@geoffreyclaude]: https://github.com/geoffreyclaude +[@goutamadwant]: https://github.com/goutamadwant +[@james-willis]: https://github.com/james-willis +[@jay-dee7]: https://github.com/jay-dee7 +[@jayzhan211]: https://github.com/jayzhan211 +[@kosiew]: https://github.com/kosiew +[@Kristofferjoha]: https://github.com/Kristofferjoha +[@lyne7-sc]: https://github.com/lyne7-sc +[@M-Tesla]: https://github.com/M-Tesla +[@martin-g]: https://github.com/martin-g +[@neilconway]: https://github.com/neilconway +[@nuno-faria]: https://github.com/nuno-faria +[@Omega359]: https://github.com/Omega359 +[@osipovartem]: https://github.com/osipovartem +[@paleolimbot]: https://github.com/paleolimbot +[@pepijnve]: https://github.com/pepijnve +[@peterxcli]: https://github.com/peterxcli +[@QinXi-ai]: https://github.com/QinXi-ai +[@Rich-T-kid]: https://github.com/Rich-T-kid +[@SubhamSinghal]: https://github.com/SubhamSinghal +[@Surajsuthar]: https://github.com/Surajsuthar +[@theirix]: https://github.com/theirix +[@Tpt]: https://github.com/Tpt +[@TTyChud]: https://github.com/TTyChud +[@viirya]: https://github.com/viirya +[@wirybeaver]: https://github.com/wirybeaver +[@xanderbailey]: https://github.com/xanderbailey +[@Xuanwo]: https://github.com/Xuanwo +[@xudong963]: https://github.com/xudong963 +[@yashrb24]: https://github.com/yashrb24 +[@yiaany]: https://github.com/yiaany +[@zhuqi-lucas]: https://github.com/zhuqi-lucas + +[#318]: https://github.com/apache/datafusion/issues/318 +[#17071]: https://github.com/apache/datafusion/issues/17071 +[#19241]: https://github.com/apache/datafusion/issues/19241 +[#19857]: https://github.com/apache/datafusion/pull/19857 +[#21621]: https://github.com/apache/datafusion/pull/21621 +[#21714]: https://github.com/apache/datafusion/pull/21714 +[#23169]: https://github.com/apache/datafusion/pull/23169 +[#23565]: https://github.com/apache/datafusion/pull/23565 +[#23831]: https://github.com/apache/datafusion/pull/23831 +[#24179]: https://github.com/apache/datafusion/pull/24179 +[#24325]: https://github.com/apache/datafusion/pull/24325 +[#24326]: https://github.com/apache/datafusion/pull/24326 +[#24329]: https://github.com/apache/datafusion/pull/24329 +[#24330]: https://github.com/apache/datafusion/pull/24330 +[#24392]: https://github.com/apache/datafusion/pull/24392 +[#24397]: https://github.com/apache/datafusion/pull/24397 +[#24419]: https://github.com/apache/datafusion/pull/24419 +[#24579]: https://github.com/apache/datafusion/pull/24579 +[#24744]: https://github.com/apache/datafusion/pull/24744 +[#24792]: https://github.com/apache/datafusion/pull/24792 +[#24865]: https://github.com/apache/datafusion/pull/24865 +[#24924]: https://github.com/apache/datafusion/pull/24924 +[#24925]: https://github.com/apache/datafusion/pull/24925 +[#24939]: https://github.com/apache/datafusion/pull/24939 +[#24971]: https://github.com/apache/datafusion/pull/24971 +[#25000]: https://github.com/apache/datafusion/pull/25000 +[#25030]: https://github.com/apache/datafusion/pull/25030 +[#25112]: https://github.com/apache/datafusion/pull/25112 +[#25150]: https://github.com/apache/datafusion/pull/25150 +[#25163]: https://github.com/apache/datafusion/pull/25163 +[#25188]: https://github.com/apache/datafusion/pull/25188 +[#25255]: https://github.com/apache/datafusion/pull/25255 +[#25337]: https://github.com/apache/datafusion/pull/25337 +[#25338]: https://github.com/apache/datafusion/pull/25338 +[#25371]: https://github.com/apache/datafusion/pull/25371 +[#25404]: https://github.com/apache/datafusion/pull/25404 +[#25576]: https://github.com/apache/datafusion/pull/25576 +[#25580]: https://github.com/apache/datafusion/pull/25580 +[#25640]: https://github.com/apache/datafusion/pull/25640 +[#25739]: https://github.com/apache/datafusion/pull/25739 +[#25853]: https://github.com/apache/datafusion/pull/25853 +[#25887]: https://github.com/apache/datafusion/pull/25887 +[#26038]: https://github.com/apache/datafusion/pull/26038 +[#26074]: https://github.com/apache/datafusion/pull/26074 +[#26155]: https://github.com/apache/datafusion/pull/26155 +[#26277]: https://github.com/apache/datafusion/pull/26277 +[#26310]: https://github.com/apache/datafusion/pull/26310 +[#26357]: https://github.com/apache/datafusion/pull/26357 +[#26370]: https://github.com/apache/datafusion/pull/26370 +[#26404]: https://github.com/apache/datafusion/pull/26404 +[#26461]: https://github.com/apache/datafusion/pull/26461 +[#26517]: https://github.com/apache/datafusion/issues/26517 +[#26533]: https://github.com/apache/datafusion/pull/26533 +[#26672]: https://github.com/apache/datafusion/issues/26672 +[#26854]: https://github.com/apache/datafusion/pull/26854 +[#26865]: https://github.com/apache/datafusion/issues/26865 +[#26893]: https://github.com/apache/datafusion/pull/26893 +[#26939]: https://github.com/apache/datafusion/pull/26939 +[#27015]: https://github.com/apache/datafusion/pull/27015 +[#27036]: https://github.com/apache/datafusion/pull/27036