Google Git
Sign in
apache / arrow-rs / refs/tags/57.0.0
commit5faa7248bd0d2efec9e072c3f58014691c4bddf3[log] [tgz]
authorAndrew Lamb <andrew@nerdnetworks.org>Sun Oct 19 13:18:15 2025 -0700
committerGitHub <noreply@github.com>Sun Oct 19 16:18:15 2025 -0400
tree84b8ac25ab3c082a67179cd50bb85ea08ac7bcca
parent0c33129b890027b6d421fdfe153e192196b65ad9 [diff]
Prepare for `57.0.0` release (#8644)

# Which issue does this PR close?

- Part of #7835 

# Rationale for this change

Let's get the code to the people

# What changes are included in this PR?

Update version number and CHANGELOG. See rendered version here:
https://github.com/alamb/arrow-rs/blob/alamb/prepare_57.0.0/CHANGELOG.md

# Are these changes tested?

N/A

# Are there any user-facing changes?

No
4 files changed
tree: 84b8ac25ab3c082a67179cd50bb85ea08ac7bcca
  1. .github/
  2. arrow/
  3. arrow-arith/
  4. arrow-array/
  5. arrow-avro/
  6. arrow-buffer/
  7. arrow-cast/
  8. arrow-csv/
  9. arrow-data/
  10. arrow-flight/
  11. arrow-integration-test/
  12. arrow-integration-testing/
  13. arrow-ipc/
  14. arrow-json/
  15. arrow-ord/
  16. arrow-pyarrow/
  17. arrow-pyarrow-integration-testing/
  18. arrow-pyarrow-testing/
  19. arrow-row/
  20. arrow-schema/
  21. arrow-select/
  22. arrow-string/
  23. dev/
  24. format/
  25. parquet/
  26. parquet-geospatial/
  27. parquet-variant/
  28. parquet-variant-compute/
  29. parquet-variant-json/
  30. parquet_derive/
  31. parquet_derive_test/
  32. parquet-testing
  33. testing
  34. .asf.yaml
  35. .gitattributes
  36. .github_changelog_generator
  37. .gitignore
  38. .gitmodules
  39. .pre-commit-config.yaml
  40. Cargo.toml
  41. CHANGELOG-old.md
  42. CHANGELOG.md
  43. CODE_OF_CONDUCT.md
  44. CONTRIBUTING.md
  45. header
  46. LICENSE.txt
  47. NOTICE.txt
  48. pre-commit.sh
  49. README.md
  50. rust-toolchain.toml
  51. rustfmt.toml
README.md

Native Rust implementation of Apache Arrow and Apache Parquet

Welcome to the Rust implementation of Apache Arrow, the popular in-memory columnar format.

This repository contains the following crates:

CrateDescriptionLatest API DocsREADME
arrowCore functionality (memory layout, arrays, low level computations)docs.rs(README)
arrow-flightSupport for Arrow-Flight IPC protocoldocs.rs(README)
parquetSupport for Parquet columnar file formatdocs.rs(README)
parquet_deriveA crate for deriving RecordWriter/RecordReader for arbitrary, simple structsdocs.rs(README)

The current development version the API documentation in this repo can be found here.

Note: previously the object_store crate was also part of this repository, but it has been moved to the arrow-rs-object-store repository

Release Versioning and Schedule

The Arrow Rust project releases approximately monthly and follows Semantic Versioning.

Due to available maintainer and testing bandwidth, arrow crates (arrow, arrow-flight, etc.) are released on the same schedule with the same versions as the parquet and [parquet-derive] crates.

This crate releases every month. We release new major versions (with potentially breaking API changes) at most once a quarter, and release incremental minor versions in the intervening months. See ticket #5368 for more details.

To keep our maintenance burden down, we do regularly scheduled releases (major and minor) from the main branch. How we handle PRs with breaking API changes is described in the contributing guide.

Planned Release Schedule

Approximate DateVersionNotes
October 202557.0.0Major, potentially breaking API changes
November 202557.1.0Minor, NO breaking API changes
December 202557.2.0Minor, NO breaking API changes
January 202658.0.0Major, potentially breaking API changes

Rust Version Compatibility Policy

arrow-rs and parquet are built and tested with stable Rust, and will keep a rolling MSRV (minimum supported Rust version) that can only be updated in major releases on a need by basis (e.g. project dependencies bump their MSRV or a particular Rust feature is useful for us etc.). The new MSRV if selected will be at least 6 months old. The minor releases are guaranteed to have the same MSRV.

Note: If a Rust hotfix is released for the current MSRV, the MSRV will be updated to the specific minor version that includes all applicable hotfixes preceding other policies.

Guidelines for panic vs Result

In general, use panics for bad states that are unreachable, unrecoverable or harmful. For those caused by invalid user input, however, we prefer to report that invalidity gracefully as an error result instead of panicking. In general, invalid input should result in an Error as soon as possible. It is ok for code paths after validation to assume validation has already occurred and panic if not. See ticket #6737 for more nuances.

Deprecation Guidelines

Minor releases may deprecate, but not remove APIs. Deprecating APIs allows downstream Rust programs to still compile, but generate compiler warnings. This gives downstream crates time to migrate prior to API removal.

To deprecate an API:

  • Mark the API as deprecated using #[deprecated] and specify the exact arrow-rs version in which it was deprecated
  • Concisely describe the preferred API to help the user transition

The deprecated version is the next version which will be released (please consult the list above). To mark the API as deprecated, use the #[deprecated(since = "...", note = "...")] attribute.

For example

#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]

In general, deprecated APIs will remain in the codebase for at least two major releases after they were deprecated (typically between 6 - 9 months later). For example, an API deprecated in 51.3.0 can be removed in 54.0.0 (or later). Deprecated APIs may be removed earlier or later than these guidelines at the discretion of the maintainers.

Related Projects

There are several related crates in different repositories

CrateDescriptionDocumentation
object_storeObject Storage (aws, azure, gcp, local, in-memory) interface(README)
datafusionIn-memory query engine with SQL support(README)
ballistaDistributed query execution(README)
parquet_opendalUse [opendal] for parquet Arrow IO(README)

Collectively, these crates support a wider array of functionality for analytic computations in Rust.

For example, you can write SQL queries or a DataFrame (using the datafusion crate) to read a parquet file (using the parquet crate), evaluate it in-memory using Arrow's columnar format (using the arrow crate), and send to another process (using the arrow-flight crate).

Generally speaking, the arrow crate offers functionality for using Arrow arrays, and datafusion offers most operations typically found in SQL, including joins and window functions.

You can find more details about each crate in their respective READMEs.

Arrow Rust Community

The dev@arrow.apache.org mailing list serves as the core communication channel for the Arrow community. Instructions for signing up and links to the archives can be found on the Arrow Community page. All major announcements and communications happen there.

The Rust Arrow community also uses the official ASF Slack for informal discussions and coordination. This is a great place to meet other contributors and get guidance on where to contribute. Join us in the #arrow-rust channel and feel free to ask for an invite via:

  1. the dev@arrow.apache.org mailing list
  2. the GitHub Discussions
  3. the Discord channel

The Rust implementation uses GitHub issues as the system of record for new features and bug fixes and this plays a critical role in the release process.

For design discussions we generally use GitHub issues.

There is more information in the contributing guide.