You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by al...@apache.org on 2021/07/13 13:56:50 UTC
[arrow-rs] branch master updated: Clean up README.md in advance of
the 5.0 release (#536)
This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/master by this push:
new 6698eed Clean up README.md in advance of the 5.0 release (#536)
6698eed is described below
commit 6698eed2900cffadc549a92defe2030d36ccf0d6
Author: Andrew Lamb <an...@nerdnetworks.org>
AuthorDate: Tue Jul 13 09:56:40 2021 -0400
Clean up README.md in advance of the 5.0 release (#536)
* Clean up parquet readme
* Fixup arrow readme content
* cleanups
* update main readmen
* update contributing
* Prettier
* RAT
---
CONTRIBUTING.md | 145 +++++++++++++++++++++---------
README.md | 167 +++++------------------------------
arrow-flight/README.md | 13 ++-
arrow/{README.md => CONTRIBUTING.md} | 33 -------
arrow/README.md | 156 ++++----------------------------
parquet/CONTRIBUTING.md | 61 +++++++++++++
parquet/README.md | 67 +-------------
7 files changed, 215 insertions(+), 427 deletions(-)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 18d6a7b..9fe6c48 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -17,61 +17,122 @@
under the License.
-->
-# How to contribute to Apache Arrow
+## Developer's guide to Arrow Rust
-## Did you find a bug?
+### How to compile
-The Arrow project uses JIRA as a bug tracker. To report a bug, you'll have
-to first create an account on the
-[Apache Foundation JIRA](https://issues.apache.org/jira/). The JIRA server
-hosts bugs and issues for multiple Apache projects. The JIRA project name
-for Arrow is "ARROW".
+This is a standard cargo project with workspaces. To build it, you need to have `rust` and `cargo`:
-To be assigned to an issue, ask an Arrow JIRA admin to go to
-[Arrow Roles](https://issues.apache.org/jira/plugins/servlet/project-config/ARROW/roles),
-click "Add users to a role," and add you to the "Contributor" role. Most
-committers are authorized to do this; if you're a committer and aren't
-able to load that project admin page, have someone else add you to the
-necessary role.
+```bash
+cargo build
+```
-Before you create a new bug entry, we recommend you first
-[search](https://issues.apache.org/jira/projects/ARROW/issues/ARROW-5140?filter=allopenissues)
-among existing Arrow issues.
+You can also use rust's official docker image:
-When you create a new JIRA entry, please don't forget to fill the "Component"
-field. Arrow has many subcomponents and this helps triaging and filtering
-tremendously. Also, we conventionally prefix the issue title with the component
-name in brackets, such as "[C++] Crash in Array::Frobnicate()", so as to make
-lists more easy to navigate, and we'd be grateful if you did the same.
+```bash
+docker run --rm -v $(pwd):/arrow-rs -it rust /bin/bash -c "cd /arrow-rs && rustup component add rustfmt && cargo build"
+```
-## Did you write a patch that fixes a bug or brings an improvement?
+The command above assumes that are in the root directory of the project, not in the same
+directory as this README.md.
-First create a JIRA entry as described above. Then, submit your changes
-as a GitHub Pull Request. We'll ask you to prefix the pull request title
-with the JIRA issue number and the component name in brackets.
-(for example: "ARROW-2345: [C++] Fix crash in Array::Frobnicate()").
-Respecting this convention makes it easier for us to process the backlog
-of submitted Pull Requests.
+You can also compile specific workspaces:
-### Minor Fixes
+```bash
+cd arrow && cargo build
+```
-Any functionality change should have a JIRA opened. For minor changes that
-affect documentation, you do not need to open up a JIRA. Instead you can
-prefix the title of your PR with "MINOR: " if meets the following guidelines:
+### Git Submodules
-- Grammar, usage and spelling fixes that affect no more than 2 files
-- Documentation updates affecting no more than 2 files and not more
- than 500 words.
+Before running tests and examples, it is necessary to set up the local development environment.
-## Do you want to propose a significant new feature or an important refactoring?
+The tests rely on test data that is contained in git submodules.
-We ask that all discussions about major changes in the codebase happen
-publicly on the [arrow-dev mailing-list](https://mail-archives.apache.org/mod_mbox/arrow-dev/).
+To pull down this data run the following:
-## Do you have questions about the source code, the build procedure or the development process?
+```bash
+git submodule update --init
+```
-You can also ask on the mailing-list, see above.
+This populates data in two git submodules:
-## Further information
+- `../parquet_testing/data` (sourced from https://github.com/apache/parquet-testing.git)
+- `../testing` (sourced from https://github.com/apache/arrow-testing)
-Please read our [development documentation](https://arrow.apache.org/docs/developers/contributing.html).
+By default, `cargo test` will look for these directories at their
+standard location. The following environment variables can be used to override the location:
+
+```bash
+# Optionally specify a different location for test data
+export PARQUET_TEST_DATA=$(cd ../parquet-testing/data; pwd)
+export ARROW_TEST_DATA=$(cd ../testing/data; pwd)
+```
+
+From here on, this is a pure Rust project and `cargo` can be used to run tests, benchmarks, docs and examples as usual.
+
+### Running the tests
+
+Run tests using the Rust standard `cargo test` command:
+
+```bash
+# run all tests.
+cargo test
+
+
+# run only tests for the arrow crate
+cargo test -p arrow
+```
+
+## Code Formatting
+
+Our CI uses `rustfmt` to check code formatting. Before submitting a
+PR be sure to run the following and check for lint issues:
+
+```bash
+cargo +stable fmt --all -- --check
+```
+
+## Clippy Lints
+
+We recommend using `clippy` for checking lints during development. While we do not yet enforce `clippy` checks, we recommend not introducing new `clippy` errors or warnings.
+
+Run the following to check for clippy lints.
+
+```bash
+cargo clippy
+```
+
+If you use Visual Studio Code with the `rust-analyzer` plugin, you can enable `clippy` to run each time you save a file. See https://users.rust-lang.org/t/how-to-use-clippy-in-vs-code-with-rust-analyzer/41881.
+
+One of the concerns with `clippy` is that it often produces a lot of false positives, or that some recommendations may hurt readability. We do not have a policy of which lints are ignored, but if you disagree with a `clippy` lint, you may disable the lint and briefly justify it.
+
+Search for `allow(clippy::` in the codebase to identify lints that are ignored/allowed. We currently prefer ignoring lints on the lowest unit possible.
+
+- If you are introducing a line that returns a lint warning or error, you may disable the lint on that line.
+- If you have several lints on a function or module, you may disable the lint on the function or module.
+- If a lint is pervasive across multiple modules, you may disable it at the crate level.
+
+## Git Pre-Commit Hook
+
+We can use [git pre-commit hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) to automate various kinds of git pre-commit checking/formatting.
+
+Suppose you are in the root directory of the project.
+
+First check if the file already exists:
+
+```bash
+ls -l .git/hooks/pre-commit
+```
+
+If the file already exists, to avoid mistakenly **overriding**, you MAY have to check
+the link source or file content. Else if not exist, let's safely soft link [pre-commit.sh](pre-commit.sh) as file `.git/hooks/pre-commit`:
+
+```bash
+ln -s ../../rust/pre-commit.sh .git/hooks/pre-commit
+```
+
+If sometimes you want to commit without checking, just run `git commit` with `--no-verify`:
+
+```bash
+git commit --no-verify -m "... commit message ..."
+```
diff --git a/README.md b/README.md
index 0214428..b1cac38 100644
--- a/README.md
+++ b/README.md
@@ -17,167 +17,42 @@
under the License.
-->
-# Native Rust implementation of Apache Arrow
+# Native Rust implementation of Apache Arrow and Parquet
[](https://codecov.io/gh/apache/arrow?branch=master)
Welcome to the implementation of Arrow, the popular in-memory columnar format, in [Rust](https://www.rust-lang.org/).
-This part of the Arrow project is divided in 4 main components:
+This repo contains the following main components:
-| Crate | Description | Documentation |
-| ------------ | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
-| Arrow | Core functionality (memory layout, arrays, low level computations) | [(README)](arrow/README.md) |
-| Parquet | Parquet support | [(README)](parquet/README.md) |
-| Arrow-flight | Arrow data between processes | [(README)](arrow-flight/README.md) |
-| DataFusion | In-memory query engine with SQL support | [(README)](https://github.com/apache/arrow-datafusion/blob/master/README.md) |
-| Ballista | Distributed query execution | [(README)](https://github.com/apache/arrow-datafusion/blob/master/ballista/README.md) |
-
-Independently, they support a vast array of functionality for in-memory computations.
+| Crate | Description | Documentation |
+| ------------ | ------------------------------------------------------------------ | ---------------------------------- |
+| arrow | Core functionality (memory layout, arrays, low level computations) | [(README)](arrow/README.md) |
+| parquet | Support for Parquet columnar file format | [(README)](parquet/README.md) |
+| arrow-flight | Support for Arrow-Flight IPC protocol | [(README)](arrow-flight/README.md) |
-Together, they allow users to write an SQL query or a `DataFrame` (using the `datafusion` crate), run it against 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).
+There are two related crates in a different repository
+| Crate | Description | Documentation |
+| ------------ | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
+| DataFusion | In-memory query engine with SQL support | [(README)](https://github.com/apache/arrow-datafusion/blob/master/README.md) |
+| Ballista | Distributed query execution | [(README)](https://github.com/apache/arrow-datafusion/blob/master/ballista/README.md) |
-Generally speaking, the `arrow` crate offers functionality to develop code that uses Arrow arrays, and `datafusion` offers most operations typically found in SQL, including `join`s and window functions.
+Collectively, these crates support a vast array of functionality for analytic computations in Rust.
-There are too many features to enumerate here, but some notable mentions:
+For example, you can write an SQL query or a `DataFrame` (using the `datafusion` crate), run it against 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).
-- `Arrow` implements all formats in the specification except certain dictionaries
-- `Arrow` supports SIMD operations to some of its vertical operations
-- `DataFusion` supports `async` execution
-- `DataFusion` supports user-defined functions, aggregates, and whole execution nodes
+Generally speaking, the `arrow` crate offers functionality for using Arrow arrays, and `datafusion` offers most operations typically found in SQL, including `join`s and window functions.
You can find more details about each crate in their respective READMEs.
## Arrow Rust Community
-We use the official [ASF Slack](https://s.apache.org/slack-invite) 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.
-
-We use [ASF JIRA](https://issues.apache.org/jira/secure/Dashboard.jspa) 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 collaborate on Google documents and file a JIRA linking to the document.
-
-There is also a bi-weekly Rust-specific sync call for the Arrow Rust community. This is hosted on Google Meet
-at https://meet.google.com/ctp-yujs-aee on alternate Wednesday's at 09:00 US/Pacific, 12:00 US/Eastern. During
-US daylight savings time this corresponds to 16:00 UTC and at other times this is 17:00 UTC.
-
-## Developer's guide to Arrow Rust
-
-### How to compile
-
-This is a standard cargo project with workspaces. To build it, you need to have `rust` and `cargo`:
-
-```bash
-cargo build
-```
-
-You can also use rust's official docker image:
-
-```bash
-docker run --rm -v $(pwd):/arrow-rs -it rust /bin/bash -c "cd /arrow-rs && rustup component add rustfmt && cargo build"
-```
-
-The command above assumes that are in the root directory of the project, not in the same
-directory as this README.md.
-
-You can also compile specific workspaces:
-
-```bash
-cd arrow && cargo build
-```
-
-### Git Submodules
-
-Before running tests and examples, it is necessary to set up the local development environment.
-
-The tests rely on test data that is contained in git submodules.
-
-To pull down this data run the following:
-
-```bash
-git submodule update --init
-```
-
-This populates data in two git submodules:
-
-- `../parquet_testing/data` (sourced from https://github.com/apache/parquet-testing.git)
-- `../testing` (sourced from https://github.com/apache/arrow-testing)
-
-By default, `cargo test` will look for these directories at their
-standard location. The following environment variables can be used to override the location:
-
-```bash
-# Optionally specify a different location for test data
-export PARQUET_TEST_DATA=$(cd ../parquet-testing/data; pwd)
-export ARROW_TEST_DATA=$(cd ../testing/data; pwd)
-```
+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 at the [Arrow Community](https://arrow.apache.org/community/) page. All major announcements and communications happen there.
-From here on, this is a pure Rust project and `cargo` can be used to run tests, benchmarks, docs and examples as usual.
+The Rust Arrow community also uses the official [ASF Slack](https://s.apache.org/slack-invite) 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.
-### Running the tests
-
-Run tests using the Rust standard `cargo test` command:
-
-```bash
-# run all tests.
-cargo test
-
-
-# run only tests for the arrow crate
-cargo test -p arrow
-```
-
-## Code Formatting
-
-Our CI uses `rustfmt` to check code formatting. Before submitting a
-PR be sure to run the following and check for lint issues:
-
-```bash
-cargo +stable fmt --all -- --check
-```
-
-## Clippy Lints
-
-We recommend using `clippy` for checking lints during development. While we do not yet enforce `clippy` checks, we recommend not introducing new `clippy` errors or warnings.
-
-Run the following to check for clippy lints.
-
-```bash
-cargo clippy
-```
-
-If you use Visual Studio Code with the `rust-analyzer` plugin, you can enable `clippy` to run each time you save a file. See https://users.rust-lang.org/t/how-to-use-clippy-in-vs-code-with-rust-analyzer/41881.
-
-One of the concerns with `clippy` is that it often produces a lot of false positives, or that some recommendations may hurt readability. We do not have a policy of which lints are ignored, but if you disagree with a `clippy` lint, you may disable the lint and briefly justify it.
-
-Search for `allow(clippy::` in the codebase to identify lints that are ignored/allowed. We currently prefer ignoring lints on the lowest unit possible.
-
-- If you are introducing a line that returns a lint warning or error, you may disable the lint on that line.
-- If you have several lints on a function or module, you may disable the lint on the function or module.
-- If a lint is pervasive across multiple modules, you may disable it at the crate level.
-
-## Git Pre-Commit Hook
-
-We can use [git pre-commit hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) to automate various kinds of git pre-commit checking/formatting.
-
-Suppose you are in the root directory of the project.
-
-First check if the file already exists:
-
-```bash
-ls -l .git/hooks/pre-commit
-```
-
-If the file already exists, to avoid mistakenly **overriding**, you MAY have to check
-the link source or file content. Else if not exist, let's safely soft link [pre-commit.sh](pre-commit.sh) as file `.git/hooks/pre-commit`:
-
-```bash
-ln -s ../../rust/pre-commit.sh .git/hooks/pre-commit
-```
-
-If sometimes you want to commit without checking, just run `git commit` with `--no-verify`:
+Unlike other parts of the Arrow ecosystem, the Rust implementation uses [github issues](https://github.com/apache/arrow-rs/issues) as the system of record for new features
+and bug fixes and this plays a critical role in the release process.
-```bash
-git commit --no-verify -m "... commit message ..."
-```
+For design discussions we generally collaborate on Google documents and file a github issue linking to the document.
diff --git a/arrow-flight/README.md b/arrow-flight/README.md
index 4205ebb..b9bc466 100644
--- a/arrow-flight/README.md
+++ b/arrow-flight/README.md
@@ -21,8 +21,15 @@
[](https://crates.io/crates/arrow-flight)
-Apache Arrow Flight is a gRPC based protocol for exchanging Arrow data between processes. See the blog post [Introducing Apache Arrow Flight: A Framework for Fast Data Transport](https://arrow.apache.org/blog/2019/10/13/introducing-arrow-flight/) for more information.
+## Usage
+
+Add this to your Cargo.toml:
-This crate simply provides the Rust implementation of the [Flight.proto](../../format/Flight.proto) gRPC protocol and provides an example that demonstrates how to build a Flight server implemented with Tonic.
+```toml
+[dependencies]
+arrow-flight = "5.0"
+```
+
+Apache Arrow Flight is a gRPC based protocol for exchanging Arrow data between processes. See the blog post [Introducing Apache Arrow Flight: A Framework for Fast Data Transport](https://arrow.apache.org/blog/2019/10/13/introducing-arrow-flight/) for more information.
-Note that building a Flight server also requires an implementation of Arrow IPC which is based on the Flatbuffers serialization framework. The Rust implementation of Arrow IPC is not yet complete although the generated Flatbuffers code is available as part of the core Arrow crate.
+This crate provides a Rust implementation of the [Flight.proto](../../format/Flight.proto) gRPC protocol and provides an example that demonstrates how to build a Flight server implemented with Tonic.
diff --git a/arrow/README.md b/arrow/CONTRIBUTING.md
similarity index 83%
copy from arrow/README.md
copy to arrow/CONTRIBUTING.md
index dfd5926..843e1fa 100644
--- a/arrow/README.md
+++ b/arrow/CONTRIBUTING.md
@@ -17,12 +17,6 @@
under the License.
-->
-# Native Rust implementation of Apache Arrow
-
-[](https://crates.io/crates/arrow)
-
-This crate contains a native Rust implementation of the [Arrow columnar format](https://arrow.apache.org/docs/format/Columnar.html).
-
## Developer's guide
Common information for all Rust libraries in this project, including
@@ -45,19 +39,6 @@ cargo test --features memory-check --lib -- --test-threads 1
This runs all unit-tests on a single thread and counts all allocations and de-allocations.
-## Examples
-
-The examples folder shows how to construct some different types of Arrow
-arrays, including dynamic arrays created at runtime.
-
-Examples can be run using the `cargo run --example` command. For example:
-
-```bash
-cargo run --example builders
-cargo run --example dynamic_types
-cargo run --example read_csv
-```
-
## IPC
The expected flatc version is 1.12.0+, built from [flatbuffers](https://github.com/google/flatbuffers)
@@ -75,20 +56,6 @@ The above script will run the `flatc` compiler and perform some adjustments to t
- Remove `org::apache::arrow::flatbuffers` namespace
- Add includes to each generated file
-## Features
-
-Arrow uses the following features:
-
-- `simd` - Arrow uses the [packed_simd](https://crates.io/crates/packed_simd) crate to optimize many of the
- implementations in the [compute](https://github.com/apache/arrow/tree/master/rust/arrow/src/compute)
- module using SIMD intrinsics. These optimizations are turned _off_ by default.
- If the `simd` feature is enabled, an unstable version of Rust is required (we test with `nightly-2021-03-24`)
-- `flight` which contains useful functions to convert between the Flight wire format and Arrow data
-- `prettyprint` which is a utility for printing record batches
-
-Other than `simd` all the other features are enabled by default. Disabling `prettyprint` might be necessary in order to
-compile Arrow to the `wasm32-unknown-unknown` WASM target.
-
## Guidelines in usage of `unsafe`
[`unsafe`](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) has a high maintenance cost because debugging and testing it is difficult, time consuming, often requires external tools (e.g. `valgrind`), and requires a higher-than-usual attention to details. Undefined behavior is particularly difficult to identify and test, and usage of `unsafe` is the [primary cause of undefined behavior](https://doc.rust-lang.org/reference/behavior-considered-undefined.html) in a program written in Rust.
diff --git a/arrow/README.md b/arrow/README.md
index dfd5926..f9b7308 100644
--- a/arrow/README.md
+++ b/arrow/README.md
@@ -17,38 +17,36 @@
under the License.
-->
-# Native Rust implementation of Apache Arrow
+# Apache Arrow Official Native Rust Implementation
[](https://crates.io/crates/arrow)
-This crate contains a native Rust implementation of the [Arrow columnar format](https://arrow.apache.org/docs/format/Columnar.html).
+This crate contains the official Native Rust implementation of [Apache Arrow](https://arrow.apache.org/) in memory format. Please see the API documents for additional details.
-## Developer's guide
-
-Common information for all Rust libraries in this project, including
-testing, code formatting, and lints, can be found in the main Arrow
-Rust [README.md](../README.md).
+## Features
-Please refer to [lib.rs](src/lib.rs) for an introduction to this
-specific crate and its current functionality.
+The arrow crate provides the following optional features:
-### How to check memory allocations
+- `csv` (default) - support for reading and writing Arrow arrays to/from csv files
+- `ipc` (default) - support for the [arrow-flight]((https://crates.io/crates/arrow-flight) IPC and wire format
+- `prettyprint` - support for formatting record batches as textual columns
+- `simd` - (_Requires Nightly Rust_) alternate optimized
+ implementations of some [compute](https://github.com/apache/arrow/tree/master/rust/arrow/src/compute)
+ kernels using explicit SIMD processor intrinsics.
-This crate heavily uses `unsafe` due to how memory is allocated in cache lines.
-We have a small tool to verify that this crate does not leak memory (beyond what the compiler already does)
+## Building for WASM
-Run it with
+In order to compile Arrow for Web Assembly (the `wasm32-unknown-unknown` WASM target), you will likely need to turn off this crate's default features.
-```bash
-cargo test --features memory-check --lib -- --test-threads 1
+```toml
+[dependencies]
+arrow = {version = "5.0" default-features = false }
```
-This runs all unit-tests on a single thread and counts all allocations and de-allocations.
-
## Examples
The examples folder shows how to construct some different types of Arrow
-arrays, including dynamic arrays created at runtime.
+arrays, including dynamic arrays:
Examples can be run using the `cargo run --example` command. For example:
@@ -57,125 +55,3 @@ cargo run --example builders
cargo run --example dynamic_types
cargo run --example read_csv
```
-
-## IPC
-
-The expected flatc version is 1.12.0+, built from [flatbuffers](https://github.com/google/flatbuffers)
-master at fixed commit ID, by regen.sh.
-
-The IPC flatbuffer code was generated by running this command from the root of the project:
-
-```bash
-./regen.sh
-```
-
-The above script will run the `flatc` compiler and perform some adjustments to the source code:
-
-- Replace `type__` with `type_`
-- Remove `org::apache::arrow::flatbuffers` namespace
-- Add includes to each generated file
-
-## Features
-
-Arrow uses the following features:
-
-- `simd` - Arrow uses the [packed_simd](https://crates.io/crates/packed_simd) crate to optimize many of the
- implementations in the [compute](https://github.com/apache/arrow/tree/master/rust/arrow/src/compute)
- module using SIMD intrinsics. These optimizations are turned _off_ by default.
- If the `simd` feature is enabled, an unstable version of Rust is required (we test with `nightly-2021-03-24`)
-- `flight` which contains useful functions to convert between the Flight wire format and Arrow data
-- `prettyprint` which is a utility for printing record batches
-
-Other than `simd` all the other features are enabled by default. Disabling `prettyprint` might be necessary in order to
-compile Arrow to the `wasm32-unknown-unknown` WASM target.
-
-## Guidelines in usage of `unsafe`
-
-[`unsafe`](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) has a high maintenance cost because debugging and testing it is difficult, time consuming, often requires external tools (e.g. `valgrind`), and requires a higher-than-usual attention to details. Undefined behavior is particularly difficult to identify and test, and usage of `unsafe` is the [primary cause of undefined behavior](https://doc.rust-lang.org/reference/behavior-considered-undefined.html) in a program written in Rust.
-For two real world examples of where `unsafe` has consumed time in the past in this project see [#8545](https://github.com/apache/arrow/pull/8645) and [8829](https://github.com/apache/arrow/pull/8829)
-This crate only accepts the usage of `unsafe` code upon careful consideration, and strives to avoid it to the largest possible extent.
-
-### When can `unsafe` be used?
-
-Generally, `unsafe` should only be used when a `safe` counterpart is not available and there is no `safe` way to achieve additional performance in that area. The following is a summary of the current components of the crate that require `unsafe`:
-
-- alloc, dealloc and realloc of buffers along cache lines
-- Interpreting bytes as certain rust types, for access, representation and compute
-- Foreign interfaces (C data interface)
-- Inter-process communication (IPC)
-- SIMD
-- Performance (e.g. omit bounds checks, use of pointers to avoid bound checks)
-
-#### cache-line aligned memory management
-
-The arrow format recommends storing buffers aligned with cache lines, and this crate adopts this behavior.
-However, Rust's global allocator does not allocate memory aligned with cache-lines. As such, many of the low-level operations related to memory management require `unsafe`.
-
-#### Interpreting bytes
-
-The arrow format is specified in bytes (`u8`), which can be logically represented as certain types
-depending on the `DataType`.
-For many operations, such as access, representation, numerical computation and string manipulation,
-it is often necessary to interpret bytes as other physical types (e.g. `i32`).
-
-Usage of `unsafe` for the purpose of interpreting bytes in their corresponding type (according to the arrow specification) is allowed. Specifically, the pointer to the byte slice must be aligned to the type that it intends to represent and the length of the slice is a multiple of the size of the target type of the transmutation.
-
-#### FFI
-
-The arrow format declares an ABI for zero-copy from and to libraries that implement the specification
-(foreign interfaces). In Rust, receiving and sending pointers via FFI requires usage of `unsafe` due to
-the impossibility of the compiler to derive the invariants (such as lifetime, null pointers, and pointer alignment) from the source code alone as they are part of the FFI contract.
-
-#### IPC
-
-The arrow format declares a IPC protocol, which this crate supports. IPC is equivalent to a FFI in that the rust compiler can't reason about the contract's invariants.
-
-#### SIMD
-
-The API provided by the `packed_simd` library is currently `unsafe`. However, SIMD offers a significant performance improvement over non-SIMD operations.
-
-#### Performance
-
-Some operations are significantly faster when `unsafe` is used.
-
-A common usage of `unsafe` is to offer an API to access the `i`th element of an array (e.g. `UInt32Array`).
-This requires accessing the values buffer e.g. `array.buffers()[0]`, picking the slice
-`[i * size_of<i32>(), (i + 1) * size_of<i32>()]`, and then transmuting it to `i32`. In safe Rust,
-this operation requires boundary checks that are detrimental to performance.
-
-Usage of `unsafe` for performance reasons is justified only when all other alternatives have been exhausted and the performance benefits are sufficiently large (e.g. >~10%).
-
-### Considerations when introducing `unsafe`
-
-Usage of `unsafe` in this crate _must_:
-
-- not expose a public API as `safe` when there are necessary invariants for that API to be defined behavior.
-- have code documentation for why `safe` is not used / possible
-- have code documentation about which invariant the user needs to enforce to ensure [soundness](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#soundness-of-code--of-a-library), or which
-- invariant is being preserved.
-- if applicable, use `debug_assert`s to relevant invariants (e.g. bound checks)
-
-Example of code documentation:
-
-```rust
-// JUSTIFICATION
-// Benefit
-// Describe the benefit of using unsafe. E.g.
-// "30% performance degradation if the safe counterpart is used, see bench X."
-// Soundness
-// Describe why the code remains sound (according to the definition of rust's unsafe code guidelines). E.g.
-// "We bounded check these values at initialization and the array is immutable."
-let ... = unsafe { ... };
-```
-
-When adding this documentation to existing code that is not sound and cannot trivially be fixed, we should file
-specific JIRA issues and reference them in these code comments. For example:
-
-```rust
-// Soundness
-// This is not sound because .... see https://issues.apache.org/jira/browse/ARROW-nnnnn
-```
-
-# Releases and publishing to crates.io
-
-Please see the [release](../dev/release/README.md) for details on how to create arrow releases
diff --git a/parquet/CONTRIBUTING.md b/parquet/CONTRIBUTING.md
new file mode 100644
index 0000000..834b6af
--- /dev/null
+++ b/parquet/CONTRIBUTING.md
@@ -0,0 +1,61 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+## Build
+
+Run `cargo build` or `cargo build --release` to build in release mode.
+Some features take advantage of SSE4.2 instructions, which can be
+enabled by adding `RUSTFLAGS="-C target-feature=+sse4.2"` before the
+`cargo build` command.
+
+## Test
+
+Run `cargo test` for unit tests. To also run tests related to the binaries, use `cargo test --features cli`.
+
+## Binaries
+
+The following binaries are provided (use `cargo install --features cli` to install them):
+
+- **parquet-schema** for printing Parquet file schema and metadata.
+ `Usage: parquet-schema <file-path>`, where `file-path` is the path to a Parquet file. Use `-v/--verbose` flag
+ to print full metadata or schema only (when not specified only schema will be printed).
+
+- **parquet-read** for reading records from a Parquet file.
+ `Usage: parquet-read <file-path> [num-records]`, where `file-path` is the path to a Parquet file,
+ and `num-records` is the number of records to read from a file (when not specified all records will
+ be printed). Use `-j/--json` to print records in JSON lines format.
+
+- **parquet-rowcount** for reporting the number of records in one or more Parquet files.
+ `Usage: parquet-rowcount <file-paths>...`, where `<file-paths>...` is a space separated list of one or more
+ files to read.
+
+If you see `Library not loaded` error, please make sure `LD_LIBRARY_PATH` is set properly:
+
+```
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(rustc --print sysroot)/lib
+```
+
+## Benchmarks
+
+Run `cargo bench` for benchmarks.
+
+## Docs
+
+To build documentation, run `cargo doc --no-deps`.
+To compile and view in the browser, run `cargo doc --no-deps --open`.
diff --git a/parquet/README.md b/parquet/README.md
index b48e27e..0600e12 100644
--- a/parquet/README.md
+++ b/parquet/README.md
@@ -17,24 +17,13 @@
under the License.
-->
-# An Apache Parquet implementation in Rust
+# Apache Parquet Official Native Rust Implementation
[](https://crates.io/crates/parquet)
-## Usage
+This crate contains the official Native Rust implementation of [Apache Parquet](https://parquet.apache.org/), which is part of the [Apache Arrow](https://arrow.apache.org/) project.
-Add this to your Cargo.toml:
-
-```toml
-[dependencies]
-parquet = "^4"
-```
-
-and this to your crate root:
-
-```rust
-extern crate parquet;
-```
+## Example
Example usage of reading data:
@@ -51,7 +40,7 @@ while let Some(record) = iter.next() {
}
```
-See [crate documentation](https://docs.rs/crate/parquet/5.0.0-SNAPSHOT) on available API.
+See [crate documentation](https://docs.rs/crate/parquet) on available API.
## Upgrading from versions prior to 4.0
@@ -90,54 +79,6 @@ version is available. Then simply update version of `parquet-format` crate in Ca
- [ ] Predicate pushdown
- [x] Parquet format 2.6.0 support
-## Requirements
-
-Parquet requires LLVM. Our windows CI image includes LLVM but to build the libraries locally windows
-users will have to install LLVM. Follow [this](https://github.com/appveyor/ci/issues/2651) link for info.
-
-## Build
-
-Run `cargo build` or `cargo build --release` to build in release mode.
-Some features take advantage of SSE4.2 instructions, which can be
-enabled by adding `RUSTFLAGS="-C target-feature=+sse4.2"` before the
-`cargo build` command.
-
-## Test
-
-Run `cargo test` for unit tests. To also run tests related to the binaries, use `cargo test --features cli`.
-
-## Binaries
-
-The following binaries are provided (use `cargo install --features cli` to install them):
-
-- **parquet-schema** for printing Parquet file schema and metadata.
- `Usage: parquet-schema <file-path>`, where `file-path` is the path to a Parquet file. Use `-v/--verbose` flag
- to print full metadata or schema only (when not specified only schema will be printed).
-
-- **parquet-read** for reading records from a Parquet file.
- `Usage: parquet-read <file-path> [num-records]`, where `file-path` is the path to a Parquet file,
- and `num-records` is the number of records to read from a file (when not specified all records will
- be printed). Use `-j/--json` to print records in JSON lines format.
-
-- **parquet-rowcount** for reporting the number of records in one or more Parquet files.
- `Usage: parquet-rowcount <file-paths>...`, where `<file-paths>...` is a space separated list of one or more
- files to read.
-
-If you see `Library not loaded` error, please make sure `LD_LIBRARY_PATH` is set properly:
-
-```
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(rustc --print sysroot)/lib
-```
-
-## Benchmarks
-
-Run `cargo bench` for benchmarks.
-
-## Docs
-
-To build documentation, run `cargo doc --no-deps`.
-To compile and view in the browser, run `cargo doc --no-deps --open`.
-
## License
Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0.