--- title: "Contribute" --- # Contributing In this page, you will find some guidelines on contributing to Apache Iceberg. Please keep in mind that none of these are hard rules and they're meant as a collection of helpful suggestions to make contributing as seamless of an experience as possible. If you are thinking of contributing but first would like to discuss the change you wish to make, we welcome you to head over to the [Community](community.md) page on the official Iceberg documentation site to find a number of ways to connect with the community, including slack and our mailing lists. Of course, always feel free to just open a [new issue](https://github.com/apache/iceberg/issues/new) in the GitHub repo. You can also check the following for a [good first issue](https://github.com/apache/iceberg/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22). The Iceberg Project is hosted on GitHub at . ## Pull Request Process The Iceberg community prefers to receive contributions as [Github pull requests][github-pr-docs]. [View open pull requests][iceberg-prs] [iceberg-prs]: https://github.com/apache/iceberg/pulls [github-pr-docs]: https://help.github.com/articles/about-pull-requests/ * PRs are automatically labeled based on the content by our github-actions labeling action * It's helpful to include a prefix in the summary that provides context to PR reviewers, such as `Build:`, `Docs:`, `Spark:`, `Flink:`, `Core:`, `API:` * If a PR is related to an issue, adding `Closes #1234` in the PR description will automatically close the issue and helps keep the project clean * If a PR is posted for visibility and isn't necessarily ready for review or merging, be sure to convert the PR to a draft ## Apache Iceberg Improvement Proposals ### What is an improvement proposal? An improvement proposal is a major change to Apache Iceberg that may require changes to an existing specification, creation of a new specification, or significant additions/changes to any of the existing Iceberg implementations. Changes that are large in scope need to be considered carefully and incorporate feedback from many community stakeholders. ### What should a proposal include? 1. A GitHub issue created using the `Apache Iceberg Improvement Proposal` template 2. A document including the following: * Motivation for the change * Implementation proposal * Breaking changes/incompatibilities * Alternatives considered 3. A discussion thread initiated in the dev list with the Subject: '[DISCUSS] ' ### Who can submit a proposal? Anyone can submit a proposal, but be considerate and submit only if you plan on contributing to the implementation. ### Where can I find current proposals? Current proposals are tracked in GitHub issues with the label [Proposal][iceberg-proposals] ### How are proposals adopted? Once general consensus has been reached, a vote should be raised on the dev list. The vote follows the ASF [code modification][apache-vote] model with three positive PMC votes required and no lazy consensus modifier. The voting process should be held in good faith to reinforce and affirm the agreed upon proposal, not to settle disagreements or to force a decision. [iceberg-proposals]: https://github.com/apache/iceberg/issues?q=is%3Aissue+is%3Aopen+label%3Aproposal+ [apache-vote]: https://www.apache.org/foundation/voting.html#apache-voting-process ## Building the Project Locally Iceberg is built using Gradle with Java 8 or Java 11. * To invoke a build and run tests: `./gradlew build` * To skip tests: `./gradlew build -x test -x integrationTest` * To fix code style: `./gradlew spotlessApply` * To build particular Spark/Flink Versions: `./gradlew build -DsparkVersions=3.4,3.5 -DflinkVersions=1.14` Iceberg table support is organized in library modules: * `iceberg-common` contains utility classes used in other modules * `iceberg-api` contains the public Iceberg API * `iceberg-core` contains implementations of the Iceberg API and support for Avro data files, **this is what processing engines should depend on** * `iceberg-parquet` is an optional module for working with tables backed by Parquet files * `iceberg-arrow` is an optional module for reading Parquet into Arrow memory * `iceberg-orc` is an optional module for working with tables backed by ORC files * `iceberg-hive-metastore` is an implementation of Iceberg tables backed by the Hive metastore Thrift client * `iceberg-data` is an optional module for working with tables directly from JVM applications This project Iceberg also has modules for adding Iceberg support to processing engines: * `iceberg-spark` is an implementation of Spark's Datasource V2 API for Iceberg with submodules for each spark versions (use runtime jars for a shaded version) * `iceberg-flink` contains classes for integrating with Apache Flink (use iceberg-flink-runtime for a shaded version) * `iceberg-mr` contains an InputFormat and other classes for integrating with Apache Hive * `iceberg-pig` is an implementation of Pig's LoadFunc API for Iceberg ## Setting up IDE and Code Style ### Configuring Code Formatter for Eclipse/IntelliJ Follow the instructions for [Eclipse](https://github.com/google/google-java-format#eclipse) or [IntelliJ](https://github.com/google/google-java-format#intellij-android-studio-and-other-jetbrains-ides) to install the **google-java-format** plugin (note the required manual actions for IntelliJ). ## Semantic Versioning Apache Iceberg leverages [semantic versioning](https://semver.org/#semantic-versioning-200) to ensure compatibility for developers and users of the iceberg libraries as APIs and implementations evolve. The requirements and guarantees provided depend on the subproject as described below: ### Major Version Deprecations Required __Modules__ `iceberg-api` The API subproject is the main interface for developers and users of the Iceberg API and therefore has the strongest guarantees. Evolution of the interfaces in this subproject are enforced by [Revapi](https://revapi.org/) and require explicit acknowledgement of API changes. All public interfaces and classes require one major version for deprecation cycle. Any backward incompatible changes should be annotated as `@Deprecated` and removed for the next major release. Backward compatible changes are allowed within major versions. ### Minor Version Deprecations Required __Modules__ `iceberg-common` `iceberg-core` `iceberg-data` `iceberg-orc` `iceberg-parquet` Changes to public interfaces and classes in the subprojects listed above require a deprecation cycle of one minor release. These projects contain common and internal code used by other projects and can evolve within a major release. Minor release deprecation will provide other subprojects and external projects notice and opportunity to transition to new implementations. ### Minor Version Deprecations Discretionary __modules__ (All modules not referenced above) Other modules are less likely to be extended directly and modifications should make a good faith effort to follow a minor version deprecation cycle. If there are significant structural or design changes that result in deprecations being difficult to orchestrate, it is up to the committers to decide if deprecation is necessary. ## Deprecation Notices All interfaces, classes, and methods targeted for deprecation must include the following: 1. `@Deprecated` annotation on the appropriate element 2. `@depreceted` javadoc comment including: the version for removal, the appropriate alternative for usage 3. Replacement of existing code paths that use the deprecated behavior Example: ```java /** * Set the sequence number for this manifest entry. * * @param sequenceNumber a sequence number * @deprecated since 1.0.0, will be removed in 1.1.0; use dataSequenceNumber() instead. */ @Deprecated void sequenceNumber(long sequenceNumber); ``` ## Adding new functionality without breaking APIs When adding new functionality, make sure to avoid breaking existing APIs, especially within the scope of the API modules that are being checked by [Revapi](https://revapi.org/). Assume adding a `createBranch(String name)` method to the `ManageSnapshots` API. The most straight-forward way would be to add the below code: ```java public interface ManageSnapshots extends PendingUpdate { // existing code... // adding this method introduces an API-breaking change ManageSnapshots createBranch(String name); } ``` And then add the implementation: ```java public class SnapshotManager implements ManageSnapshots { // existing code... @Override public ManageSnapshots createBranch(String name, long snapshotId) { updateSnapshotReferencesOperation().createBranch(name, snapshotId); return this; } } ``` ### Checking for API breakages Running `./gradlew revapi` will flag this as an API-breaking change: ``` ./gradlew revapi > Task :iceberg-api:revapi FAILED > Task :iceberg-api:showDeprecationRulesOnRevApiFailure FAILED 1: Task failed with an exception. ----------- * What went wrong: Execution failed for task ':iceberg-api:revapi'. > There were Java public API/ABI breaks reported by revapi: java.method.addedToInterface: Method was added to an interface. old: new: method org.apache.iceberg.ManageSnapshots org.apache.iceberg.ManageSnapshots::createBranch(java.lang.String) SOURCE: BREAKING, BINARY: NON_BREAKING, SEMANTIC: POTENTIALLY_BREAKING From old archive: From new archive: iceberg-api-1.4.0-SNAPSHOT.jar If this is an acceptable break that will not harm your users, you can ignore it in future runs like so for: * Just this break: ./gradlew :iceberg-api:revapiAcceptBreak --justification "{why this break is ok}" \ --code "java.method.addedToInterface" \ --new "method org.apache.iceberg.ManageSnapshots org.apache.iceberg.ManageSnapshots::createBranch(java.lang.String)" * All breaks in this project: ./gradlew :iceberg-api:revapiAcceptAllBreaks --justification "{why this break is ok}" * All breaks in all projects: ./gradlew revapiAcceptAllBreaks --justification "{why this break is ok}" ---------------------------------------------------------------------------------------------------- ``` ### Adding a default implementation To avoid breaking the API, add a default implementation that throws an `UnsupportedOperationException`:` ```java public interface ManageSnapshots extends PendingUpdate { // existing code... // introduces new code without breaking the API default ManageSnapshots createBranch(String name) { throw new UnsupportedOperationException(this.getClass().getName() + " doesn't implement createBranch(String)"); } } ``` ## Iceberg Code Contribution Guidelines ### Style Java code adheres to the [Google style](https://google.github.io/styleguide/javaguide.html), which will be verified via `./gradlew spotlessCheck` during builds. In order to automatically fix Java code style issues, please use `./gradlew spotlessApply`. **NOTE**: The **google-java-format** plugin will always use the latest version of the **google-java-format**. However, `spotless` itself is configured to use **google-java-format** 1.7 since that version is compatible with JDK 8. When formatting the code in the IDE, there is a slight chance that it will produce slightly different results. In such a case please run `./gradlew spotlessApply` as CI will check the style against **google-java-format** 1.7. ### Copyright Each file must include the Apache license information as a header. ``` 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. ``` ### Configuring Copyright for IntelliJ IDEA Every file needs to include the Apache license as a header. This can be automated in IntelliJ by adding a Copyright profile: 1. In the **Settings/Preferences** dialog go to **Editor → Copyright → Copyright Profiles**. 2. Add a new profile and name it **Apache**. 3. Add the following text as the license text: ``` 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. ``` 4. Go to **Editor → Copyright** and choose the **Apache** profile as the default profile for this project. 5. Click **Apply**. ### Java style guidelines #### Method naming 1. Make method names as short as possible, while being clear. Omit needless words. 2. Avoid `get` in method names, unless an object must be a Java bean. * In most cases, replace `get` with a more specific verb that describes what is happening in the method, like `find` or `fetch`. * If there isn't a more specific verb or the method is a getter, omit `get` because it isn't helpful to readers and makes method names longer. 3. Where possible, use words and conjugations that form correct sentences in English when read * For example, `Transform.preservesOrder()` reads correctly in an if statement: `if (transform.preservesOrder()) { ... }` #### Boolean arguments Avoid boolean arguments to methods that are not `private` to avoid confusing invocations like `sendMessage(false)`. It is better to create two methods with names and behavior, even if both are implemented by one internal method. ```java // prefer exposing suppressFailure in method names public void sendMessageIgnoreFailure() { sendMessageInternal(true); } public void sendMessage() { sendMessageInternal(false); } private void sendMessageInternal(boolean suppressFailure) { ... } ``` When passing boolean arguments to existing or external methods, use inline comments to help the reader understand actions without an IDE. ```java // BAD: it is not clear what false controls dropTable(identifier, false); // GOOD: these uses of dropTable are clear to the reader dropTable(identifier, true /* purge data */); dropTable(identifier, purge); ``` #### Config naming 1. Use `-` to link words in one concept * For example, preferred convection `access-key-id` rather than `access.key.id` 2. Use `.` to create a hierarchy of config groups * For example, `s3` in `s3.access-key-id`, `s3.secret-access-key` ## Testing ### AssertJ Prefer using [AssertJ](https://github.com/assertj/assertj) assertions as those provide a rich and intuitive set of strongly-typed assertions. Checks can be expressed in a fluent way and [AssertJ](https://github.com/assertj/assertj) provides rich context when assertions fail. Additionally, [AssertJ](https://github.com/assertj/assertj) has powerful testing capabilities on collections and exceptions. Please refer to the [usage guide](https://assertj.github.io/doc/#assertj-core-assertions-guide) for additional examples. ```java // bad: will only say true != false when check fails assertTrue(x instanceof Xyz); // better: will show type of x when check fails assertThat(x).isInstanceOf(Xyz.class); // bad: will only say true != false when check fails assertTrue(catalog.listNamespaces().containsAll(expected)); // better: will show content of expected and of catalog.listNamespaces() if check fails assertThat(catalog.listNamespaces()).containsAll(expected); ``` ```java // ok assertNotNull(metadataFileLocations); assertEquals(metadataFileLocations.size(), 4); // better: will show the content of metadataFileLocations if check fails assertThat(metadataFileLocations).isNotNull().hasSize(4); // or assertThat(metadataFileLocations).isNotNull().hasSameSizeAs(expected).hasSize(4); ``` ```java // if any key doesn't exist, it won't show the content of the map assertThat(map.get("key1")).isEqualTo("value1"); assertThat(map.get("key2")).isNotNull(); assertThat(map.get("key3")).startsWith("3.5"); // better: all checks can be combined and the content of the map will be shown if any check fails assertThat(map) .containsEntry("key1", "value1") .containsKey("key2") .hasEntrySatisfying("key3", v -> assertThat(v).startsWith("3.5")); ``` ```java // bad try { catalog.createNamespace(deniedNamespace); Assert.fail("this should fail"); } catch (Exception e) { assertEquals(AccessDeniedException.class, e.getClass()); assertEquals("User 'testUser' has no permission to create namespace", e.getMessage()); } // better assertThatThrownBy(() -> catalog.createNamespace(deniedNamespace)) .isInstanceOf(AccessDeniedException.class) .hasMessage("User 'testUser' has no permission to create namespace"); ``` Checks on exceptions should always make sure to assert that a particular exception message has occurred. ### Awaitility Avoid using `Thread.sleep()` in tests as it leads to long test durations and flaky behavior if a condition takes slightly longer than expected. ```java deleteTablesAsync(); Thread.sleep(3000L); assertThat(tables()).isEmpty(); ``` A better alternative is using [Awaitility](https://github.com/awaitility/awaitility) to make sure `tables()` are eventually empty. The below example will run the check with a default polling interval of **100 millis**: ```java deleteTablesAsync(); Awaitility.await("Tables were not deleted") .atMost(5, TimeUnit.SECONDS) .untilAsserted(() -> assertThat(tables()).isEmpty()); ``` Please refer to the [usage guide](https://github.com/awaitility/awaitility/wiki/Usage) of [Awaitility](https://github.com/awaitility/awaitility) for more usage examples. ### JUnit4 / JUnit5 Iceberg currently uses a mix of JUnit4 (`org.junit` imports) and JUnit5 (`org.junit.jupiter.api` imports) tests. To allow an easier migration to JUnit5 in the future, new test classes that are being added to the codebase should be written purely in JUnit5 where possible. ## Running Benchmarks Some PRs/changesets might require running benchmarks to determine whether they are affecting the baseline performance. Currently there is no "push a single button to get a performance comparison" solution available, therefore one has to run JMH performance tests on their local machine and post the results on the PR. See [Benchmarks](benchmarks.md) for a summary of available benchmarks and how to run them.