// 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.

[[prior_release_notes]]
= Apache Kudu Prior Version Release Notes

:author: Kudu Team
:imagesdir: ./images
:icons: font
:toc: left
:toclevels: 3
:doctype: book
:backend: html5
:sectlinks:
:experimental:

This section reproduces the release notes for new features and incompatible
changes in prior releases of Apache Kudu.


NOTE: The list of known issues and limitations for prior releases are not
reproduced on this page. Please consult the
link:http://kudu.apache.org/releases/[documentation of the appropriate release]
for a list of known issues and limitations.

[[rn_1.17.0]]
= Apache Kudu 1.17.0 Release Notes

[[rn_1.17.0_upgrade_notes]]
== Upgrade Notes

** TLSv1.2 is the minimum TLS protocol version that newer Kudu clients are able to use for secure
Kudu RPC. The newer clients are not able to communicate with servers built and run with OpenSSL of
versions prior to 1.0.1.  If such a Kudu cluster is running on a deprecated OS versions
(e.g., RHEL/CentOS 6.4), the following options are available to work around the incompatibility:
* use Kudu clients of 1.14 or earlier versions to communicate with such cluster
* disable RPC encryption and authentication for Kudu RPC, setting `--rpc_authentication=disabled`
and `--rpc_encryption=disabled` for all masters and tablet servers in the cluster to allow the new
client to work with the old cluster

** TLSv1.2 is the minimum TLS protocol version that newer Kudu servers are able to use for secure
Kudu RPC. The newer servers are not able to communicate using secure Kudu RPC with Kudu C++ client
applications linked with libkudu_client library built against OpenSSL of versions prior to 1.0.1 or
with Java client applications run with outdated Java runtime that doesn't support TLSv1.2.  The
following options are available to work around this incompatibility:
* customize settings for the `--rpc_tls_min_protocol` and `--rpc_tls_ciphers` flags on all masters
and tablet servers in the cluster, setting `--rpc_tls_min_protocol=TLSv1` and adding TLSv1-capable
cipher suites (e.g. AES128-SHA and AES256-SHA) into the list
* disable RPC encryption and authentication for Kudu RPC, setting `--rpc_authentication=disabled`
and `--rpc_encryption=disabled` for all masters and tablet servers in the cluster to allow such Kudu
clients to work with newer clusters

[[rn_1.17.0_obsoletions]]
== Obsoletions


[[rn_1.17.0_deprecations]]
== Deprecations

Support for Python 2.x and Python 3.4 and earlier is deprecated and may be removed in the next minor
release.

[[rn_1.17.0_new_features]]
== New features

* Kudu now supports encrypting data at rest. Kudu supports `AES-128-CTR`, `AES-192-CTR`, and
`AES-256-CTR` ciphers to encrypt data, supports Apache Ranger KMS and Apache Hadoop KMS. See
link:https://kudu.apache.org/docs/security.html#_data_at_rest_[Data at rest] for more details.

* Kudu now supports range-specific hash schemas for tables. It's now possible to add ranges with
their own unique hash schema independent of the table-wide hash schema. This can be done at table
creation time and while altering the table. It’s controlled by the `--enable_per_range_hash_schemas`
master flag which is enabled by default (see
link:https://issues.apache.org/jira/browse/KUDU-2671[KUDU-2671]).

* Kudu now supports soft-deleted tables. Kudu keeps a soft-deleted table aside for a period of time
(a.k.a. reservation), not purging the data yet.  The table can be restored/recalled back before its
reservation expires.  The reservation period can be customized via Kudu client API upon
soft-deleting the table.  The default reservation period is controlled by the
`--default_deleted_table_reserve_seconds` master's flag.
NOTE: As of Kudu 1.17 release, the soft-delete functionality is not supported when HMS integration
is enabled, but this should be addressed in a future release (see
link:https://issues.apache.org/jira/browse/KUDU-3326[KUDU-3326]).

* Introduced `Auto-Incrementing` column. An auto-incrementing column is populated on the server side
with a monotonically increasing counter. The counter is local to every tablet, i.e. each tablet has
a separate auto incrementing counter (see
link:https://issues.apache.org/jira/browse/KUDU-1945[KUDU-1945]).

* Kudu now supports experimental non-unique primary key. When a table with non-unique primary key is
created, an `Auto-Incrementing` column named `auto_incrementing_id` is added automatically to the
table as the key column. The non-unique key columns and the `Auto-Incrementing` column together form
the effective primary key (see link:https://issues.apache.org/jira/browse/KUDU-1945[KUDU-1945]).

* Introduced `Immutable` column. It's useful to represent a semantically constant entity (see
link:https://issues.apache.org/jira/browse/KUDU-3353[KUDU-3353]).

* An experimental feature is added to Kudu that allows it to automatically rebalance tablet leader
replicas among tablet servers. The background task can be enabled by setting the
`--auto_leader_rebalancing_enabled` flag on the Kudu masters. By default, the flag is set to 'false'
(see link:https://issues.apache.org/jira/browse/KUDU-3390[KUDU-3390]).

* Introduced an experimental feature: authentication of Kudu client applications to Kudu servers
using JSON Web Tokens (JWT).  The JWT-based authentication can be used as an alternative to Kerberos
authentication for Kudu applications running at edge nodes where configuring Kerberos might be
cumbersome.  Similar to Kerberos credentials, a JWT is considered a primary client's credentials.
The server-side capability of JWT-based authentication is controlled by the
`--enable_jwt_token_auth` flag (set 'false' by default).  When the flat set to 'true', a Kudu server
is capable of authenticating Kudu clients using the JWT provided by the client during RPC connection
negotiation.  From its side, a Kudu client authenticates a Kudu server by verifying its TLS
certificate.  For the latter to succeed, the client should use Kudu client API to add the cluster's
IPKI CA certificate into the list of trusted certificates.

* The C++ client scan token builder can now create multiple tokens per tablet. So, it's now possible
to dynamically scale the set of readers/scanners fetching data from a Kudu table in parallel. To use
this functionality, use the newly introduced `SetSplitSizeBytes()` method of the Kudu client API to
specify how many bytes of data each token should scan
(see link:https://issues.apache.org/jira/browse/KUDU-3393[KUDU-3393]).

* Kudu's default replica placement algorithm is now range and table aware to prevent hotspotting
unlike the old power of two choices algorithm. New replicas from the same range are spread evenly
across available tablet servers, the table the range belongs to is used as a tiebreaker (see
link:https://issues.apache.org/jira/browse/KUDU-3476[KUDU-3476]).

* Statistics on various write operations is now available via Kudu client API at the session level
(see link:https://issues.apache.org/jira/browse/KUDU-3351[KUDU-3351],
link:https://issues.apache.org/jira/browse/KUDU-3365[KUDU-3365]).

* Kudu now exposes all its metrics except for string gauges in Prometheus format via the embedded
webserver's `/metrics_prometheus` endpoint (see
link:https://issues.apache.org/jira/browse/KUDU-3375[KUDU-3375]).

* It’s now possible to deploy Kudu clusters in an internal network (e.g. in K8S environment) and
avoid internal traffic (i.e. tservers and masters) using advertised addresses and allow Kudu clients
running in external networks. This can be achieved by customizing the setting for the newly
introduced `--rpc_proxy_advertised_addresses` and `--rpc_proxied_addresses` server flags. This might
be useful in various scenarios where Kudu cluster is running in an internal network behind a
firewall, but Kudu clients are running at the other side of the firewall using JWT to authenticate
to Kudu servers, and the RPC traffic between to the Kudu cluster is forwarded through a TCP/SOCKS
proxy (see link:https://issues.apache.org/jira/browse/KUDU-3357[KUDU-3357]).

* It’s now possible to clean up metadata for deleted tables/tablets from Kudu master's in-memory map
and the `sys.catalog` table.  This is useful in reducing the memory consumption and bootstrap time
for masters. This can be achieved by customizing the setting for the newly introduced
`--enable_metadata_cleanup_for_deleted_tables_and_tablets` and
`--metadata_for_deleted_table_and_tablet_reserved_secs` kudu-master’s flags.

* It’s now possible to perform range rebalancing for a single table per run in the `kudu cluster
rebalance` CLI tool by setting the newly introduced `--enable_range_rebalancing` tool flag.  This is
useful to address various hot-spotting issues when too many tablet replicas from the same range (but
different hash buckets) were placed at the same tablet server.  The hot-spotting issue in tablet
replica placement should be address in a follow-up releases, see
link:https://issues.apache.org/jira/browse/KUDU-3476[KUDU-3476] for details.

* It’s now possible to compact log container metadata files at runtime.  This is useful in
reclaiming the disk space once the container becomes full. This feature can be turned on/off by
customizing the setting for the newly introduced `--log_container_metadata_runtime_compact`
kudu-tserver flag (see link:https://issues.apache.org/jira/browse/KUDU-3318[KUDU-3318]).

* New CLI tools `kudu master/tserver set_flag_for_all` are added to update flags for all masters and
tablet servers in a Kudu cluster at once.

* A new CLI tool `kudu local_replica copy_from_local` is added to copy tablet replicas' data at the
filesystem level. It can be used when adding disks and for quick rebalancing of data between disks,
or can be used when migrating data from one data directory to the other. It will make data more
dense than data on old data directories too.

* A new CLI tool `kudu diagnose parse_metrics` is added to parse metrics out of diagnostic logs (see
link:https://issues.apache.org/jira/browse/KUDU-2353[KUDU-2353]).

* A new CLI tool `kudu local_replica tmeta delete_rowsets` is added to delete rowsets from the
tablet.

* A sanity check has been added to detect wall clock jumps, it is controlled by the newly introduced
`--wall_clock_jump_detection` and `--wall_clock_jump_threshold_sec` flags. That should help to
address issues reported in link:https://issues.apache.org/jira/browse/KUDU-2906[KUDU-2906].

[[rn_1.17.0_improvements]]
== Optimizations and improvements

* Reduce the memory consumption if there are frequent alter schema operations for tablet servers
(see link:https://issues.apache.org/jira/browse/KUDU-3197[KUDU-3197]).

* Reduce the memory consumption by implementing memory budgeting for performing RowSet merge
compactions (i.e. CompactRowSetsOp maintenance operations). Several flags have been introduced,
while the `--rowset_compaction_memory_estimate_enabled` flag indicates whether to check for
available memory necessary to run CompactRowSetsOp maintenance operations (see
link:https://issues.apache.org/jira/browse/KUDU-3406[KUDU-3406]).

* Optimized evaluating in-list predicates based on RowSet PK bounds.  A tablet server can now
effectively skip rows when the predicate is on a non-prefix part of the primary key and the leading
columns' cardinality is 1 (see link:https://issues.apache.org/jira/browse/KUDU-1644[KUDU-1644]).

* Speed up CLI tool `kudu cluster rebalance` to run intra-location rebalancing in parallel for
location-aware Kudu cluster. Theoretically, running intra-location rebalancing in parallel might
shorten the runtime by N times compared with running sequentially, where N is the number of
locations in a Kudu cluster. This can be achieved by customizing the setting for the newly
introduced `--intra_location_rebalancing_concurrency` flag.

* Two new flags `--show_tablet_partition_info` and `--show_hash_partition_info` have been introduced
for the `kudu table list` CLI tool to show the corresponding relationship between partitions and
tablet ids, and it's possible to specify the output format by specifying
`--list_table_output_format` flag.

* A new flag `--create_table_replication_factor` has been introduced for the `kudu table copy` CLI
tool to specify the replication factor for the destination table.

* A new flag `--create_table_hash_bucket_nums` has been introduced for the `kudu table copy` CLI
tool to specify the number of hash buckets in each hash dimension for the destination table.

* A new flag `--tables` has been introduced for the `kudu master unsafe_rebuild` CLI tool to rebuild
the metadata of specified tables on Kudu master, and it has no effect on the other tables.

* A new flag `--fault_tolerant` has been introduced for the `kudu table copy/scan` and
`kudu perf table_scan` CLI tool to make the scanner fault-tolerant and the results returned in
primary key order per-tablet.

* A new flag `--show_column_comment` has been introduced for the `kudu table describe` CLI tool to
show column comments.

* A new flag `--current_leader_uuid` has been introduced for the `kudu tablet leader_step_down` CLI
tool to conveniently step down leader replica using a given UUID.

* A new flag `--use_readable_format` has been introduced for the `kudu local_replica dump rowset`
CLI tool to indicate whether to dump the primary key in human readable format. Besides, another flag
`--dump_primary_key_bounds_only` has been introduced to this tool to indicate whether to dump rowset
primary key bounds only.

* A new flag `--tables` has been introduced for the `kudu local_replica delete` CLI tool to
conveniently delete multiple tablets by table name.

* It’s now possible to specify `owner` and `comment` fields when using the `kudu table create` CLI
tool to create tables.

* It’s now possible to use the `kudu local_replica copy_from_remote` CLI tool to copy tablets in a
batch.

* It’s now possible to enable or disable auto rebalancer by setting `--auto_rebalancing_enabled`
flag to Kudu master at runtime.

* It’s now possible for `kudu tserver/master get_flags` CLI tool to filter flags even if the server
side doesn’t support flags filter function (the latter is for Kudu servers of releases prior to
1.12).

* Added a CSP (Content Security Policy) header to prevent security scanners flagging Kudu's web UI
as vulnerable.

* A separated section has been introduced to include all non-default flags specially on path `/varz`
of Kudu's web UI.

* A separated section has been introduced to show slow scans on path `/scans` of Kudu's web UI, it
can be enabled by tweaking the `--show_slow_scans` flag for tablet servers. A scan is called 'slow'
if it takes more time than defined by `--slow_scanner_threshold_ms`.

* A new `Data retained` column has been introduced to the `Non-running operations` section to
indicate the approximate amount of disk space that would be freed on path `/maintenance-manager` of
Kudu's web UI.

* The default value of tablet history retention time (controlled by `--tablet_history_max_age_sec`
flag) on Kudu master has been reduced from 7 days to 5 minutes. It's not necessary to keep such a
long history of the system tablet since masters always scan data at the latest available snapshot.

* Kudu can now be built and run on Apple M chips and macOS 11, 12. As with prior releases, Kudu's
support for macOS is experimental, and should only be used for development.

[[rn_1.17.0_fixed_issues]]
== Fixed Issues

* Fixed an issue where historical MVCC data older than the ancient history mark (configured by
`--tablet_history_max_age_sec`) that had only DELETE operations wouldn't be compacted correctly. As
a result, the ancient history data could not be GCed if the tablet had been created by Kudu servers
of releases prior to 1.10 (those versions did not support live row counting) (see
link:https://issues.apache.org/jira/browse/KUDU-3367[KUDU-3367]).

* Fixed an issue where the Kudu server could potentially crash on malicious negotiation attempts.

* Fixed a bug when a Kudu tablet server started under an OS account that had no permission to access
tablet metadata files would stuck in the tablet bootstrapping phase (see
link:https://issues.apache.org/jira/browse/KUDU-3419[KUDU-3419]).

* Fixed a bug in the C++ client where toggling `SetFaultTolerant(false)` would not work.

* Fixed a bug in the C++ client where toggling `KuduScanner::SetSelection()` would not work.

* Fixed a bug in the Java client where under certain conditions same rows would be returned multiple
times even if the scanner was configured to be fault-tolerant.

* Fixed a bug in the Java client where the last propagated timestamp and resource metrics would not
be updated in subsequent scan responses.

* Fixed a bug in the Java client where it would not invalidate stale locations of the leader master.

* Fixed a bug in the Kudu HMS client that was causing failures when scanning Kudu tables from Hive
(see link:https://issues.apache.org/jira/browse/KUDU-3401[KUDU-3401]).

* Fixed a bug where the `kudu table copy` CLI tool would fail copying an unpartitioned table.

* Fixed a bug where the `kudu master unsafe_rebuild` CLI tool would rebuild the system catalog with
outdated schemas of tables that were unhealthy during the rebuild process.

* Fixed a bug where `kudu table copy` failed to copy tables that had STRING, BINARY or VARCHAR type
of columns in their range keys (see
link:https://issues.apache.org/jira/browse/KUDU-3306[KUDU-3306]).

* Fixed a bug of the `kudu table copy` CLI tool crashing if encountering an error while copying rows
to the destination table. The tool now exits gracefully and provides additional information for
troubleshooting in such a condition.

* Fixed a bug where the `kudu local_replica list` CLI tool would crash if the `--list_detail` flag
was enabled.

* Fixed a bug when a sub-process running Ranger client would crash when receiving a oversized
message from Kudu master.  With the fix, each peer communicating via the Subprocess protocol now
discards an oversized message, logs about the issue, and clears the channel, and is able to receive
further messages after encountering such a condition.

* Fixed a bug when a Kudu application linked with kudu_client library would crash with SIGILL if
running on a machine lacking SSE4.2 support (see
link:https://issues.apache.org/jira/browse/KUDU-3248[KUDU-3248]).

* Fixed a bug where the subprocess crashes in case of receiving large messages from the Kudu master
when the pipe gets full to transport the entire message in one go or when there is a delay in
sending from the master (see
link:https://issues.apache.org/jira/browse/KUDU-3489[KUDU-3489]).

[[rn_1.17.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.17.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.17 clients may connect to servers running Kudu 1.0 or later. If the client uses
features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.16 and Kudu 1.17 servers is believed to be possible
though has not been sufficiently tested. Users are encouraged to shut down all nodes
in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.17 with the exception of the
below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.17 and versions earlier than 1.3:

* If a Kudu 1.17 cluster is configured with authentication or encryption set to "required",
clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.17 cluster is configured with authentication and encryption set to "optional"
or "disabled", older clients will still be able to connect.

[[rn_1.17.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.17.0


[[rn_1.17.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.17 Java client library is API- and ABI-compatible with Kudu 1.16. Applications written
against Kudu 1.16 will compile and run against the Kudu 1.17 client library. Applications written
against Kudu 1.17 will compile and run against the Kudu 1.16 client library unless they use the
API newly introduced in Kudu 1.17.

* The Kudu 1.17 {cpp} client is API- and ABI-forward-compatible with Kudu 1.16. Applications written
and compiled against the Kudu 1.16 client library will run without modification against the Kudu
1.17 client library. Applications written and compiled against the Kudu 1.17 client library will
run without modification against the Kudu 1.16 client library unless they use the API newly
introduced in Kudu 1.17.

* The Kudu 1.17 Python client is API-compatible with Kudu 1.16. Applications
written against Kudu 1.16 will continue to run against the Kudu 1.17 client
and vice-versa.

[[rn_1.17.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.17.0_contributors]]
== Contributors

Kudu 1.17.0 includes contributions from 26 people, including 12 first-time contributors:

* Ashwani Raina
* Hari Reddy
* Kurt Deschler
* Marton Greber
* Song Jiacheng
* Zoltan Martonka
* bsglz
* mammadli.khazar
* wzhou-code
* xinghuayu007
* xlwh
* Ádám Bakai

Thank you for your contributions!

[[rn_1.16.0]]
= Apache Kudu 1.16.0 Release Notes

[[rn_1.16.0_upgrade_notes]]
== Upgrade Notes

[[rn_1.16.0_deprecations]]
== Deprecations
* Support for Python 2.x and Python 3.4 and earlier is deprecated and may be
removed in the next minor release.

[[rn_1.16.0_new_features]]
== New features

* Clients can now require authentication and encryption instead of depending on
server-side settings
(link:https://issues.apache.org/jira/browse/KUDU-1921[KUDU-1921]).

* Kudu Masters now automatically attempt to add themselves to an existing
cluster if there is a healthy Raft quorum among Kudu Masters.

* A new tool `kudu master unsafe_rebuild` is added to reconstruct the master
catalog from tablet metadata collected from tablet servers. This can be used
in emergencies to restore access to tables when all masters are unavailable.

* A new tool `kudu table set_replication_factor` is added to alter the
replication factor of a table. The tool immediately updates table metadata in
the master, and the master will asynchronously effect the new replication
factor. Progress can be monitored by running `ksck`.

* It’s now possible to require a minimum replication factor for a Kudu table.
This can be achieved by customizing the setting for the newly introduced
`--min_num_replicas` kudu-master’s flag. For example, setting
`--min_num_replicas=3` enforces every newly created table to have at least 3
replicas for each of its tablets, so there cannot be a data loss when just a
single tablet server in the cluster fails irrecoverably. For the sake of
backward compatibility, `--min_num_replicas` is set to 1 by default.

* It’s now possible to track startup progress on the `/startup` page on the web
UI. There are also metrics added to track the overall server startup progress
as well as the processing of the log block containers and starting of the
tablets (link:https://issues.apache.org/jira/browse/KUDU-1959[KUDU-1959]).

* A new tool `kudu table add_column` is added to add columns to existing tables
using the CLI
(link:https://issues.apache.org/jira/browse/KUDU-3339[KUDU-3339]).

* A new tool `kudu tserver unregister` is added to remove a dead tablet server
from the cluster without restarting the masters
(link:https://issues.apache.org/jira/browse/KUDU-2915[KUDU-2915]).


[[rn_1.16.0_improvements]]
== Optimizations and improvements

* Kudu will now more aggressively fsync consensus-related metadata when metadata
is configured to be on an XFS mount. This may lead to increased contention on
the device that backs metadata, but will prevent corruption in the event of an
outage (link:https://issues.apache.org/jira/browse/KUDU-2195[KUDU-2195]).

* A clearer message is logged when the Ranger subprocess crashes, to specify a
problem with the Ranger client.

* Two new flags have been introduced for the `kudu table scan` and `kudu perf
table_scan` CLI tools: `--row_count_only` and `--report_scanner_stats`. With
these new flags, the above mentioned CLI tools allow to issue scan requests
equivalent to running “SELECT COUNT(1) FROM <table_name>” from impala-shell.
These new provisions are useful in detecting and troubleshooting scan
performance issues.

* Added replica selection configuration knob for the `kudu table scan` and `kudu
perf table_scan` CLI tools: it’s controlled by the `--replica_selection` flag.

* To improve security, the following flags are now marked as sensitive and will
be redacted in the logs and WebUI when the redaction is enabled:
** `--webserver_private_key_file`
** `--webserver_private_key_password_cmd`
** `--webserver_password_file`

* The logic to select the effective time source when running with
`--time_source=auto` has been updated. The `builtin` time source would be
auto-selected if a Kudu server runs with `--time_source=auto` in an
environment where the instance detector isn't aware of dedicated NTP servers
AND the `--builtin_ntp_servers` flag is set to a valid value. Otherwise, if
`--builtin_ntp_servers` flag is set to an empty or invalid value, the
effective time source becomes `system` for platforms supporting the
`get_ntptime()` API, otherwise the catch-all case selects the `system_unsync`
as the time effective source.

* It is now possible to print or edit PBC files in batch using the `kudu pbc`
CLI tool, and also to format its JSON input/output as “pretty”.

* Client connection timeout is now configurable in the Java client
(link:https://issues.apache.org/jira/browse/KUDU-3240[KUDU-3240]).

* A new `/healthz` endpoint is now available on the kudu-master and tablet-server
embedded web servers for liveness checks
(link:https://issues.apache.org/jira/browse/KUDU-3308[KUDU-3308]).

* Hive Metastore URI is now logged to the console when connecting via `kudu hms`
CLI tool (link:https://issues.apache.org/jira/browse/KUDU-3189[KUDU-3189]).

* It is now possible to start up a master when there is an additional master
address present in the master addresses flag
(link:https://issues.apache.org/jira/browse/KUDU-3311[KUDU-3311]).

* Table entity is now accessible in `KuduWriteOperation` in the C++ client,
making understanding errors on the client side easier
(link:https://issues.apache.org/jira/browse/KUDU-2623[KUDU-2623]).

* The rebalancer tool now doesn’t move replicas to tablet servers in maintenance
mode (link:https://issues.apache.org/jira/browse/KUDU-3328[KUDU-3328]).

* Improved the performance of the run length encoding (RLE).

[[rn_1.16.0_fixed_issues]]
== Fixed Issues
* Log4J used in Ranger subprocess was upgraded to 2.17.1 which contains patches
go several security vulnerabilities
(link:https://nvd.nist.gov/vuln/detail/CVE-2021-44832[CVE-2021-44832],
link:https://nvd.nist.gov/vuln/detail/CVE-2021-45105[CVE-2021-45105],
link:https://nvd.nist.gov/vuln/detail/CVE-2021-45046[CVE-2021-45046], and
link:https://nvd.nist.gov/vuln/detail/CVE-2021-44228[CVE-2021-44228]).

* Kudu servers previously crashed if hostnames became unresolvable via DNS (e.g.
if the container hosting a server were destroyed). Such errors are now treated
as transient and the lookups are retried periodically. See
link:https://issues.apache.org/jira/browse/KUDU-75[KUDU-75],
link:https://issues.apache.org/jira/browse/KUDU-1620[KUDU-1620],
and link:https://issues.apache.org/jira/browse/KUDU-1885[KUDU-1885] for more details.

* Fixed an issue in Kudu Java client where concurrent flushing of data buffers
could lead to errors reported as 'java.lang.AssertionError: This Deferred was
already called'
(link:https://issues.apache.org/jira/browse/KUDU-3277[KUDU-3277]).

* Fixed Kudu RPC negotiation issue when running with cyrus-sasl-gssapi-2.1.27-5
and newer versions of the RPM package. A failed RPC connection negotiation
attempt would result in an error logged along with the full connection
negotiation trace: `Runtime error: SASL(-15): mechanism too weak for this
user: Unable to find a callback: 32775`
(link:https://issues.apache.org/jira/browse/KUDU-3297[KUDU-3297]).

* Fixed crash in kudu-master and kudu-tserver when running with kernel where the
`getrandom(2)` API is not available (versions of Linux kernel prior to 3.17).

* Fixed bug which could lead to exhaustion of the address space for the outgoing
connections on a busy Kudu cluster
(link:https://issues.apache.org/jira/browse/KUDU-3352[KUDU-3352]).

* Fixed a bug in the Java client where a malformed tablet server ID in the scan
token causes connection failures and timeouts in some cases
(link:https://issues.apache.org/jira/browse/KUDU-3349[KUDU-3349]).

* Fixed a bug where the rebalancer failed with `-ignored_tservers` flag
(link:https://issues.apache.org/jira/browse/KUDU-3346[KUDU-3346]).

[[rn_1.16.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.16.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.16 clients may connect to servers running Kudu 1.0 or later. If the client uses
features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.15 and Kudu 1.16 servers is believed to be possible
though has not been sufficiently tested. Users are encouraged to shut down all nodes
in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.16 with the exception of the
below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.16 and versions earlier than 1.3:

* If a Kudu 1.16 cluster is configured with authentication or encryption set to "required",
clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.16 cluster is configured with authentication and encryption set to "optional"
or "disabled", older clients will still be able to connect.

[[rn_1.16.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.16.0

[[rn_1.16.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.16 Java client library is API- and ABI-compatible with Kudu 1.15. Applications
written against Kudu 1.15 will compile and run against the Kudu 1.16 client library and
vice-versa.

* The Kudu 1.16 {cpp} client is API- and ABI-forward-compatible with Kudu 1.15.
Applications written and compiled against the Kudu 1.15 client library will run without
modification against the Kudu 1.16 client library. Applications written and compiled
against the Kudu 1.16 client library will run without modification against the Kudu 1.15
client library.

* The Kudu 1.16 Python client is API-compatible with Kudu 1.15. Applications
written against Kudu 1.15 will continue to run against the Kudu 1.16 client
and vice-versa.

[[rn_1.16.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.16.0_contributors]]
== Contributors

Kudu 1.16.0 includes contributions from 17 people, including 5 first-time contributors:

* Riza Suminto
* Zoltan Chovan
* kedeng
* khazarmammadli
* yejiabao

Thank you for your contributions!

[[rn_1.15.0]]
= Apache Kudu 1.15.0 Release Notes

[[rn_1.15.0_upgrade_notes]]
== Upgrade Notes

[[rn_1.15.0_obsoletions]]
== Obsoletions

* The `kudu-mapreduce` integration has been removed in the 1.15.0 release.
Similar functionality and capabilities now exist via the Apache Spark, Apache Hive, Apache Impala,
and Apache NiFi integrations. See link:https://issues.apache.org/jira/browse/KUDU-3142[KUDU-3142]
for details.

[[rn_1.15.0_deprecations]]
== Deprecations

* Support for Python 2.x and Python 3.4 and earlier is deprecated and may be removed in the next minor
release.

[[rn_1.15.0_new_features]]
== New features

* Kudu now experimentally supports multi-row transactions. Currently only `INSERT` and
`INSERT_IGNORE` operations are supported.
See link:https://github.com/apache/kudu/blob/master/docs/design-docs/transactions.adoc[here] for a
design overview of this feature.

* Kudu now supports Raft configuration change for Kudu masters and CLI tools for orchestrating
addition and removal of masters in a Kudu cluster. These tools substantially simplify the process
of migrating to multiple masters, recovering a dead master and removing masters from a Kudu cluster.
For detailed steps, see the latest administration documentation. This feature is evolving and
the steps to add, remove and recover masters may change in the future.
See link:https://issues.apache.org/jira/browse/KUDU-2181[KUDU-2181] for details.

* Kudu now supports table comments directly on Kudu tables which are automatically synchronized
when the Hive Metastore integration is enabled. These comments can be added at table creation time
and changed via table alteration.

* Kudu now experimentally supports per-table size limits based on leader disk space usage or number
of rows. When generating new authorization tokens, Masters will now consider the size limits and
strip tokens of `INSERT` and `UPDATE` privileges if either limit is reached. To enable this feature,
set the `--enable_table_write_limit` master flag; adjust the `--table_disk_size_limit` and
`--table_row_count_limit` flags as desired or use the `kudu table set_limit` tool to set limits per
table.

[[rn_1.15.0_improvements]]
== Optimizations and improvements

* It is now possible to change the Kerberos Service Principal Name using the `--principal` flag. The
default SPN is still `kudu/_HOST`. Clients connecting to a cluster using a non-default SPN must set
the `sasl_protocol_name` or `saslProtocolName` to match the SPN base
(i.e. “kudu” if the SPN is “kudu/_HOST”) in the client builder or the Kudu CLI.
See link:https://issues.apache.org/jira/browse/KUDU-1884[KUDU-1884] for details.

* Kudu RPC now supports TLSv1.3.  Kudu servers and clients automatically negotiate TLSv1.3 for Kudu
RPC if OpenSSL (or Java runtime correspondingly) on each side supports TLSv1.3.
If necessary, use the newly introduced flag `--rpc_tls_ciphersuites` to customize TLSv1.3-specific
cipher suites at the server side.
See link:https://issues.apache.org/jira/browse/KUDU-2871[KUDU-2871] for details.

* TLS ciphers renegotiation for TLSv1.2 and prior protocol versions is now explicitly disabled.
See link:https://issues.apache.org/jira/browse/KUDU-1926[KUDU-1926] for details.

* The location assignment for Kudu clients is now disabled by default since it doesn’t bring a lot
of benefits, but rather puts an extra load to Kudu masters.  This change reduces the load on Kudu
masters which is essential if too many clients run in a cluster.  To enable the location assignment
for clients, override the default by setting `--master_client_location_assignment_enabled=true` for
Kudu masters.

* The behavior of the C++ client replica selection for closest replica, the default, was updated to
match the behavior of the Java client. Instead of picking a random replica each time, a static value
is used for each process ensuring that the selection remains deterministic and can benefit from
better caching. See link:https://issues.apache.org/jira/browse/KUDU-3248[KUDU-3248] for details.

* The Web UI /rpcz endpoint now displays information on whether an RPC connection is protected by
TLS, and if so, provides information on the negotiated TLS cipher suite.

* Tooling requests and C++ client requests bound for leader masters will now be retried in the event
the masters cannot be reached.

* Cluster tooling will now validate that the master argument contains no duplicate values.
See link:https://issues.apache.org/jira/browse/KUDU-3226[KUDU-3226] for details.

* The error message output by Kudu Java client in an attempt to write into a non-existent table
partition now contains the table’s name.
See link:https://issues.apache.org/jira/browse/KUDU-3267[KUDU-3267] for details.

[[rn_1.15.0_fixed_issues]]
== Fixed Issues

* Fixed a bug in the Kudu tablet servers that could result in a crash when performing an incremental
backup of rows that had many batches of updates.
See link:https://issues.apache.org/jira/browse/KUDU-3291[KUDU-3291] for more details.

* The Kudu Java client will now retry scans bound for tablets hosted on quiescing tablet servers at
replicas on other tablet servers. See
link:https://issues.apache.org/jira/browse/KUDU-3213[KUDU-3213] for more details.

* Fixed a race between the scheduling of a maintenance op and the destruction of a tablet. This
could previously lead to a crash.
See link:https://issues.apache.org/jira/browse/KUDU-3268[KUDU-3268] for more details.

* Fixed crash in Kudu C++ client introduced with KUDU-1802.
See link:https://issues.apache.org/jira/browse/KUDU-3254[KUDU-3254] for details.

* Fixed bug in Kudu Java client which manifested in `AUTO_FLUSH_BACKGROUND` sessions hung in a call
to `KuduSession.flush()` method.  Another sign of the bug were stuck data ingest workloads based on
Java client (e.g., kudu-spark applications) with
"java.lang.AssertionError: This Deferred was already called!" message in the logs.
See link:https://issues.apache.org/jira/browse/KUDU-3277[KUDU-3277] for details.

* Fixed crash in Kudu server due to lack of `getrandom(2)` system call in Linux kernel version
earlier than 3.17 by instead using `/dev/random` for uuid generation in the Boost library.
Crash includes the following message in the logs
"terminate called after throwing an instance of 'boost::wrapexcept<boost::uuids::entropy_error>'".
See the link:https://gerrit.cloudera.org/c/17354/[fix] for a sample stack trace.

[[rn_1.15.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.15.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.15 clients may connect to servers running Kudu 1.0 or later. If the client uses
features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.14 and Kudu 1.15 servers is believed to be possible
though has not been sufficiently tested. Users are encouraged to shut down all nodes
in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.15 with the exception of the
below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.15 and versions earlier than 1.3:

* If a Kudu 1.15 cluster is configured with authentication or encryption set to "required",
clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.15 cluster is configured with authentication and encryption set to "optional"
or "disabled", older clients will still be able to connect.

[[rn_1.15.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.15.0

* Updated hash computation for empty strings in the FastHash implementation to conform with the
handling in Apache Impala. For Bloom filter predicate pushdown feature that uses FastHash,
this makes the Kudu client older than version 1.15.0 incompatible with Kudu server version 1.15.0
and Kudu client version at or newer than 1.15.0 incompatible with Kudu server version earlier than
1.15.0. Both client library and Kudu server need to be updated to version 1.15.0 or above if using
the Bloom filter predicate feature. One manifestation of this incompatibility is following message
in the logs, "Not implemented: call requires unsupported application feature flags: 4".
See link:https://issues.apache.org/jira/browse/KUDU-3286[KUDU-3286] for details.

[[rn_1.15.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.15 Java client library is API- and ABI-compatible with Kudu 1.14. Applications
written against Kudu 1.14 will compile and run against the Kudu 1.15 client library and
vice-versa.

* The Kudu 1.15 {cpp} client is API- and ABI-forward-compatible with Kudu 1.14.
Applications written and compiled against the Kudu 1.14 client library will run without
modification against the Kudu 1.15 client library. Applications written and compiled
against the Kudu 1.15 client library will run without modification against the Kudu 1.14
client library.

* The Kudu 1.15 Python client is API-compatible with Kudu 1.14. Applications
written against Kudu 1.14 will continue to run against the Kudu 1.15 client
and vice-versa.

[[rn_1.15.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.15.0_contributors]]
== Contributors

Kudu 1.15.0 includes contributions from 12 people, including 2 first-time contributors:

* Abhishek Chennaka
* shenxingwuying

Thank you for your contributions!

[[rn_1.14.0]]
= Apache Kudu 1.14.0 Release Notes

[[rn_1.14.0_upgrade_notes]]
== Upgrade Notes

[[rn_1.14.0_obsoletions]]
== Obsoletions

* Support for CentOS 6/RHEL 6, Ubuntu 14, Ubuntu 16, and Debian 8 platforms has been dropped
given they are at or near end-of-life. We will no longer validate these platforms as a
part of the release process, though patches will still be accepted going forward.

* Developer support for OS X 10.10 Yosemite, OS X 10.11 El Capitan, and OS X 10.12 Sierra
has been dropped. We will no longer validate these versions as a part of the release
process, though patches will still be accepted going forward.

[[rn_1.14.0_deprecations]]
== Deprecations

* Support for Python 2.x and Python 3.4 and earlier is deprecated and may be
removed in the next minor release.

* The `kudu-mapreduce` integration has been deprecated and may be removed in the
next minor release. Similar functionality and capabilities now exist via the
Apache Spark, Apache Hive, Apache Impala, and Apache NiFi integrations.

[[rn_1.14.0_new_features]]
== New features

* Full support for `INSERT_IGNORE`, `UPDATE_IGNORE`, and `DELETE_IGNORE` operations
was added. The `INSERT_IGNORE` operation will insert a row if one matching the key
does not exist and ignore the operation if one already exists. The `UPDATE_IGNORE`
operation will update the row if one matching the key exists and ignore the operation
if one does not exist. The `DELETE_IGNORE` operation will delete the row if one matching
the key exists and ignore the operation if one does not exist. These operations are
particularly useful in situations where retries or duplicate operations could occur and
you do not want to handle the errors that could result manually or you do not want to cause
unnecessary writes and compaction work as a result of using the `UPSERT` operation.
The Java client can check if the cluster it is communicating with supports these operations
by calling the `supportsIgnoreOperations()` method on the KuduClient. See
link:https://issues.apache.org/jira/browse/KUDU-1563[KUDU-1563] for more details.

* Spark 3 compatible JARs compiled for Scala 2.12 are now published for the Kudu Spark integration.
See link:https://issues.apache.org/jira/browse/KUDU-3202[KUDU-3202] for more details.

* Every Kudu cluster now has an automatically generated cluster Id that can be used to uniquely
identify a cluster. The cluster Id is shown in the masters web-UI, the `kudu master list` tool,
and in master server logs. See link:https://issues.apache.org/jira/browse/KUDU-2574[KUDU-2574]
for more details.

* It is now possible to enforce that OpenSSL is initialized in FIPS approved mode in the servers
and the C++ client by setting the KUDU_REQUIRE_FIPS_MODE environment variable to “1”, “yes” or
“true”. See link:https://issues.apache.org/jira/browse/KUDU-3210[KUDU-3210] for more details.

[[rn_1.14.0_improvements]]
== Optimizations and improvements

* Downloading the WAL data and data blocks when copying tablets to another tablet server is now
parallelized, resulting in much faster tablet copy operations. These operations occur when
recovering from a down tablet server or when running the cluster rebalancer. See
link:https://issues.apache.org/jira/browse/KUDU-1728[KUDU-1728] and
link:https://issues.apache.org/jira/browse/KUDU-3214[KUDU-3214] for more details.

* The HMS integration now supports multiple Kudu clusters associated with a single HMS
including Kudu clusters that do not have HMS synchronization enabled. This is possible,
because the Kudu master will now leverage the cluster Id to ignore notifications from
tables in a different cluster. Additionally, the HMS plugin will check if the Kudu cluster
associated with a table has HMS synchronization enabled.
See link:https://issues.apache.org/jira/browse/KUDU-3192[KUDU-3192] and
link:https://issues.apache.org/jira/browse/KUDU-3187[KUDU-3187] for more details.

* The HMS integration now supports gzipped HMS notifications. This is important in order to
support Hive 4 where the default encoder was changed to be the GzipJSONMessageEncoder. See
link:https://issues.apache.org/jira/browse/KUDU-3201[KUDU-3201] for more details.

* Kudu will now fail tablet replicas that have been corrupted due to KUDU-2233 instead of
crashing the tablet server. If a healthy majority still exists, a new replica will be created
and the failed replica will be evicted and deleted. See
link:https://issues.apache.org/jira/browse/KUDU-3191[KUDU-3191] and
link:https://issues.apache.org/jira/browse/KUDU-2233[KUDU-2233] for more details.

* DeltaMemStores will now be flushed as long as any DMS in a tablet is older than the point
defined by `--flush_threshold_secs`, rather than flushing once every `--flush_threshold_secs`
period. This can reduce memory pressure under update- or delete-heavy workloads, and lower tablet
server restart times following such workloads. See
link:https://issues.apache.org/jira/browse/KUDU-3195[KUDU-3195] for more details.

* The `kudu perf loadgen` CLI tool now supports `UPSERT` for storing the generated data into
the table. To switch to `UPSERT` for row operations (instead of default `INSERT`), add the
`--use_upsert` command-line flag.

* Users can now specify the level of parallelization when copying a tablet using the
`kudu local_replica copy_from_remote` CLI tool by passing the
`--tablet_copy_download_threads_nums_per_session` argument.

* The Kudu Masters now discriminate between overlapped and exact duplicate key ranges when adding
new partitions, returning `Status::AlreadyPresent()` for exact range duplicates and
`Status::InvalidArgument()` for otherwise overlapped ones. In prior releases, the master
returned `Status::InvalidArgument()` both in case of duplicate and otherwise overlapped ranges.

* The handling of an empty list of master addresses in Kudu C++ client has improved. In prior
releases, `KuduClientBuilder::Build()` would hang in `ConnectToCluster()` if no master addresses
were provided. Now, `KuduClientBuilder::Build()` instantly returns `Status::InvalidArgument()`
in such a case.

* The connection negotiation timeout for Kudu C++ client is now programmatically configurable.
  To customize the connection negotiation timeout, use the newly introduced
  `KuduClientBuilder::connection_negotiation_timeout()` method in the Kudu C++ client API.

* All RPC-related `kudu` CLI tools now have `--negotiation_timeout_ms` command line flag to
control the client-side connection negotiation timeout. The default value for the new flag is
set to 3000 milliseconds for backward compatibility. Keep in mind that the total RPC timeout
includes the connection negotiation time, so in general it makes sense to bump `--timeout_ms`
along with `--negotiation_timeout_ms` by the same delta.

* Kudu now reports on slow SASL calls (i.e. calls taking more than 250  milliseconds to complete)
when connecting to a server. This is to help diagnose issues like described in
link:https://issues.apache.org/jira/browse/KUDU-3217[KUDU-3217].

* MaintenanceManager now has a new histogram-based `maintenance_op_find_best_candidate_duration`
metric to capture the stats on how long it takes (in microseconds) to find the best maintenance
operation among available candidates. The newly introduced metric can help in diagnosing
conditions where MaintenanceManager seems lagging behind the rate of write operations in a busy
Kudu cluster with many replicas per tablet server.

* The KuduScanToken Java API has been extended with a `deserializeIntoScannerBuilder()` method that
can be used to further customize generated tokens.

* Logging of the error message produced when applying an op while a Java KuduSession is closed
has been throttled. See
link:https://issues.apache.org/jira/browse/KUDU-3012[KUDU-3012] for more details.

* Added a new `uptime` metric for a Kudu server. The metric's value is reported as the length of
the time interval passed from the start of the server, in microseconds. Knowing the server's
uptime, it's easier to interpret and compare metrics reported by different Kudu servers.

* Documentation for Kudu’s metrics are now automatically generated for each release and can be seen
link:https://kudu.apache.org/docs/metrics_reference.html[here].

[[rn_1.14.0_fixed_issues]]
== Fixed Issues

* Fixed lock contention between MaintenanceManager op registration and the scheduling of new
maintenance ops. On particularly dense tablet servers, this contention was previously shown to
significantly slow down startup times. See
link:https://issues.apache.org/jira/browse/KUDU-3149[KUDU-3149] for more details.

* Fixed lock contention between MaintenanceManager’s threads performing already scheduled
operations and the scheduler thread itself. This benefits clusters with heavy ingest/update
workloads that have many replicas per tablet server. See
link:https://issues.apache.org/jira/browse/KUDU-1954[KUDU-1954] for more details.

* Fixed a bug in the merge iterator that could result in a crash. This could surface as a crash
when performing ordered or differential scans, particularly when the underlying data contained
deletes and reinserts. See
link:https://issues.apache.org/jira/browse/KUDU-3108[KUDU-3108] for more details.

* Fixed a heap-use-after-free bug in Kudu C++ client that might manifest itself when altering a
table to update the partitioning schema. See
link:https://issues.apache.org/jira/browse/KUDU-3238[KUDU-3238] for more details.

* Fixed a bug where building scan tokens would result in a NullPointerException if a tablet not
found error occurred before generating the token. See
link:https://issues.apache.org/jira/browse/KUDU-3205[KUDU-3205] for more details.

* Fixed a bug where a delete operation would fail if the row being deleted contained exactly
64 columns and all values were set on the row. See
link:https://issues.apache.org/jira/browse/KUDU-3198[KUDU-3198] for more details.

* Fixed a bug where Slf4j classes were shaded into the Spark integration JARs. See
link:https://issues.apache.org/jira/browse/KUDU-3157[KUDU-3157] for more details.

* Fixed a bug where the 'kudu hms fix' tool mistakenly reports non-matching master addresses
when the addresses are in-fact canonically the same. See
link:https://issues.apache.org/jira/browse/KUDU-2884[KUDU-2884] for more details.

[[rn_1.14.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.14.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.14 clients may connect to servers running Kudu 1.0 or later. If the client uses
features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.13 and Kudu 1.14 servers is believed to be possible
though has not been sufficiently tested. Users are encouraged to shut down all nodes
in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.14 with the exception of the
below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.14 and versions earlier than 1.3:

* If a Kudu 1.14 cluster is configured with authentication or encryption set to "required",
clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.14 cluster is configured with authentication and encryption set to "optional"
or "disabled", older clients will still be able to connect.

[[rn_1.14.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.14.0


[[rn_1.14.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.14 Java client library is API- and ABI-compatible with Kudu 1.13. Applications
written against Kudu 1.13 will compile and run against the Kudu 1.14 client library and
vice-versa.

* The Kudu 1.14 {cpp} client is API- and ABI-forward-compatible with Kudu 1.13.
Applications written and compiled against the Kudu 1.13 client library will run without
modification against the Kudu 1.14 client library. Applications written and compiled
against the Kudu 1.14 client library will run without modification against the Kudu 1.13
client library.

* The Kudu 1.14 Python client is API-compatible with Kudu 1.13. Applications
written against Kudu 1.13 will continue to run against the Kudu 1.14 client
and vice-versa.

[[rn_1.14.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.14.0_contributors]]
== Contributors

Kudu 1.14.0 includes contributions from 12 people, including 1 first-time
contributors:

* liguohao

Thank you for your contributions!

[[rn_1.13.0]]
= Apache Kudu 1.13.0 Release Notes

[[rn_1.13.0_upgrade_notes]]
== Upgrade Notes

* The Sentry integration has been removed and the Ranger integration should now
be used in its place for fine-grained authorization.

[[rn_1.13.0_deprecations]]
== Deprecations

* Support for Python 2.x and Python 3.4 and earlier is deprecated and may be
removed in the next minor release.
* The `kudu-mapreduce` integration has been deprecated and may be removed in the
next minor release. Similar functionality and capabilities now exist via the
Apache Spark, Apache Hive, Apache Impala, and Apache NiFi integrations.

[[rn_1.13.0_new_features]]
== New features

* Added table ownership support. All newly created tables are automatically
owned by the user creating them. It is also possible to change the owner by
altering the table. You can also assign privileges to table owners via Apache
Ranger (see link:https://issues.apache.org/jira/browse/KUDU-3090[KUDU-3090]).
* An experimental feature is added to Kudu that allows it to automatically
rebalance tablet replicas among tablet servers. The background task can be
enabled by setting the `--auto_rebalancing_enabled` flag on the Kudu masters.
Before starting auto-rebalancing on an existing cluster, the CLI rebalancer
tool should be run first (see
link:https://issues.apache.org/jira/browse/KUDU-2780[KUDU-2780]).
* Bloom filter column predicate pushdown has been added to allow optimized
execution of filters which match on a set of column values with a
false-positive rate. Support for Impala queries utilizing Bloom filter
predicate is available yielding performance improvements of 19% to 30% in TPC-H
benchmarks and around 41% improvement for distributed joins across large
tables. Support for Spark is not yet available. (see
link:https://issues.apache.org/jira/browse/KUDU-2483[KUDU-2483]).
* AArch64-based (ARM) architectures are now supported including published Docker
images.
* The Java client now supports the columnar row format returned from the server
transparently. Using this format can reduce the server CPU and size of the
request over the network for scans. The columnar format can be enabled via the
setRowDataFormat() method on the KuduScanner.
* An experimental feature that can be enabled by setting the
`--enable_workload_score_for_perf_improvement_ops` prioritizes flushing and
compacting hot tablets.

[[rn_1.13.0_improvements]]
== Optimizations and improvements

* Hive metastore synchronization now supports Hive 3 and later.
* The Spark KuduContext accumulator metrics now track operation counts per table
instead of cumulatively for all tables.
* The `kudu local_replica delete` CLI tool now accepts multiple tablet
identifiers. Along with the newly added `--ignore_nonexistent` flag, this
helps with scripting scenarios when removing multiple tablet replicas from a
particular Tablet Server.
* Both Master’s and Tablet Server’s web UI now displays the name for a service
thread pool group at the `/threadz` page
* Introduced `queue_overflow_rejections_` metrics for both Masters and Tablet
Servers: number of RPC requests of a particular type dropped due to RPC
service queue overflow.
* Introduced a CoDel-like queue control mechanism for the apply queue. This
helps to avoid accumulating too many write requests and timing them out in
case of seek-bound workloads (e.g., uniform random inserts). The newly
introduced queue control mechanism is disabled by default. To enable it, set
the `--tablet_apply_pool_overload_threshold_ms` Tablet Server’s flag to
appropriate value, e.g. 250 (see
link:https://issues.apache.org/jira/browse/KUDU-1587[KUDU-1587]).
* Java client’s error collector can be resized (see
link:https://issues.apache.org/jira/browse/KUDU-1422[KUDU-1422]).
* Calls to the Kudu master server are now drastically reduced when using scan
tokens. Previously deserializing a scan token would result in a GetTableSchema
request and potentially a GetTableLocations request. Now the table schema and
location information is serialized into the scan token itself avoiding the
need for any requests to the master when processing them.
* The default size of Master’s RPC queue is now 100 (it was 50 in earlier
releases). This is to optimize for use cases where a Kudu cluster has many
clients working concurrently.
* Masters now have an option to cache table location responses. This is
targeted for Kudu clusters which have many clients working concurrently. By
default, the caching of table location responses is disabled. To enable table
location caching, set the proper capacity of the table location cache using
Master’s `--table_locations_cache_capacity_mb` flag (setting to 0 disables the
caching). Up to 17% of improvement is observed in GetTableLocations request
rate when enabling the caching.
* Removed lock contention on Raft consensus lock in Tablet Servers while
processing a write request. This helps to avoid RPC queue overflows when
handling concurrent write requests to the same tablet from multiple clients
(see link:https://issues.apache.org/jira/browse/KUDU-2727[KUDU-2727]).
* Master’s performance for handling concurrent GetTableSchema requests has been
improved. End-to-end tests indicated up to 15% improvement in sustained
request rate for high concurrency scenarios.
* Kudu servers now use protobuf Arena objects to perform all RPC
request/response-related memory allocations. This gives a boost for overall
RPC performance, and with further optimization the result request rate
was increased significantly for certain methods. For example, the result request
rate increased up to 25% for Master’s GetTabletLocations() RPC in case of
highly concurrent scenarios (see
link:https://issues.apache.org/jira/browse/KUDU-636[KUDU-636]).
* Tablet Servers now use protobuf Arena for allocating Raft-related runtime
structures. This results in substantial reduction of CPU cycles used and
increases write throughput (see
link:https://issues.apache.org/jira/browse/KUDU-636[KUDU-636]).
* Tablet Servers now use protobuf Arena for allocating EncodedKeys to reduce
allocator contention and improve memory locality (see
link:https://issues.apache.org/jira/browse/KUDU-636[KUDU-636]).
* Bloom filter predicate evaluation for scans can be computationally expensive.
A heuristic has been added that verifies rejection rate of the supplied Bloom
filter predicate below which the Bloom filter predicate is automatically
disabled. This helped reduce regression observed with Bloom filter predicate
in TPC-H benchmark query #9 (see
link:https://issues.apache.org/jira/browse/KUDU-3140[KUDU-3140]).
* Improved scan performance of dictionary and plain-encoded string columns by
avoiding copying them (see
link:https://issues.apache.org/jira/browse/KUDU-2844[KUDU-2844]).
* Improved maintenance manager's heuristics to prioritize larger memstores
(see link:https://issues.apache.org/jira/browse/KUDU-3180[KUDU-3180]).
* Spark client's KuduReadOptions now supports setting a snapshot timestamp for
repeatable reads with READ_AT_SNAPSHOT consistency mode (see
link:https://issues.apache.org/jira/browse/KUDU-3177[KUDU-3177]).

[[rn_1.13.0_fixed_issues]]
== Fixed Issues

* Kudu scans now honor location assignments when multiple tablet servers are
co-located with the client.
* Fixed a bug that caused IllegalArgumentException to be thrown when trying to
create a predicate for a DATE column in Kudu Java client (see
link:https://issues.apache.org/jira/browse/KUDU-3152[KUDU-3152]).
* Fixed a potential race when multiple RPCs work on the same scanner object.

[[rn_1.13.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.13.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.13 clients may connect to servers running Kudu 1.0 or later. If the client uses
features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.12 and Kudu 1.13 servers is believed to be possible
though has not been sufficiently tested. Users are encouraged to shut down all nodes
in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.13 with the exception of the
below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.13 and versions earlier than 1.3:

* If a Kudu 1.13 cluster is configured with authentication or encryption set to "required",
clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.13 cluster is configured with authentication and encryption set to "optional"
or "disabled", older clients will still be able to connect.

[[rn_1.13.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.13.0


[[rn_1.13.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.13 Java client library is API- and ABI-compatible with Kudu 1.12. Applications
written against Kudu 1.12 will compile and run against the Kudu 1.13 client library and
vice-versa.

* The Kudu 1.13 {cpp} client is API- and ABI-forward-compatible with Kudu 1.12.
Applications written and compiled against the Kudu 1.12 client library will run without
modification against the Kudu 1.13 client library. Applications written and compiled
against the Kudu 1.13 client library will run without modification against the Kudu 1.12
client library.

* The Kudu 1.13 Python client is API-compatible with Kudu 1.12. Applications
written against Kudu 1.12 will continue to run against the Kudu 1.13 client
and vice-versa.

[[rn_1.13.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.13.0_contributors]]
== Contributors

Kudu 1.13.0 includes contributions from 22 people, including 9 first-time
contributors:

* Jim Apple
* Kevin J McCarthy
* Li Zhiming
* Mahesh Reddy
* Romain Rigaux
* RuiChen
* Shuping Zhou
* ningw
* wenjie

[[rn_1.12.0]]
= Apache Kudu 1.12.0 Release Notes

[[rn_1.12.0_upgrade_notes]]
== Upgrade Notes


[[rn_1.12.0_obsoletions]]
== Obsoletions

* The Flume sink has been migrated to the Apache Flume project and removed
from Kudu. Users depending on the Flume integration can use the old
`kudu-flume` jars or migrate to the Flume jars containing the Kudu sink.

* Support for Apache Sentry authorization has been deprecated and may be
removed in the next minor release. Users depending on the Sentry integration
should migrate to the Apache Ranger integration for fine-grained authorization.

* Support for Python 2 has been deprecated and may be removed in the next minor
release.

* Support for CentOS/RHEL 6, Debian 8, Ubuntu 14 has been deprecated and may
be removed in the next minor release.

[[rn_1.12.0_deprecations]]
== Deprecations


[[rn_1.12.0_new_features]]
== New features

* Kudu now supports native fine-grained authorization via integration with
Apache Ranger. Kudu may now enforce access control policies defined for
Kudu tables and columns stored in Ranger. See the
link:security.html#fine_grained_authz[authorization documentation]
for more details.

* Kudu’s web UI now supports proxying via Apache Knox. Kudu may be deployed
in a firewalled state behind a Knox Gateway which will forward HTTP requests
and responses between clients and the Kudu web UI.

* Kudu’s web UI now supports HTTP keep-alive. Operations that access multiple
URLs will now reuse a single HTTP connection, improving their performance.

* The `kudu tserver quiesce` tool is added to quiesce tablet servers. While a
tablet server is quiescing, it will stop hosting tablet leaders and stop
serving new scan requests. This can be used to orchestrate a rolling restart
without stopping on-going Kudu workloads.

* Introduced `auto` time source for HybridClock timestamps. With
`--time_source=auto` in AWS and GCE cloud environments, Kudu masters and
tablet servers use the built-in NTP client synchronized with dedicated NTP
servers available via host-only networks. With `--time_source=auto` in
environments other than AWS/GCE, Kudu masters and tablet servers rely on
their local machine's clock synchronized by NTP. The default setting for
the HybridClock time source (`--time_source=system`) is backward-compatible,
requiring the local machine's clock to be synchronized by the kernel's NTP
discipline.

* The `kudu cluster rebalance` tool now supports moving replicas away from
specific tablet servers by supplying the `--ignored_tservers` and
`--move_replicas_from_ignored_tservers` arguments (see
link:https://issues.apache.org/jira/browse/KUDU-2914[KUDU-2914] for more
details).

* The `kudu table create` tool is added to allow users to specify table
creation options using JSON.

* Kudu now supports DATE and VARCHAR data types. See the
link:http://kudu.apache.org/docs/schema_design.html[schema design documentation]
for more details.


[[rn_1.12.0_improvements]]
== Optimizations and improvements

* Write Ahead Log file segments and index chunks are now managed by Kudu’s file
cache. With that, all long-lived file descriptors used by Kudu are managed by
the file cache, and there’s no longer a need for capacity planning of file
descriptor usage.

* Kudu no longer requires the running of `kudu fs update_dirs` to change a
directory configuration or recover from a disk failure
(see link:https://issues.apache.org/jira/browse/KUDU-2993[KUDU-2993]).

* Kudu tablet servers and masters now expose a tablet-level metric
`num_raft_leaders` for the number of Raft leaders hosted on the server.

* Kudu's maintenance operation scheduling has been updated to prioritize
reducing WAL retention under memory pressure. Kudu would previously prioritize
operations that yielded high-memory reduction, which could result in high WAL
disk usage in workloads that contained updates
(see link:https://issues.apache.org/jira/browse/KUDU-3002[KUDU-3002]).

* A new maintenance operation is introduced to remove rowsets that have had all
of their rows deleted and whose newest delete operations are considered
ancient (see link:https://issues.apache.org/jira/browse/KUDU-1625[KUDU-1625]).

* The built-in NTP client is now fully supported as the time source for Kudu's
HybridTime clock, i.e. it's no longer marked as experimental. To switch the
time source from the existing `system` time source (which is the default)
to the built-in NTP client, use `--time_source=builtin`.

* Introduced additional metrics for the built-in NTP client
(see link:https://issues.apache.org/jira/browse/KUDU-3048[KUDU-3048]).

* Updated `/config` page of masters' and tablet servers' web UI to display
configured and effective time source. In addition, the effective list of
reference servers for the built-in NTP client is shown there as well,
if applicable.

* `chronyd` (version 3.4 and newer) is now supported as NTP server for
synchronizing the local machine's clock in a Kudu cluster. It's important to
have the `rtcsync` option enabled in the configuration of the `chronyd` NTP
daemon (see link:https://issues.apache.org/jira/browse/KUDU-2573[KUDU-2573]).

* Kudu now supports building and running on RHEL/CentOS 8. This has been tested
with CentOS 8.1.

* The processing of Raft consensus vote requests has been improved to be more
robust during high contention scenarios like election storms.

* Added a validator to enforce consistency between the maximum size of an RPC
and the maximum size of tablet transaction memory, controlled by
`--rpc_max_message_size` and `--tablet_transaction_memory` flags
correspondingly.  In prior releases, if the limit on the size of RPC requests
is increased and the limit on tablet transaction memory size is kept with the
default setting, certain Raft transactions could be committed but not applied
(see link:https://issues.apache.org/jira/browse/KUDU-3023[KUDU-3023]).

* The metrics endpoint now supports filtering metrics by a metric severity level.
See the link:https://kudu.apache.org/docs/administration.html#_collecting_metrics_via_http[documentation]
for more details.

* Many `kudu local_replica` tools are updated to not open the block manager,
which significantly reduces the amount of IO done when running them (see
link:https://issues.apache.org/jira/browse/KUDU-3070[KUDU-3070] for more
details).

* The Kudu Java client now exposes a way to get the resource metrics associated
with a given scanner (see
link:https://issues.apache.org/jira/browse/KUDU-2162[KUDU-2162] for more
details).

* Scan predicates are pushed down to RLE decoders, improving
predicate-evaluation-efficiency in some workloads (see
link:https://issues.apache.org/jira/browse/KUDU-2852[KUDU-2852] for more
details).

* The log block manager will now attempt to use multiple threads to open blocks
in each data directory, in some tests reducing startup time by up to 20% (see
link:https://issues.apache.org/jira/browse/KUDU-2977[KUDU-2977] and
link:https://issues.apache.org/jira/browse/KUDU-3001[KUDU-3001] for more
details).

* Kudu's tablet server web UI scans page is updated to show the number of round
trips per scanner.

* Kudu's master and tablet server web UIs are updated to show critical
partition information, including tablet count and on-disk size.

* Kudu servers now expose the `last_read_elapsed_seconds` and
`last_write_elapsed_seconds` tablet-level metrics that indicate how long ago
the most recent read and write operations to a given tablet were.

* Kudu servers now expose the `transaction_memory_limit_rejections`
tablet-level metric that tracks the number of transactions rejected because a
given tablet's transactional memory limit was reached (see
link:https://issues.apache.org/jira/browse/KUDU-3021[KUDU-3021] for more
details).

[[rn_1.12.0_fixed_issues]]
== Fixed Issues

* Fixed a bug in which Kudu would not schedule compactions if a server were
under memory pressure
(see link:https://issues.apache.org/jira/browse/KUDU-2929[KUDU-2929]).

* Fixed a bug where DDL operations like ALTER TABLE on tables with huge
number of partitions might result in a DoS situation for Kudu masters
(see link:https://issues.apache.org/jira/browse/KUDU-3036[KUDU-3036]).

* Fixed a bug where Kudu Java client cannot negotiate a secure connection
with Kudu masters and tablet servers if using BouncyCastle JCE provider
(see link:https://issues.apache.org/jira/browse/KUDU-3106[KUDU-3106]).

* Kudu masters will now crash immediately upon hitting a disk failure (see
link:https://issues.apache.org/jira/browse/KUDU-2904[KUDU-2904] for more details).

* Fixed an issue in the Kudu master in which delays in receiving tablet server
heartbeats could result in an excess amount of RPC traffic between the
masters and tablet servers (see
link:https://issues.apache.org/jira/browse/KUDU-2992[KUDU-2992] for more
details).

* Fixed an issue with Kudu's location placement policy that would place all
replicas in one location when two locations were available (see
link:https://issues.apache.org/jira/browse/KUDU-3008[KUDU-3008] for more
details).

* The Java client will now correctly propagate timestamps when sending write
batches (see link:https://issues.apache.org/jira/browse/KUDU-3035[KUDU-3035]
for more detail).

* Fixed an issue with the Kudu backup Spark jobs in which Kudu would return
with a non-zero exit if the job succeeded but backed up no rows (see
link:https://issues.apache.org/jira/browse/KUDU-3099[KUDU-3099] for more
details).

* The `raft_term` and `time_since_last_leader_heartbeat` aggregated table
metrics will now return the maximum metric reported instead of the sum.

[[rn_1.12.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.12.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.12 clients may connect to servers running Kudu 1.0 or later. If the client uses
features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.11 and Kudu 1.12 servers is believed to be possible
though has not been sufficiently tested. Users are encouraged to shut down all nodes
in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.12 with the exception of the
below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.12 and versions earlier than 1.3:

* If a Kudu 1.12 cluster is configured with authentication or encryption set to "required",
clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.12 cluster is configured with authentication and encryption set to "optional"
or "disabled", older clients will still be able to connect.

[[rn_1.12.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.12.0


[[rn_1.12.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.12 Java client library is API- and ABI-compatible with Kudu 1.11. Applications
written against Kudu 1.11 will compile and run against the Kudu 1.12 client library and
vice-versa.

* The Kudu 1.12 {cpp} client is API- and ABI-forward-compatible with Kudu 1.11.
Applications written and compiled against the Kudu 1.11 client library will run without
modification against the Kudu 1.12 client library. Applications written and compiled
against the Kudu 1.12 client library will run without modification against the Kudu 1.11
client library.

* The Kudu 1.12 Python client is API-compatible with Kudu 1.11. Applications
written against Kudu 1.11 will continue to run against the Kudu 1.12 client
and vice-versa.

[[rn_1.12.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.12.0_contributors]]
== Contributors

Kudu 1.12 includes contributions from 33 people, including 8 first-time
contributors:

* Andy Singer
* Michele Milesi
* Ning Wang
* Renhai Zhao
* Sheng Liu
* Thomas D'Silva
* Tianhua Huang
* Waleed Fateem

Thank you for your help in making Kudu even better!

[[rn_1.11.1]]
Apache Kudu 1.11.1 is a bug-fix release which fixes one critical licensing
issue in Kudu 1.11.0.

[[rn_1.11.1_upgrade_notes]]
== Upgrade Notes
When upgrading from earlier versions of Kudu, if support for Kudu's NVM
(non-volatile memory) block cache is desired, install the `memkind` library
of version 1.8.0 or newer as documented in link:installation.html[Kudu
Installation] for corresponding platform. This is a mandatory step for existing
users of the NVM block cache (i.e. those who set `--block_cache_type=NVM`
for `kudu-master` and `kudu-tserver`): they must install `memkind`, otherwise
their Kudu processes will crash at startup.

[[rn_1.11.1_fixed_issues]]
== Fixed Issues
* Fixed an issue with distributing `libnuma` dynamic library with `kudu-binary`
  JAR artifact. Also, fixed the issue of statically compiling in `libnuma.a`
  into `kudu-master` and `kudu-tserver` binaries when building Kudu
  from source in release mode. The fix removes both `numactl` and `memkind`
  projects from Kudu's thirdparty dependencies and makes the dependency on the
  `libmemkind` library optional, opening the library using `dlopen()` and
  resolving required symbols via `dlsym()`
  (see link:https://issues.apache.org/jira/browse/KUDU-2990[KUDU-2990]).

* Fixed an issue with `kudu cluster rebalancer` CLI tool crashing when running
  against a location-aware cluster if a tablet server in one location doesn't
  contain a single tablet replica
  (see link:https://issues.apache.org/jira/browse/KUDU-2987[KUDU-2987]).

* Fixed an issue with connection negotiation using SASL mechanism when server
  FQDN is longer than 64 characters
  (see link:https://issues.apache.org/jira/browse/KUDU-2989[KUDU-2989]).

* Fixed an issue in the test harness of the kudu-binary JAR artifact. With this
  fix, `kudu-master` and `kudu-tserver` processes of the mini-cluster's test
  harness no longer rely on the test NTP server to synchronize their built-in
  NTP client. Instead, the test harness relies on the local machine clock
  synchronized by the system NTP daemon
  (see link:https://issues.apache.org/jira/browse/KUDU-2994[KUDU-2994]).

[[rn_1.11.0]]
= Apache Kudu 1.11.0 Release Notes

[[rn_1.11.0_upgrade_notes]]
== Upgrade Notes

* Since link:https://issues.apache.org/jira/browse/KUDU-2625[KUDU-2625] is
  addressed, tablet servers now reject individual write operations which
  violate schema constraints in a batch of write operations. In prior versions
  the behavior was to reject the whole batch of write operations if a violation
  of the schema constraints is detected even for a single row. It's recommended
  to revise applications which relied on the behavior mentioned above
  upon upgrading to Kudu 1.11.0.

[[rn_1.11.0_deprecations]]
== Deprecations

* The Kudu Flume integration is deprecated and may be removed in the
  next minor release. The integration will be moved to the Apache Flume
  project going forward
  (see link:https://issues.apache.org/jira/browse/FLUME-3345[FLUME-3345]).

[[rn_1.11.0_new_features]]
== New features

* Kudu now supports putting tablet servers into maintenance. While in this
  mode, the tablet server's replicas will not be re-replicated if it fails.
  Only upon exiting maintenance will re-replication be triggered for any
  remaining under-replicated tablets. The `kudu tserver state enter_maintenance`
  and `kudu tserver state exit_maintenance` tools are added to orchestrate
  tablet server maintenance, and the `kudu tserver list` tool is amended with
  a "state" column option to display current state of each tablet server
  (see link:https://issues.apache.org/jira/browse/KUDU-2069[KUDU-2069]).

* Kudu now has a built-in NTP client which maintains the internal wallclock
  time used for generation of HybridTime timestamps. When enabled, system clock
  synchronization for nodes running Kudu is no longer necessary. This is useful
  for containerized deployments and in other cases when it's troublesome
  to maintain properly configured system NTP service at each node of a Kudu
  cluster. The list of NTP servers to synchronize against is specified with the
  `--builtin_ntp_servers` flag. By default, Kudu masters and tablet servers use
  public servers hosted by the NTP Pool project. To use the built-in NTP
  client, set `--time_source=builtin` and reconfigure `--builtin_ntp_servers`
  if necessary
  (see link:https://issues.apache.org/jira/browse/KUDU-2935[KUDU-2935]).

* Aggregated table statistics are now available to Kudu clients via
  `KuduClient.getTableStatistics()` and `KuduTable.getTableStatistics()`
  methods in the Kudu Java client and `KuduClient.GetTableStatistics()`
  in the Kudu {cpp} client. This allows for various query optimizations.
  For example, Spark now uses it to perform join optimizations.
  The statistics are available via the API of both {cpp} and Java Kudu clients.
  In addition, per-table statistics are available via `kudu table statistics`
  CLI tool. The statistics are also available via master's Web UI at
  `master:8051/metrics` and `master:8051/table?id=<uuid>` URIs
  (see link:https://issues.apache.org/jira/browse/KUDU-2797[KUDU-2797] and
   link:https://issues.apache.org/jira/browse/KUDU-2921[KUDU-2921]).

* The `kudu` CLI tool now supports altering table columns. Use the newly
  introduced sub-commands such as `kudu table column_set_default`,
  `kudu table column_remove_default`, `kudu table column_set_compression`,
  `kudu table column_set_encoding`, and `kudu table column_set_block_size`
  to alter a column of the specified table.

* The `kudu` CLI tool now supports dropping table columns. Use the newly
  introduced `kudu table delete_column` sub-command to drop a column of the
  specified table.

* The `kudu` CLI tool now supports getting and setting extra
  configuration properties for a table. Use `kudu table get_extra_configs`
  and `kudu table set_extra_config` sub-commands to perform the corresponding
  operations
  (see link:https://issues.apache.org/jira/browse/KUDU-2514[KUDU-2514]).

* The `kudu` CLI tool now supports creating and dropping range partitions
  for a table. Use `kudu table add_range_partition` and
  `kudu table drop_range_partition` sub-commands to perform the corresponding
  operations
  (see link:https://issues.apache.org/jira/browse/KUDU-2881[KUDU-2881]).

[[rn_1.11.0_improvements]]
== Optimizations and improvements

* The `kudu fs dump uuid` CLI tool is now significantly faster and consumes
  significantly less IO.

* The memory consumed by CFileReaders and BloomFileReaders is factored out and
  accounted separately by the tablet server memory tracking. The stats are
  available via Web UI as "CFileReaders" and "BloomFileReaders" entries.

* `KuduScanBatch::const_iterator` in Kudu {cpp} client now supports
  `operator->()`
  (see link:https://issues.apache.org/jira/browse/KUDU-1561[KUDU-1561]).

* Master server Web UI now supports sorting the list of tables by the columns
  of "Table Name", "Create Time", and "Last Alter Time".

* Tablet servers now expand a tablet's data directory group with available
  healthy directories when all directories of the group are full
  (see link:https://issues.apache.org/jira/browse/KUDU-2907[KUDU-2907]).

* For scan operations run with `CLOSEST_REPLICA` selection mode, the Kudu Java
  client now picks a random available replica in case no replica is located at
  the same node with the client that initiated the scan operation. This helps
  to spread the load generated by multiple scan requests to the same tablet
  among all available replicas. In prior releases, all such scan requests might
  end up fetching data from the same tablet replica
  (see link:https://issues.apache.org/jira/browse/KUDU-2348[KUDU-2348]).

* The serialization of in-memory rows to Kudu's wire format has been optimized
  to be more CPU efficient
  (see link:https://issues.apache.org/jira/browse/KUDU-2847[KUDU-2847]).

* Tablet servers and masters can now aggregate metrics by the same attribute.
  For example, it's now possible to fetch aggregated metrics from a tablet
  server by retrieving data from URLs of form
  `http://<host>:<port>/metrics?merge_rules=tablet|table|table_name`

* Introduced Docker image for Python Kudu client
  (see link:https://issues.apache.org/jira/browse/KUDU-2849[KUDU-2849]).

* Tablet servers now consider available disk space when choosing a set of data
  directories for a tablet's data directory group, and when deciding in which
  data directory a new block should be written
  (see link:https://issues.apache.org/jira/browse/KUDU-2901[KUDU-2901]).

* Added a quick-start example of using Apache Spark to load, query, and modify
  a real data set stored in Kudu.

* Added a quick-start example of using Apache Nifi to ingest data into Kudu.

* Tablet servers now reject individual write operations which violate schema
  constraints in a batch of write operations received from a client. The
  previous behavior was to reject the whole batch of write operations
  if a violation of the schema constraints is detected even for a single row
  (see link:https://issues.apache.org/jira/browse/KUDU-2625[KUDU-2625]).

* Tablet replicas can now be optionally placed in accordance with a
  dimension-based placement policy. To specify a dimension label for a table,
  use the `KuduTableCreator::dimension_label()` and
  `CreateTableOptions.setDimensionLabel()` methods of the {cpp} and Java Kudu
  clients. To add a partition with a dimension label, use the
  `KuduTableAlterer::AddRangePartitionWithDimension()` and
  `AlterTableOptions.addRangePartition()` methods of the {cpp} and Java Kudu
  clients
  (see link:https://issues.apache.org/jira/browse/KUDU-2823[KUDU-2823]).

* Kudu RPC now enables TCP keepalive for all outbound connections for faster
  detection of no-longer-reachable nodes
  (see link:https://issues.apache.org/jira/browse/KUDU-2192[KUDU-2192]).

* The `kudu table scan` and `kudu table copy` CLI tools now fail gracefully
  rather than crashing upon hitting an error
  (see link:https://issues.apache.org/jira/browse/KUDU-2851[KUDU-2851]).

* Optimized decoding of deltas' timestamps
  (see link:https://issues.apache.org/jira/browse/KUDU-2867[KUDU-2867]).

* Optimized the initialization of DeltaMemStore for the case when no matching
  deltas are present
  (see link:https://issues.apache.org/jira/browse/KUDU-2381[KUDU-2381]).

* Improved the rehydration of scan tokens. Now a scan token created
  before renaming a column can be used even after the column has been renamed.

* The memory reserved by tcmalloc is now released to OS periodically to avoid
  potential OOM issues in the case of read-only workloads
  (see link:https://issues.apache.org/jira/browse/KUDU-2836[KUDU-2836]).

* Optimized evaluation of predicates on columns of primitive types and
  `NULL`/`NOT NULL` predicates to leverage SIMD instructions
  (see link:https://issues.apache.org/jira/browse/KUDU-2846[KUDU-2846]).

[[rn_1.11.0_fixed_issues]]
== Fixed Issues

* Fixed an issue of fault-tolerant scan operation failing for a projection
  with key columns specified in other than the table schema's order
  (see link:https://issues.apache.org/jira/browse/KUDU-2980[KUDU-2980]).

* Fixed an issue that would cause frequent leader elections in case when
  persisting Raft transactions to the WAL took longer than the leader
  election timeout. The issue was contributing to election storms
  (see link:https://issues.apache.org/jira/browse/KUDU-2947[KUDU-2947]).

* Fixed a tablet server crash in cases where blocks were not removed due to IO
  error. This issue may have surfaced after recovering from a disk failure
  (see link:https://issues.apache.org/jira/browse/KUDU-2635[KUDU-2635]).

* Fixed a crash in master and tablet server by validating the size of default
  values when de-serializing `ColumnSchemaPB`
  (see link:https://issues.apache.org/jira/browse/KUDU-2622[KUDU-2622]).

* Fixed RPC negotiation failure in the case when TLS v1.3 is supported at
  both the client and the server side. This is a temporary workaround before
  the connection negotiation code is properly updated to support 1.5-RTT
  handshake used in TLS v1.3. The issue affected Linux distributions shipped
  or updated with OpenSSL version 1.0.2 and newer
  (see link:https://issues.apache.org/jira/browse/KUDU-2871[KUDU-2871]).

* Fixed a race between `GetTabletLocations()` and tablet report processing.
  The race could crash the Kudu master
  (see link:https://issues.apache.org/jira/browse/KUDU-2842[KUDU-2842]).

* Fixed a bug in `AlterSchemaTransactionState::ToString()` that led to a crash
  of tablet server when removing a tablet replica with a pending `AlterSchema`
  transaction.

[[rn_1.11.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.11.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.11 clients may connect to servers running Kudu 1.0 or later. If the client uses
  features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.10 and Kudu 1.11 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.11 with the exception of the
  below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.11 and versions earlier than 1.3:

* If a Kudu 1.11 cluster is configured with authentication or encryption set to "required",
  clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.11 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.

[[rn_1.11.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.11 Java client library is API- and ABI-compatible with Kudu 1.10. Applications
  written against Kudu 1.10 will compile and run against the Kudu 1.11 client library and
  vice-versa.

* The Kudu 1.11 {cpp} client is API- and ABI-forward-compatible with Kudu 1.10.
  Applications written and compiled against the Kudu 1.10 client library will run without
  modification against the Kudu 1.11 client library. Applications written and compiled
  against the Kudu 1.11 client library will run without modification against the Kudu 1.10
  client library.

* The Kudu 1.11 Python client is API-compatible with Kudu 1.10. Applications
  written against Kudu 1.10 will continue to run against the Kudu 1.11 client
  and vice-versa.

[[rn_1.11.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.11.0_contributors]]
== Contributors
Kudu 1.11 includes contributions from 24 people, including 8 first-time
contributors:

* Hannah Nguyen
* lingbin
* Ritwik Yadav
* Scott Reynolds
* Volodymyr Verovkin
* Xiaokai Wang
* Xin He
* Yao Wang

Thank you for your help in making Kudu even better!

[[rn_1.10.1]]
Apache Kudu 1.10.1 is a bug-fix release which fixes one critical licensing
issue in Kudu 1.10.0.

[[rn_1.10.1_upgrade_notes]]
== Upgrade Notes
When upgrading from earlier versions of Kudu, if support for Kudu's NVM
(non-volatile memory) block cache is desired, install the `memkind` library
of version 1.6.0 or newer as documented in link:installation.html[Kudu
Installation] for corresponding platform. This is a mandatory step for existing
users of the NVM block cache (i.e. those who set `--block_cache_type=NVM`
for `kudu-master` and `kudu-tserver`): they must install `memkind`, otherwise
their Kudu processes will crash at startup.

[[rn_1.10.1_fixed_issues]]
== Fixed Issues
* Fixed an issue with distributing `libnuma` dynamic library with `kudu-binary`
  JAR artifact. Also, fixed the issue of statically compiling in `libnuma.a`
  into `kudu-master` and `kudu-tserver` binaries when building Kudu
  from source in release mode. The fix removes both `numactl` and `memkind`
  projects from Kudu's thirdparty dependencies and makes the dependency on the
  `libmemkind` library optional, opening the library using `dlopen()` and
  resolving required symbols via `dlsym()`
  (see link:https://issues.apache.org/jira/browse/KUDU-2990[KUDU-2990]).

[[rn_1.10.0]]
== Release Notes Specific to 1.10.0

[[rn_1.10.0_upgrade_notes]]
== Upgrade Notes

* The default tablet history retention time has been raised from 15 minutes to
  7 days to better support touchless incremental backups
  (see link:https://issues.apache.org/jira/browse/KUDU-2677[KUDU-2677]).

[[rn_1.10.0_obsoletions]]
== Obsoletions


[[rn_1.10.0_deprecations]]
== Deprecations


[[rn_1.10.0_new_features]]
== New features

* Kudu now supports both full and incremental table backups via a job
  implemented using Apache Spark. Additionally it supports restoring
  tables from full and incremental backups via a restore job implemented using
  Apache Spark. See the link:administration.html#backup[backup documentation]
  for more details.

* Kudu can now synchronize its internal catalog with the Apache Hive Metastore,
  automatically updating Hive Metastore table entries upon table creation,
  deletion, and alterations in Kudu. See the
  link:hive_metastore.html#metadata_sync[HMS synchronization documentation]
  for more details.

* Kudu now supports native fine-grained authorization via integration with
  Apache Sentry. Kudu may now enforce access control policies defined for Kudu
  tables and columns, as well as policies defined on Hive servers and databases
  that may store Kudu tables. See the
  link:security.html#fine_grained_authz[authorization documentation] for more
  details.

* Kudu’s web UI now supports SPNEGO, a protocol for securing HTTP requests with
  Kerberos by passing negotiation through HTTP headers. To enable, set the
  `--webserver_require_spnego` command line flag.

* Column comments can now be stored in Kudu tables, and can be updated using
  the AlterTable API
  (see link:https://issues.apache.org/jira/browse/KUDU-1711[KUDU-1711]).

* The Java scan token builder can now create multiple tokens per tablet.
  To use this functionality, call `setSplitSizeBytes()` to specify how many bytes
  of data each token should scan. The same API is also available in Kudu’s
  Spark integration, where it can be used to spawn multiple Spark tasks per
  scanned tablet
  (see link:https://issues.apache.org/jira/browse/KUDU-2670[KUDU-2670]).

* Experimental Kudu Docker images are now published on
  link:https://hub.docker.com/r/apache/kudu[Docker Hub].

* Kudu now has an experimental Kubernetes StatefulSet manifest and Helm chart,
  which can be used to define and provision Kudu clusters using Kubernetes
  (see link:https://issues.apache.org/jira/browse/KUDU-2398[KUDU-2398]).

* The Kudu CLI now has rudimentary YAML-based configuration file support,
  which can be used to provide cluster connection information via cluster name
  instead of keying in comma-separated lists of master addresses.
  See the link:https://kudu.apache.org/docs/administration.html#using_cluster_names_in_kudu_tool[cluster name documentation]
  for more details.

* `kudu perf table_scan` scans a table and displays a table’s row count as well
  as the time it took to run the scan.

* `kudu table copy` copies data from one table to another, within the same
  cluster or across clusters. Note, this implementation leverages a single client,
  therefore it may not be suitable for large tables.

* Tablet history retention time can now be configured on a table-by-table basis.
  (see link:https://issues.apache.org/jira/browse/KUDU-2514[KUDU-2514]).

[[rn_1.10.0_improvements]]
== Optimizations and improvements

* The performance of mutations (i.e. UPDATE, DELETE, and re-INSERT) to
  not-yet-flushed Kudu data has been significantly optimized
  (see link:https://issues.apache.org/jira/browse/KUDU-2826[KUDU-2826] and
  link:https://github.com/apache/kudu/commit/f9f9526d3[f9f9526d3]).

* Predicate performance for primitive columns has been optimized
  (see link:https://issues.apache.org/jira/browse/KUDU-2846[KUDU-2846]).

* IS NULL and IS NOT NULL predicate performance has been optimized
  (see link:https://issues.apache.org/jira/browse/KUDU-2846[KUDU-2846]).

* Optimized the performance of fetching tablet locations from the master for
  tables with large numbers of partitions. This can improve the performance of
  short-running Spark or Impala queries as well as user applications which make
  use of short-lived client instances
  (see link:https://issues.apache.org/jira/browse/KUDU-2711[KUDU-2711]).

* The `tableExists()` (Java) and `TableExists()` (C++) APIs are now more performant
  (see link:https://issues.apache.org/jira/browse/KUDU-2802[KUDU-2802]).

* Fault tolerant scans are now much more performant and consume far less memory
  (see link:https://issues.apache.org/jira/browse/KUDU-2466[KUDU-2466]).

* `kudu cluster ksck` now sends more requests in parallel, which should result
  in a speed-up when running against clusters with many tables or when there’s
  high latency between the node running the CLI and the cluster nodes.

* Kudu’s block manager now deletes spent block containers when needed instead of
  just at server startup. This should reduce server startup times somewhat
  (see link:https://issues.apache.org/jira/browse/KUDU-2636[KUDU-2636]).

* DNS resolutions are now cached by Kudu masters, tablet servers, and
  Kudu C++ clients. The TTL for a resolved DNS entry in the cache is 15 seconds
  by default
  (see link:https://issues.apache.org/jira/browse/KUDU-2791[KUDU-2791]).

* Tables created in Kudu 1.10.0 or later will show their creation time as well
  as their last alteration time in the web UI
  (see link:https://issues.apache.org/jira/browse/KUDU-2750[KUDU-2750]).

* The Kudu CLI and C++ client now support overriding the local username using
  the ‘KUDU_USER_NAME’ environment variable. This allows operating against a
  Kudu cluster using an identity which differs from the local Unix user on the
  client. Note that this has no effect on secure clusters, where client identity
  is determined by Kerberos authentication
  (see link:https://issues.apache.org/jira/browse/KUDU-2717[KUDU-2717]).

* Kudu C++ client now performs stricter verification on the input data of
  INSERT and UPSERT operations w.r.t. table schema constraints. This helps
  spotting schema violations before sending the data to a tablet server.

* The `KuduScanner` in the Java client is now iterable. Additionally the
  `KuduScannerIterator` will automatically make scanner keep alive calls to
  ensure scanners do not time out while iterating.

* A `KuduPartitioner` API was added to the Java client. The `KuduPartitioner`
  API allows a client to determine which partition a row falls into without
  actually writing that row. For example, the `KuduPartitioner` is used in the
  Spark integration to optionally repartition and pre-sort the data before
  writing to Kudu
  (see link:https://issues.apache.org/jira/browse/KUDU-2674[KUDU-2674] and
  link:https://issues.apache.org/jira/browse/KUDU-2672[KUDU-2672]).

* The `PartialRow` and `RowResult` Java API have new methods that accept and return
  Java Objects. These methods are useful when you don't care about autoboxing
  and your existing type handling logic is based on Java types. See the javadoc
  for more details.

* The Kudu Java client now logs RPC trace summaries instead of full RPC traces when
  the log level is `INFO` or higher. This reduces log noise and makes RPC issues
  more visible in a more compact format
  (see link:https://issues.apache.org/jira/browse/KUDU-2830[KUDU-2830]).

* Kudu servers now display the time at which they were started in their web UIs.

* Kudu tablet servers now display a table’s total column count in the web UI.

* The `/metrics` web UI endpoint now supports filtering on entity types,
  entity IDs, entity attributes, and metric names. This can be used to more
  efficiently collect important metrics when there is a large number of tablets
  on a tablet server.

* The Kudu rebalancer now accepts the `--ignored_tservers` command line
  argument, which can be used to ignore the health status of specific tablet
  servers (i.e. if they are down) when deciding whether or not it’s safe to
  rebalance the cluster.

* `kudu master list` now displays the Raft consensus role of each master in the
  cluster (i.e. LEADER or FOLLOWER)
  (see link:https://issues.apache.org/jira/browse/KUDU-2825[KUDU-2825]).

* `kudu table scan` no longer interleaves its output, and now projects all
  columns without having to manually list the column names.

* `kudu perf loadgen` now supports creating empty tables. The semantics of the
  special value of 0 for `--num_rows_per_thread` flag has changed. A value of 0
  now indicates that no rows should be generated, and a value of -1 indicates
  there should be no limit to the number of rows generated.

* Running `make install` after building Kudu from source will now install the
  Kudu binaries into appropriate locations.
  (see link:https://issues.apache.org/jira/browse/KUDU-1344[KUDU-1344]).

[[rn_1.10.0_fixed_issues]]
== Fixed Issues

* Fixed an issue where the Java client would fail scans that took a very long
  time to return a single block of rows, such as highly selective scans over a
  large amount of data
  (see link:https://issues.apache.org/jira/browse/KUDU-1868[KUDU-1868]).

* Fixed the handling of SERVICE_UNAVAILABLE errors that caused the Java client
  to do unnecessary master lookups.

* Kudu scan tokens now work correctly when the target table is renamed between
  when the scan token is created and when it is rehydrated into a scanner.

* Kudu’s “NTP synchronization wait” behavior at startup now works properly when
  Kudu is run in a containerized environment.

* Fixed a crash when a flush or compaction overlapped with another compaction
  (see link:https://issues.apache.org/jira/browse/KUDU-2807[KUDU-2807]).

* Fixed a rare race at startup where the leader master would fruitlessly try to
  tablet copy to a healthy follower master, causing the cluster to operate as if
  it had two masters until master leadership changed
  (see link:https://issues.apache.org/jira/browse/KUDU-2748[KUDU-2748]).

* Under rare circumstances, it was possible for Kudu to crash in libkrb5 when
  negotiating multiple TLS connections concurrently. This crash has been fixed
  (see link:https://issues.apache.org/jira/browse/KUDU-2706[KUDU-2706]).

* Kudu no longer crashes at startup on machines with disabled CPUs
  (see link:https://issues.apache.org/jira/browse/KUDU-2721[KUDU-2721]).

[[rn_1.10.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.10.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.10 clients may connect to servers running Kudu 1.0 or later. If the client uses
  features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.9 and Kudu 1.10 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.10 with the exception of the
  below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.10 and versions earlier than 1.3:

* If a Kudu 1.10 cluster is configured with authentication or encryption set to "required",
  clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.10 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.

[[rn_1.10.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.10.0

* Support for building and running with Java 7 has been dropped in this release.
  It had been deprecated since Kudu 1.5.0.
  (see link:https://issues.apache.org/jira/browse/KUDU-2099[KUDU-2099]).

[[rn_1.10.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.10 Java client library is API- and ABI-compatible with Kudu 1.9. Applications
  written against Kudu 1.9 will compile and run against the Kudu 1.10 client library and
  vice-versa.

* The Kudu 1.10 {cpp} client is API- and ABI-forward-compatible with Kudu 1.9.
  Applications written and compiled against the Kudu 1.9 client library will run without
  modification against the Kudu 1.10 client library. Applications written and compiled
  against the Kudu 1.10 client library will run without modification against the Kudu 1.9
  client library.

* The Kudu 1.10 Python client is API-compatible with Kudu 1.9. Applications
  written against Kudu 1.9 will continue to run against the Kudu 1.10 client
  and vice-versa.

[[rn_1.10.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.10.0_contributors]]
== Contributors

Kudu 1.10 includes contributions from 27 people, including 6 first-time contributors:

* Csaba Fulop
* Florentino Sainz
* Guangchao Deng
* Jia Hongchao
* Ye Yuqiang
* Yifan Zhang

Thank you for your help in making Kudu even better!

[[rn_1.9.0]]
== Release Notes Specific to 1.9.0

[[rn_1.9.0_upgrade_notes]]
== Upgrade Notes

* Flume 1.8+ requires Java 8 at runtime even though the Kudu Flume integration
  is Java 7 compatible. Flume 1.9 is the default dependency version as of
  Kudu 1.9.0.

* Hadoop 3.0+ requires Java 8 at runtime even though the Kudu Hadoop integration
  is Java 7 compatible. Hadoop 3.2 is the default dependency version as of
  Kudu 1.9.0.

[[rn_1.9.0_obsoletions]]
== Obsoletions


[[rn_1.9.0_deprecations]]
== Deprecations

* Support for Java 7 has been deprecated since Kudu 1.5.0 and may be removed in
  the next major release.

[[rn_1.9.0_new_features]]
== New features
* Kudu now supports location awareness. When configured, Kudu will make a best
  effort to avoid placing a majority of replicas for a given tablet at the same
  location. The `kudu cluster rebalance` tool has been updated to act in
  accordance with the placement policy of a location-aware Kudu. The
  link:https://kudu.apache.org/releases/1.9.0/docs/administration.html#rack_awareness[administrative
  documentation] has been updated to detail the usage of this feature.

* Docker scripts have been introduced to build and run Kudu on various operating
  systems. See the `/docker` subdirectory of the source repository for more
  details. An link:https://hub.docker.com/r/apache/kudu[official repository] has
  been created for Apache Kudu Docker artifacts.

* Developers integrating with Kudu can now write Java tests that start a Kudu
  mini cluster without having to first locally build and install Kudu. This is
  made possible by the Kudu team providing platform-specific binaries available
  to Gradle or Maven for download and install at test time. More information on
  this feature can be found <<developing.adoc#,here>>. This binary test
  artifact is currently considered to be experimental.

[[rn_1.9.0_improvements]]
== Optimizations and improvements
* When creating a table, the master now enforces a restriction on the total
  number of replicas rather than the total number of partitions. If manually
  overriding `--max_create_tablets_per_ts`, the maximum size of a new table
  has effectively been cut by a factor of its replication factor. Note that
  partitions can still be added after table creation.

* The compaction policy has been updated to favor reducing the number of
  rowsets. This can lead to faster scans and lower bootup times, particularly
  in the face of a “trickling inserts” workload, where rows are inserted slowly
  in primary key order (see
  link:https://issues.apache.org/jira/browse/KUDU-1400[KUDU-1400]).

* A tablet-level metric `average_diskrowset_height` has been added to indicate
  how much a replica needs to be compacted, as indicated by the average number
  of rowsets per unit of keyspace.

* Scans which read multiple columns of tables undergoing a heavy `UPDATE`
  workload are now more CPU efficient. In some cases, scan performance of such
  tables may be several times faster upon upgrading to this release.

* Kudu-Spark users can now provide the short “kudu” format alias to Spark. This
  enables using `.format(“kudu”)` in places where you would have needed to
  provide the fully qualified name like `.format(“org.apache.kudu.spark.kudu")`
  or imported `org.apache.kudu.spark.kudu._` and used the implicit `.kudu`
  functions. The
  link:https://kudu.apache.org/releases/1.9.0/docs/developing.html#_kudu_integration_with_spark[Spark
  integration documentation] has been updated to reflect this improvement.

* The `KuduSink` class has been added to the Spark integration as a
  `StreamSinkProvider`, allowing structured streaming writes into Kudu (see
  link:https://issues.apache.org/jira/browse/KUDU-2640[KUDU-2640]).

* The amount of server-side logging has been greatly reduced for Kudu's
  consensus implementation and background processes. This logging was determined
  to be not useful and unnecessarily verbose.

* The web UI now more obviously depicts which columns are a part of the primary
  key (see link:https://issues.apache.org/jira/browse/KUDU-2477[KUDU-2477]).

* The `kudu table describe` tool has been added to support describing table
  attributes, including schema, partitioning, replication factor, column
  encodings, compressions, and default values.

* The `kudu table scan` tool has been added to scan rows from a table,
  supporting comparison, in-list, and is-null predicates.

* The `kudu locate_row` tool has been added to allow users to determine what
  tablet a given primary key belongs to, and whether a row exists for that
  primary key.

* The `kudu diagnose dump_mem_trackers` tool is added to allow users to output
  the contents of the `/mem-trackers` web UI page in a CSV format.

[[rn_1.9.0_fixed_issues]]
== Fixed Issues
* To avoid glitches and undefined behavior, the Kudu Python client now
  detects and reports on conflicting/incorrect initialization of the OpenSSL
  library.

* Fixed a crash caused by a race between altering tablet schemas and deleting
  tablet replicas (see
  link:https://issues.apache.org/jira/browse/KUDU-1678[KUDU-1678]).

* Fixed an issue that would prevent the `kudu fs update_dirs` tool from
  removing directories in the presence of tablet tombstones (see
  link:https://issues.apache.org/jira/browse/KUDU-2680[KUDU-2680]).

* The `--cmeta_force_fsync` flag may be used to fsync Kudu's consensus
  metadata more aggressively. Setting this to `true` may decrease Kudu's
  performance, but improve its durability in the face of power failures and
  forced shutdowns (see
  link:https://issues.apache.org/jira/browse/KUDU-2195[KUDU-2195]).

* Fixed an issue that would cause an excessive amount of RPC traffic from Kudu
  masters if the tablet servers were configured with duplicated master addresses
  (see link:https://issues.apache.org/jira/browse/KUDU-2684[KUDU-2684]).

* Fixed an issue that would cause the `kudu cluster rebalance` tool to run
  indefinitely in the case of tables with a replication factor of 2 (see
  link:https://issues.apache.org/jira/browse/KUDU-2688[KUDU-2688]).

* Fixed an issue that could lead to a failure to bootstrap tablet replicas
  that were a part of workloads with many alter table operations
  (see link:https://issues.apache.org/jira/browse/KUDU-2690[KUDU-2690]).

* Fixed an issue with the Java scanner's `keepAlive` that could lead to a
  permanent hang in the scanner (see
  link:https://issues.apache.org/jira/browse/KUDU-2710[KUDU-2710]).

* Fixed an issue that would cause undefined behavior upon connecting to a
  secure cluster concurrently from multiple C++ clients (see
  link:https://issues.apache.org/jira/browse/KUDU-2706[KUDU-2706]).

[[rn_1.9.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.9.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.9 clients may connect to servers running Kudu 1.0 or later. If the client uses
  features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.8 and Kudu 1.9 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.9 with the exception of the
  below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.9 and versions earlier than 1.3:

* If a Kudu 1.9 cluster is configured with authentication or encryption set to "required",
  clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.9 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.

[[rn_1.9.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.9.0


[[rn_1.9.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.9 Java client library is API- and ABI-compatible with Kudu 1.8. Applications
  written against Kudu 1.8 will compile and run against the Kudu 1.9 client library and
  vice-versa.

* The Kudu 1.9 {cpp} client is API- and ABI-forward-compatible with Kudu 1.8.
  Applications written and compiled against the Kudu 1.8 client library will run without
  modification against the Kudu 1.9 client library. Applications written and compiled
  against the Kudu 1.9 client library will run without modification against the Kudu 1.8
  client library.

* The Kudu 1.9 Python client is API-compatible with Kudu 1.8. Applications
  written against Kudu 1.8 will continue to run against the Kudu 1.9 client
  and vice-versa.

[[rn_1.9.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.9.0_contributors]]
== Contributors
Kudu 1.9 includes contributions from 24 people, including 5 first-time contributors:

* Bankim Bhavsar
* Mike Parker
* Mitch Barnett
* Tim Armstrong
* Yingchun Lai

Thank you for your help in making Kudu even better!

[[rn_1.8.0]]
== Release Notes Specific to 1.8.0

[[rn_1.8.0_upgrade_notes]]
== Upgrade Notes

- Upgrading directly from Kudu 1.7.0 is supported and no special upgrade steps are
  required. A rolling upgrade may work, however it has not been tested. When upgrading
  Kudu, it is recommended to first shut down all Kudu processes across the cluster, then
  upgrade the software on all servers, then restart the Kudu processes on all servers in
  the cluster.

- Kudu Flume Sink released with Kudu 1.8.0 is compiled against Apache Flume 1.8 and might
  not function with earlier versions of Flume. Note that Flume 1.8 requires Java 1.8 or
  higher.

- Hadoop 3.0+ requires Java 8 at runtime even though the Kudu Hadoop integration is Java 7
  compatible. Hadoop 3.1 is the default dependency version as of Kudu 1.8.0, used by
  certain features in the Java client.

[[rn_1.8.0_obsoletions]]
== Obsoletions

- The `-table_num_buckets` configuration option of the `kudu perf loadgen` tool is now
  removed in favor of `-table_num_hash_partitions` and `-table_num_range_partitions`
  (see link:https://issues.apache.org/jira/browse/KUDU-1861[KUDU-1861]).

[[rn_1.8.0_deprecations]]
== Deprecations

- Support for Java 7 has been deprecated since Kudu 1.5.0 and may be removed in the next
  major release.

- The `producer.skipMissingColumn`, `producer.skipBadColumnValue`, and
  `producer.warnUnmatchedRows` Kudu Flume sink configuration parameters have been
  deprecated in favor of `producer.missingColumnPolicy`, `producer.badColumnValuePolicy`,
  and `producer.unmatchedRowPolicy` respectively (see
  link:https://issues.apache.org/jira/browse/KUDU-1882[KUDU-1882]).

[[rn_1.8.0_new_features]]
== New features

- Examples showcasing functionality in {cpp}, Java, and Python, previously
  hosted in a separate repository have been added. They can be found in the
  `link:https://github.com/apache/kudu/tree/master/examples[examples/]`
  top-level subdirectory.

- Added `kudu diagnose parse_stacks`, a tool to parse sampled stack traces out of a
  diagnostics log (see link:https://issues.apache.org/jira/browse/KUDU-2353[KUDU-2353]).

- Added support for `IS NULL` and `IS NOT NULL` predicates to the Kudu Python client (see
  link:https://issues.apache.org/jira/browse/KUDU-2399[KUDU-2399]).

- Introduced <<administration.adoc#rebalancer_tool,manual data rebalancer>> into the kudu
  CLI tool. The rebalancer can be used to redistribute table replicas among tablet
  servers. The rebalancer can be run via `kudu cluster rebalance` sub-command. Using the
  new tool, it's possible to rebalance Kudu clusters of version 1.4.0 and newer.

- Added `kudu tserver get_flags` and `kudu master get_flags`, two tools that allow
  superusers to retrieve all the values of command line flags from remote Kudu processes.
  The `get_flags` tools support filtering the returned flags by tag, and by default will
  return only flags that were explicitly set.

- Added `kudu tablet unsafe_replace_tablet`, a tool to replace a tablet with a new one.
  This tool is meant to be used to recover a table when one of its tablets has permanently
  lost all replicas. The data in the tablet that is replaced is lost, so this tool should
  only be used as a last resort (see
  link:https://issues.apache.org/jira/browse/KUDU-2290[KUDU-2290]).

[[rn_1.8.0_improvements]]
== Optimizations and improvements

- There is a new metric for each tablet replica tracking the number of election failures
  since the last successful election attempt and the time since the last heartbeat from
  the leader (see link:https://issues.apache.org/jira/browse/KUDU-2287[KUDU-2287]).

- Kudu now supports building and running on Ubuntu 18.04 (“Bionic Beaver”) (see
  link:https://issues.apache.org/jira/browse/KUDU-2427[KUDU-2427]).

- Kudu now supports building and running against OpenSSL 1.1 (see
  link:https://issues.apache.org/jira/browse/KUDU-1889[KUDU-1889]).

- Added Kerberos support to the Kudu Flume sink (see
  link:https://issues.apache.org/jira/browse/KUDU-2012[KUDU-2012]).

- The Kudu Spark connector now supports Spark Streaming DataFrames (see
  link:https://issues.apache.org/jira/browse/KUDU-2539[KUDU-2539]).

- Added `-tables` filtering argument to `kudu table list` (see
  link:https://issues.apache.org/jira/browse/KUDU-2529[KUDU-2529]).

- Clients now support setting a limit on the number of returned rows in scans (see
  link:https://issues.apache.org/jira/browse/KUDU-16[KUDU-16]).

- Added Pandas support to the Python client (see
  link:https://issues.apache.org/jira/browse/KUDU-1276[KUDU-1276]).

- Enabled configuration of mutation buffer in the Python client (see
  link:https://issues.apache.org/jira/browse/KUDU-2441[KUDU-2441]).

- Added a `keepAlive` API call to the `KuduScanner` and `AsyncKuduScanner` in the Java
  client.  This API can be used to keep the scanners alive on the server when processing
  of messages will take longer than the scanner TTL (see
  link:https://issues.apache.org/jira/browse/KUDU-2095[KUDU-2095]).

- The Kudu Spark integration now uses the keepAlive API when reading data. By default it
  will call keepAlive on a scanner with a period of 15 seconds. This will ensure that
  Spark jobs with large batch sizes or slow processing times do not fail with scanner not
  found errors (see link:https://issues.apache.org/jira/browse/KUDU-2563[KUDU-2563]).

- Number of reactor threads in the {cpp} client is now configurable (see
  link:https://issues.apache.org/jira/browse/KUDU-2368[KUDU-2368]).

- Added an optimization to reduce CPU consumption when performing hot metadata lookups in
  the {cpp} client (see link:https://issues.apache.org/jira/browse/KUDU-1977[KUDU-1977]).

- Added an optimization to avoid bottlenecks on `getpwuid_r()` in libnss during a Raft
  leader election storm (see
  link:https://issues.apache.org/jira/browse/KUDU-2395[KUDU-2395]).

- Improved rowset tree pruning making scans with open-ended intervals on primary key (see
  link:https://issues.apache.org/jira/browse/KUDU-2566[KUDU-2566]).

- The `kudu perf loadgen` tool now supports generating range-partitioned tables. The
  `-table_num_buckets` configuration is now removed in favor of
  `-table_num_hash_partitions` and `-table_num_range_partitions` (see
  link:https://issues.apache.org/jira/browse/KUDU-1861[KUDU-1861]).

- CFile checksum failures will now cause the affected tablet replicas to be failed and
  re-replicated elsewhere (see
  link:https://issues.apache.org/jira/browse/KUDU-2469[KUDU-2469]).

- Servers are now able to start up with data directories missing on disk (see
  link:https://issues.apache.org/jira/browse/KUDU-2359[KUDU-2359]).

- The `kudu perf loadgen` tool now creates tables with a period-separated database name,
  for example `default.loadgen_auto_abc123`. This new behavior does not take effect if the
  `--table` flag is provided. The database of the table can be changed using a new
  `--auto_database` flag. This change is made in anticipation of an eventual Kudu/HMS
  integration (see link:https://jira.apache.org/jira/browse/KUDU-2191[KUDU-2191]).

- Introduced `FAILED_UNRECOVERABLE` replica health status. This is to mark replicas which
  are not able to catch up with the leader due to GC-collected segments of WAL and other
  unrecoverable cases like disk failure. With that, the replica management scheme becomes
  hybrid: the system evicts replicas with `FAILED_UNRECOVERABLE` health status before
  adding a replacement if it anticipates that it can commit the transaction, while in
  other cases it first adds a non-voter replica and removes the failed one only after
  promoting a newly added replica to voter role.

- Two additional configuration parameters, `socketReadTimeoutMs`  and `scanRequestTimeout`
  have been added to the Spark connector to allow better tuning to avoid scan timeouts
  under high load.

- The `kudu table` tool now supports two new options to rename tables and columns,
  `rename_table` and `rename_column` respectively.

- Kudu will now wait for the clock to become synchronized at startup, controlled by a new
  flag `-ntp_initial_sync_wait_secs` (see
  link:https://issues.apache.org/jira/browse/KUDU-2242[KUDU-2242]).

- Tablet deletions are now throttled, which will help Kudu clusters remain stable even
  when many tablets are deleted at once. The number of tablets that a tablet server will
  delete at once is controlled by the new flag `-num_tablets_to_delete_simultaneously`
  (see link:https://issues.apache.org/jira/browse/KUDU-2289[KUDU-2289]).

- The `kudu cluster ksck` tool has been significantly enhanced. It now checks master
  health and consensus status, displays any unsafe or hidden flags set in the cluster, and
  produces a summary of the Kudu versions running on the master and tablet servers. In
  addition, it now supports JSON output, both in pretty-printed and compact form. The
  output format is controlled by the `-ksck_format` flag.

[[rn_1.8.0_fixed_issues]]
== Fixed Issues

- When a tablet server was wiped and recreated with the same RPC address, `ksck` listed it
  twice, both as healthy, even though only one of them was there. This bug is now fixed by
  verifying the UUID of the server (see
  link:https://issues.apache.org/jira/browse/KUDU-2364[KUDU-2364]).

- Fixed an issue preventing Kudu from starting when using Vormetric's encrypted filesystem
  (secfs2) on ext4 (see link:https://issues.apache.org/jira/browse/KUDU-2406[KUDU-2406]).

- Fixed an issue where Kudu's block cache memory tracking (as seen on the `/mem-trackers`
  web UI page) wasn’t accounting for all of the overhead of the cache itself (see
  link:https://issues.apache.org/jira/browse/KUDU-972[KUDU-972]).

- Fixed an issue where the {cpp} client would fail to reopen an expired scanner; instead,
  the client would retry in a tight loop and eventually timeout (see
  link:https://issues.apache.org/jira/browse/KUDU-2414[KUDU-2414]).

- When a tablet is deleted, its write-ahead log recovery directory is also deleted, if it
  exists (see link:https://issues.apache.org/jira/browse/KUDU-1038[KUDU-1038]).

- Fixed a tablet server crash when a tablet is scanned with two predicates on its primary
  key and the predicates do not overlap (see
  link:https://issues.apache.org/jira/browse/KUDU-2447[KUDU-2447]).

- Fixed an issue where the Kudu MapReduce connector's `KuduTableInputFormat` may exhaust
  its scan too early (see
  link:https://issues.apache.org/jira/browse/KUDU-2525[KUDU-2525]).

- Fixed an issue with failed tablet copies that would cause subsequent tablet copies to
  crash the tablet server (see
  link:https://issues.apache.org/jira/browse/KUDU-2293[KUDU-2293]).

- Fixed a bug in which incorrect results would be returned in scans following a
  server restart (see
  link:https://issues.apache.org/jira/browse/KUDU-2463[KUDU-2463]).

- Fixed a bug causing a tablet server crash when a write batch request from a client
  failed coarse-grained authorization (see
  link:https://issues.apache.org/jira/browse/KUDU-2540[KUDU-2540]).

- Fixed use-after-free in case of WAL replay error (see
  link:https://issues.apache.org/jira/browse/KUDU-2509[KUDU-2509]).

- Fixed authentication token reacquisition in the {cpp} client (see
  link:https://issues.apache.org/jira/browse/KUDU-2580[KUDU-2580]).

- Fixed a bug where leader logged excessively when the followers fell behind (see
  link:https://issues.apache.org/jira/browse/KUDU-2322[KUDU-2322]).

- Fixed reporting of leader health during lifecycle transitions (see
  link:https://issues.apache.org/jira/browse/KUDU-2335[KUDU-2335]).

- Fixed moving single-replica tablets (see
  link:https://issues.apache.org/jira/browse/KUDU-2443[KUDU-2443]).

- Fixed an error that would cause the kudu CLI tool to unexpectedly exit when the
  connection to the master or tserver was abruptly closed.

- Fixed a rare issue where system failure could leave unexpected null bytes at the end of
  metadata files, causing Kudu to be unable to restart (see
  link:https://issues.apache.org/jira/browse/KUDU-2260[KUDU-2260]).

- Fixed an issue where `kudu cluster ksck` running a snapshot checksum scan would use a
  single snapshot timestamp for all tablets. This caused the checksum process to fail if
  the checksum process took a long time and the number of tablets was sufficiently large.
  The tool should now be able to checksum tables even if the process takes many hours.
  (see link:https://issues.apache.org/jira/browse/KUDU-2179[KUDU-2179]).

[[rn_1.8.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.8.0 is wire-compatible with previous versions of Kudu:

- Kudu 1.8 clients may connect to servers running Kudu 1.0 or later. If the client uses
  features that are not available on the target server, an error will be returned.

- Kudu 1.0 clients may connect to servers running Kudu 1.8 with the exception of the
  below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations on wire
compatibility between Kudu 1.8 and versions earlier than 1.3:

- If a Kudu 1.8 cluster is configured with authentication or encryption set to "required",
  clients older than Kudu 1.3 will be unable to connect.

- If a Kudu 1.8 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.

[[rn_1.8.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.8.0


[[rn_1.8.0_client_compatibility]]
=== Client Library Compatibility

- The Kudu 1.8 Java client library is API- and ABI-compatible with Kudu 1.7. Applications
  written against Kudu 1.7 will compile and run against the Kudu 1.8 client library and
  vice-versa.

- The Kudu 1.8 {cpp} client is API- and ABI-forward-compatible with Kudu 1.7.
  Applications written and compiled against the Kudu 1.7 client library will run without
  modification against the Kudu 1.8 client library. Applications written and compiled
  against the Kudu 1.8 client library will run without modification against the Kudu 1.7
  client library.

- The Kudu 1.8 Python client is API-compatible with Kudu 1.7. Applications written against
  Kudu 1.7 will continue to run against the Kudu 1.8 client and vice-versa.

[[rn_1.8.0_known_issues]]
== Known Issues and Limitations

Please refer to the link:known_issues.html[Known Issues and Limitations] section of the
documentation.

[[rn_1.8.0_contributors]]
== Contributors

Kudu 1.8 includes contributions from 40 people, including 15 first-time contributors:

- Anupama Gupta
- Attila Piros
- Brian McDevitt
- Fengling Wang
- Ferenc Szabó
- Greg Solovyev
- Kiyoshi Mizumaru
- Shriya Gupta
- Thomas Tauber-Marshall
- Tigerquoll
- Yao Xu
- ZhangYao
- helifu
- jinxing64
- qqchang2nd

Thank you for helping to make Kudu even better!

[[rn_1.7.1]]
== Release Notes Specific to 1.7.1

[[rn_1.7.1_fixed_issues]]
== Fixed Issues

Apache Kudu 1.7.1 is a bug-fix release which fixes critical issues in Kudu 1.7.0.

* Fixed and issue where a leader replica could report a follower's health status
  as FAILED instead of FAILED_UNRECOVERABLE. In configurations where the tablet
  replication factor equals to the total number of tablet servers in the cluster,
  that lead to situations where the tablet could not be automatically recovered
  until a new leader was elected or corresponding tablet servers were restarted.
  (see link:https://issues.apache.org/jira/browse/KUDU-2367[KUDU-2367]).

* Fixed an issue where Kudu would fail to start if RLIMIT_NPROC was set to -1.
  (see link:https://issues.apache.org/jira/browse/KUDU-2377[KUDU-2377]).

* Fixed an issue where `kudu-spark` was unable to connect to secure clusters.
  (see link:https://issues.apache.org/jira/browse/KUDU-2379[KUDU-2379]).

* Fixed an issue where the `kudu-python` client would not compile in environments
  where `__int128` is not supported. This was most commonly el6 environments.
  (see link:https://issues.apache.org/jira/browse/KUDU-2412[KUDU-2412]).

* Fixed an issue where unaligned loads of `__int128` integers could result
  in a crash.
  (see link:https://issues.apache.org/jira/browse/KUDU-2378[KUDU-2378]).

* Fixed a bug in `PartialRow.setMin` that could lead to incorrect partition
  pruning when a `decimal` column is part of the tables range partition but
  not a part of the query predicate.
  (see link:https://issues.apache.org/jira/browse/KUDU-2416[KUDU-2416]).

* Fixed an equality check on `decimal` column predicates that could result
  in pruning that is too conservative.

[[rn_1.7.0]]
== Release notes specific to 1.7.0

[[rn_1.7.0_upgrade_notes]]
== Upgrade Notes

* Upgrading directly from Kudu 1.6.0 is supported and no special upgrade steps
  are required. A rolling upgrade of the server side will _not_ work because
  the default replica management scheme changed, and running masters and tablet
  servers with different replica management schemes is not supported, see
  <<rn_1.7.0_incompatible_changes>> for details. However, mixing client and
  server sides of different versions is not a problem. You can still
  update your clients before your servers or vice versa.
  When upgrading to Kudu 1.7, it is required to first shut down all Kudu processes
  across the cluster, then upgrade the software on all servers, then restart
  the Kudu processes on all servers in the cluster.

[[rn_1.7.0_obsoletions]]
== Obsoletions

* The `tcmalloc_contention_time` metric, which previously tracked the amount
  of time spent in memory allocator lock contention, has been removed.

[[rn_1.7.0_deprecations]]
== Deprecations

* Support for Java 7 has been deprecated since Kudu 1.5.0 and may be removed in
  the next major release.

[[rn_1.7.0_new_features]]
== New features

* Kudu now supports the decimal column type. The decimal type is a numeric data type
  with fixed scale and precision suitable for financial and other arithmetic
  calculations where the imprecise representation and rounding behavior of float and
  double make those types impractical. The decimal type is also useful for integers
  larger than int64 and cases with fractional values in a primary key.
  See <<schema_design.adoc#decimal,Decimal Type>> for more details.

* The strategy Kudu uses for automatically healing tablets which have lost a
  replica due to server or disk failures has been improved. The new re-replication
  strategy, or replica management scheme, first adds a replacement tablet replica
  before evicting the failed one. With the previous replica management scheme,
  the system first evicts the failed replica and then adds a replacement. The new
  replica management scheme allows for much faster recovery of tablets in
  scenarios where one tablet server goes down and then returns back shortly after
  5 minutes or so. The new scheme also provides substantially better overall
  stability on clusters with frequent server failures.
  (see link:https://issues.apache.org/jira/browse/KUDU-1097[KUDU-1097]).

* The `kudu fs update_dirs` tool now supports removing directories. Unless the
  `--force` flag is specified, Kudu will not allow the removal of a directory
  across which tablets are configured to spread data. If specified, all tablet
  replicas configured to use that directory will fail upon starting up and be
  replicated elsewhere, provided a majority exists elsewhere.

* Users can use the new `--fs_metadata_dir` to specify the directory in which
  to place tablet-specific metadata. It is recommended, although not
  necessary, that this be placed on a high-performance drive with high
  bandwidth and low latency, e.g. a solid-state drive. If not specified,
  metadata will be placed in the directory specified by `--fs_wal_dir`, or in
  the directory specified by the first entry of `--fs_data_dirs` if metadata
  already exists there from a pre-Kudu 1.7 deployment. Kudu will not
  automatically move existing metadata based on this configuration.

* Kudu 1.7 introduces a new scan read mode READ_YOUR_WRITES. Users can specify
  READ_YOUR_WRITES when creating a new scanner in C++, Java and Python clients.
  If this mode is used, the client will perform a read such that it follows all
  previously known writes and reads from this client. Reads in this mode ensure
  read-your-writes and read-your-reads session guarantees, while minimizing
  latency caused by waiting for outstanding write transactions to complete.
  Note that this is still an experimental feature which may be stabilized in
  future releases.

* The tablet server web UI scans dashboard (/scans) has been improved with
  several new features, including: showing the most recently completed scans,
  a pseudo-SQL scan descriptor that concisely shows the selected columns and
  applied predicates, and more complete and better documented scan statistics.

* Kudu daemons now expose a web page `/stacks` which dumps the current stack
  trace of every thread running in the server. This information can be helpful
  when diagnosing performance issues.

== Optimizations and improvements

* By default, each tablet replica will now stripe data blocks across 3 data
  directories instead of all data directories. This decreases the likelihood
  that any given tablet will be affected in the event of a single disk failure.
  No substantial performance impact is expected due to this feature based on
  link:https://github.com/apache/kudu/commit/60276c54a221d554287c6645df7df542fe6d6443[performance testing].
  This change only affects new replicas created after upgrading to Kudu 1.7.

* Kudu servers previously offered the ability to enable a separate metrics log
  which stores periodic snapshots of all metrics available on a server. This
  functionality is now available as part of a more general “diagnostics log”
  which is enabled by default. The diagnostics log includes periodic dumps of
  server metrics as well as collections of thread stack traces. The default
  configuration ensures that no more than 640MB of diagnostics logs are retained,
  and typically the space consumption is significantly less due to compression.
  The format and contents of this log file are documented in the
  link:administration.html[Administration guide].

* The handling of errors in the synchronous Java client has been improved so that,
  when an exception is thrown, the stack trace indicates the correct location
  where the client function was invoked rather than a call stack of an internal
  worker thread. The original call stack from the worker thread is available as
  a “suppressed exception”.

* The logging of errors in the Java client has been improved to exclude exception
  stack traces for expected scenarios such as failure to connect to a server in a
  cluster. Instead, only a single line informational message will be logged in
  such cases to aid in debugging.

* The Java client now uses a predefined prioritized list of TLS ciphers when
  establishing an encrypted connection to Kudu servers. This cipher list matches
  the list of ciphers preferred for server-to-server communication and ensures
  that the most efficient and secure ciphers are preferred. When the Kudu client
  is running on Java 8 or newer, this provides a substantial speed-up to read
  and write performance.

* Reporting for the `kudu cluster ksck` tool has been updated so tablets and
  tables with on-going tablet copies are shown as "recovering". Additional
  reporting changes have been made to make various common scenarios,
  particularly tablet copies, less alarming.

* The performance of inserting rows containing many string or binary columns has
  been improved, especially in the case of highly concurrent write workloads.

* By default, Spark tasks that scan Kudu will now be able to scan non-leader
  replicas. This allows Spark to more easily schedule kudu-spark tasks local to
  the data. Users can disable this behavior by passing 'leader_only' to the
  'kudu.scanLocality' option."

* The number of OS threads used in the steady state and during bursts of
  activity (such as in Raft leader elections triggered by a node failure) has
  been drastically reduced and should no longer exceed the value of `ulimit -u`.
  As such, it should no longer be necessary to increase the value of `ulimit -u`
  (or of /proc/sys/kernel/threads-max) in order to run a Kudu tablet server in
  most cases.
  (see link:https://issues.apache.org/jira/browse/KUDU-1913[KUDU-1913]).

* An issue where sparse column predicates could cause excessive data-block reads
  has been fixed. Previously in certain scans with sparsely matching predicates
  on multiple columns, Kudu would read and decode the same data blocks many times.
  The improvement typically results in a 5-10x performance increase for the
  affected scans.
  (see link:https://issues.apache.org/jira/browse/KUDU-2231[KUDU-2231]).

* The efficiency and on-disk size of large updated values has been improved.
  This will improve update-heavy workloads which overwrite large (1KiB+) values.
  (see link:https://issues.apache.org/jira/browse/KUDU-2253[KUDU-2253]).


[[rn_1.7.0_fixed_issues]]
== Fixed Issues

* Fixed a scenario where the on-disk data of a tablet server was completely
  erased and and a new tablet server was started on the same host. This issue
  could prevent tablet replicas previously hosted on the server from being
  evicted and re-replicated.
  Tablets now immediately evict replicas that respond with a different server
  UUID than expected.
  (see link:https://issues.apache.org/jira/browse/KUDU-1613[KUDU-1613]).

* Fixed a rare race condition when connecting to masters during their
  startup which might cause a client to get a response without a CA certificate
  and/or authentication token. This would cause the client to fail to authenticate
  with other servers in the cluster. The leader master now always sends a CA
  certificate and an authentication token (when applicable) to a Kudu client
  with a successful ConnectToMaster response.
  (see link:https://issues.apache.org/jira/browse/KUDU-1927[KUDU-1927]).

* The Kudu Java client now will retry a connection if no master is discovered as a
  leader, and the user has a valid authentication token. This avoids failure
  in recoverable cases when masters are in the process of the very first leader
  election after starting up.
  (see link:https://issues.apache.org/jira/browse/KUDU-2262[KUDU-2262]).

* The Java client will now automatically attempt to re-acquire Kerberos
  credentials from the ticket cache when the prior credentials are about to
  expire. This allows client instances to persist longer than the expiration
  time of a single Kerberos ticket so long as some other process renews the
  credentials in the ticket cache. Documentation on interacting with Kerberos
  authentication has been added to the Javadoc for the `AsyncKuduClient` class.
  (see link:https://issues.apache.org/jira/browse/KUDU-2264[KUDU-2264]).

* Follower masters are now able to verify authentication tokens even if they have never
  been a leader. Prior to this fix, if a follower master had never been a leader,
  clients would be unable to authenticate to that master, resulting in spurious
  error messages being logged.
  (see link:https://issues.apache.org/jira/browse/KUDU-2265[KUDU-2265]).

* Fixed a tablet server crash when a tablet replica is deleted during a scan.
  (see link:https://issues.apache.org/jira/browse/KUDU-2295[KUDU-2295]).

* The evaluation order of predicates in scans with multiple predicates has been
  made deterministic. Due to a bug, this was not necessarily the case previously.
  Predicates are applied in most to least selective order, with ties broken by
  column index. The evaluation order may change in the future, particularly when
  better column statistics are made available internally.
  (see link:https://issues.apache.org/jira/browse/KUDU-2312[KUDU-2312]).

* Previously, the `kudu tablet change_config move_replica` tool required all
  tablet servers in the cluster to be available when performing a move. This
  restriction has been relaxed: only the tablet server that will receive a replica
  of the tablet being moved and the hosts of the tablet's existing replicas need to be
  available for the move to occur.
  (see link:https://issues.apache.org/jira/browse/KUDU-2331[KUDU-2331]).

* Fixed a bug in the Java client which prevented the client from locating the
  new leader master after a leader failover in the case that the previous leader
  either remained online or restarted quickly. This bug resulted in the client
  timing out operations with errors indicating that there was no leader master.
  (see link:https://issues.apache.org/jira/browse/KUDU-2343[KUDU-2343]).

* The Unix process username of the client is now included inside the exported
  security credentials, so that the effective username of clients who import
  credentials and subsequently use unauthenticated (SASL PLAIN) connections
  matches the client who exported the security credentials. For example, this is
  useful to let the Spark executors know which username to use if the Spark
  driver has no authentication token. This change only affects clusters with
  encryption disabled using `--rpc_encryption=disabled`.
  (see link:https://issues.apache.org/jira/browse/KUDU-2259[KUDU-2259]).

[[rn_1.7.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.7.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.7 clients may connect to servers running Kudu 1.0 or later. If the client uses
  features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.6 and Kudu 1.7 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.7 with the exception of the
  below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.7 and versions earlier than 1.3:

* If a Kudu 1.7 cluster is configured with authentication or encryption set to "required",
  clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.7 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.

[[rn_1.7.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.7.0

* The newly introduced replica management scheme is not compatible with the
  old scheme, so it's not possible to run pre-1.7 Kudu masters with
  1.7 Kudu tablet servers or vice versa. This is a server-side
  incompatibility only and it does not affect client compatibility. In other words,
  Kudu clients of prior versions are compatible with upgraded Kudu clusters.

**  Kudu masters of 1.7 version will not register Kudu tablet servers of 1.6
    and prior versions.
**  Kudu tablet servers of 1.7 version will not work with Kudu masters of 1.6
    and prior versions.

* The format of the previously-optional metrics log has changed to include a
  human-readable timestamp on each line. The path of the log file has also
  changed with the word “diagnostics” replacing the word “metrics” in the file
  name. The metrics log has been optimized to only include those metrics which
  have changed in between successive samples, and to not include entity attributes
  such as tablet partition information in the log.
  (see link:https://issues.apache.org/jira/browse/KUDU-2297[KUDU-2297]).

[[rn_1.7.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.7 Java client library is API- and ABI-compatible with Kudu 1.6. Applications
  written against Kudu 1.6 will compile and run against the Kudu 1.7 client library and
  vice-versa.

* The Kudu 1.7 {cpp} client is API- and ABI-forward-compatible with Kudu 1.6.
  Applications written and compiled against the Kudu 1.6 client library will run without
  modification against the Kudu 1.7 client library. Applications written and compiled
  against the Kudu 1.7 client library will run without modification against the Kudu 1.6
  client library.

* The Kudu 1.7 Python client is API-compatible with Kudu 1.6. Applications
  written against Kudu 1.6 will continue to run against the Kudu 1.7 client
  and vice-versa.

* Kudu 1.7 clients that attempt to create a table with a decimal column on a
  target server running Kudu 1.6 or earlier will receive an error response.
  Similarly Kudu clients running Kudu 1.6 or earlier will result in an error
  when attempting to access any table containing containing a decimal
  column.

[[rn_1.6.0]]
== Release Notes Specific to 1.6.0

[[rn_1.6.0_upgrade_notes]]
== Upgrade Notes

* Upgrading directly from Kudu 1.5.0 is supported and no special upgrade steps
  are required. A rolling upgrade may work, however it has not been tested.
  When upgrading Kudu, it is recommended to first shut down all Kudu processes
  across the cluster, then upgrade the software on all servers, then restart
  the Kudu processes on all servers in the cluster.

[[rn_1.6.0_obsoletions]]
== Obsoletions

* Support for Spark 1 (kudu-spark_2.10) has been **removed** in Kudu 1.6.0 and
  now only Spark 2 is supported. Spark 1 support was deprecated in Kudu 1.5.0.

[[rn_1.6.0_deprecations]]
== Deprecations

* Support for Java 7 has been deprecated since Kudu 1.5.0 and may be removed in
  the next major release.

[[rn_1.6.0_new_features]]
== New features

* Tablet servers' tolerance of disk failures is now enabled by default and has
  been extended to handle data directory failures at runtime. In the event of
  a disk failure at runtime, any tablets with data on a failed disk will be
  shut down and restarted on another tablet server. There is a configurable
  tradeoff between a newly added tablet's tolerance to disk failures and its
  ability to parallelize reads via the experimental
  `--fs_target_data_dirs_per_tablet` flag. Tablets that are spread across fewer
  disks are less likely to be affected by a disk failure, at the cost of
  reduced parallelism. By default, tablets are striped across all available
  disks. Note that the first configured data directory and the WAL directory
  cannot currently tolerate disk failures. This will be further improved in
  future Kudu releases.

* Kudu servers can now adopt new data directories via the new
  `kudu fs update_dirs` tool. The new directory will be used by new tablet
  replicas only. Note that removing directories is not yet supported
  (see link:https://issues.apache.org/jira/browse/KUDU-2202[KUDU-2202]).

* Kudu servers have two new flags to control webui TLS/HTTPS
  settings: `--webserver_tls_ciphers` and `--webserver_tls_min_protocol`.
  These flags allow the advertised TLS ciphers and TLS protocol versions to be
  configured. Additionally, the webserver now excludes insecure legacy ciphers
  by default
  (see link:https://issues.apache.org/jira/browse/KUDU-2190[KUDU-2190]).

== Optimizations and improvements

* Kudu servers can now tolerate short interruptions in NTP clock
  synchronization. NTP synchronization is still required when any Kudu daemon
  starts up. If NTP synchronization is not available, diagnostic information
  is now logged to help pinpoint the issue
  (see link:https://issues.apache.org/jira/browse/KUDU-1578[KUDU-1578]).

* Tablet server startup time has been improved significantly on servers
  containing large numbers of blocks.

* The log block manager now performs disk data deletion in batches. This
  optimization can significantly reduce the time taken to delete data on a tablet.

* The usage of sensitive data redaction flag has been slightly changed. By
  setting `--redact=log` flag, redaction will be disabled in the web UI but
  retained for server logs. Alternatively, `--redact=none` can be used to
  disable redaction completely.

* The Spark DataSource integration now can take advantage of scan locality
  for better scan performance, the scan will take place at the closest replica
  instead of going to the leader.

* Various optimizations were made to reduce the 99th percentile latency of
  writes on the tablet server. This can also improve throughput on certain
  write workloads, particularly on larger clusters.

* Kudu may now be configured to ignore system-wide auth_to_local mappings
  configured in /etc/krb5.conf by setting the configuration flag
  `--use_system_auth_to_local=false`
  (see link:https://issues.apache.org/jira/browse/KUDU-2198[KUDU-2198]).

* The performance of the compaction scheduler has been improved. In
  previous versions, certain types of time series workloads were found to
  cause compaction scheduling to take tens of seconds. These workloads now
  schedule compactions an order of magnitude more efficiently.

* The compaction scheduler has been improved to avoid running a compaction
  when the benefit of that compaction is extremely small.

* Tablet servers now consider the health of all replicas of a tablet before
  deciding to evict one. This can improve stability of the Kudu cluster after
  experiencing multiple simultaneous daemon failures
  (see link:https://issues.apache.org/jira/browse/KUDU-2048[KUDU-2048]).

* Several performance improvements have been made to the Kudu master,
  particularly in concurrency of clients opening tables. This should improve
  performance in highly concurrent workloads.

* The on-disk size metric for a tablet now includes all data and metadata.
  Previously, it excluded WAL segments and consensus metadata
  (see link:https://issues.apache.org/jira/browse/KUDU-1755[KUDU-1755]).

* Added verbose mode for the 'kudu cluster ksck' command to enable output
  of detailed information on the cluster's metadata, even when no errors are
  detected.

[[rn_1.6.0_fixed_issues]]
== Fixed Issues

* HybridTime timestamp propagation now works in the Java client when using scan
  tokens (see link:https://issues.apache.org/jira/browse/KUDU-1411[KUDU-1411]).

* Fixed an error message commonly found in tablet server logs indicating that
  operations were being read "from the future"
  (see link:https://issues.apache.org/jira/browse/KUDU-1078[KUDU-1078]).

* Tombstoned tablets no longer report metrics
  (see link:https://issues.apache.org/jira/browse/KUDU-2044[KUDU-2044]).

* Fixed a bug in the C++ client which could cause tablets to be erroneously
  pruned, or skipped, during certain scans, resulting in fewer results than
  expected being returned from queries. The bug only affected tables whose range
  partition columns are a proper prefix of the primary key
  (see link:https://issues.apache.org/jira/browse/KUDU-2173[KUDU-2173]).

* Published Kudu Java artifacts are now fully compatible with JRE 7 and JRE 8.
  There was previously a bug in the release process which made them compatible
  only with JRE 8
  (see link:https://issues.apache.org/jira/browse/KUDU-2188[KUDU-2188]).

* Fixed a typo in the list of default TLS ciphers used by Kudu servers. As a
  result, two additional cipher suites are now available:
** ECDHE-RSA-AES128-SHA256 TLSv1.2 Kx=ECDH Au=RSA Enc=AES(128)  Mac=SHA256
** AES256-GCM-SHA384       TLSv1.2 Kx=RSA  Au=RSA Enc=AESGCM(256) Mac=AEAD

[[rn_1.6.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.6.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.6 clients may connect to servers running Kudu 1.0 or later. If the client uses
  features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.5 and Kudu 1.6 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.6 with the exception of the
  below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.6 and versions earlier than 1.3:

* If a Kudu 1.6 cluster is configured with authentication or encryption set to "required",
  clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.6 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.

[[rn_1.6.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.6.0

[[rn_1.6.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.6 Java client library is API- and ABI-compatible with Kudu 1.5. Applications
  written against Kudu 1.5 will compile and run against the Kudu 1.6 client library and
  vice-versa.

* The Kudu 1.6 {cpp} client is API- and ABI-forward-compatible with Kudu 1.5.
  Applications written and compiled against the Kudu 1.5 client library will run without
  modification against the Kudu 1.6 client library. Applications written and compiled
  against the Kudu 1.6 client library will run without modification against the Kudu 1.5
  client library.

* The Kudu 1.6 Python client is API-compatible with Kudu 1.5. Applications
  written against Kudu 1.5 will continue to run against the Kudu 1.6 client
  and vice-versa.

[[rn_1.5.0]]
== Release notes specific to 1.5.0

[[rn_1.5.0_upgrade_notes]]
== Upgrade Notes

* Kudu 1.5 now enables the optional ability to compute, store, and verify
  checksums on all pieces of data stored on a server by default. Due to
  storage format changes, downgrading to versions 1.3 or earlier is not
  supported and will result in an error.

* Spark 2.2+ requires Java 8 at runtime even though Kudu Spark 2.x integration
  is Java 7 compatible. Spark 2.2 is the default dependency version as of
  Kudu 1.5.0.

* The kudu-spark-tools module has been renamed to kudu-spark2-tools_2.11 in
  order to include the Spark and Scala base versions. This matches the pattern
  used in the kudu-spark module and artifacts.

* To improve security, world-readable Kerberos keytab files are no longer
  accepted by default. Set `--allow_world_readable_credentials=true` to override
  this behavior. See
  link:https://issues.apache.org/jira/browse/KUDU-1955[KUDU-1955] for additional
  details.

[[rn_1.5.0_deprecations]]
== Deprecations

* Support for Java 7 is deprecated as of Kudu 1.5.0 and may be removed in the
  next major release.

* Support for Spark 1 (kudu-spark_2.10) is deprecated as of Kudu 1.5.0 and may
  be removed in the next minor release.

[[rn_1.5.0_new_features]]
== New features

* Tablet servers are now optionally able to tolerate disk failures at
  startup. This feature is experimental; by default, Kudu will crash if it
  experiences a disk failure. When enabled, tablets with any data on the failed
  disk will not be opened and will be replicated as needed. To enable this, set
  the `--crash_on_eio` flag to `false`. Additionally, there is a configurable
  tradeoff between a newly added tablet's tolerance to disk failures and its
  parallelization of I/O via the `--fs_target_data_dirs_per_tablet` flag.
  Tablets that are spread across fewer disks are less likely to be affected by a
  disk failure, at the cost of reduced parallelism. Note that the first
  configured data directory and the WAL directory cannot currently tolerate disk
  failures, and disk failures during run-time are still fatal.

* Kudu server web UIs have a new configuration dashboard (/config) which
  provides a high level summary of important security configuration values, such
  as whether RPC authentication is required, or web server HTTPS encryption is
  enabled. Other types of configuration will be added in future releases.

* The `kudu` command line tool has two new features: `kudu tablet change_config
  move_replica` and `kudu local_replica data_size`. The 'tablet change_config
  move_replica' tool moves a tablet replica from one tablet server to another,
  under the condition that the tablet is healthy. An operator can use this tool to
  rebalance tablet replicas between tablet servers. The 'local_replica data size'
  tool summarizes the space usage of a tablet, breaking it down by type of file,
  column, and rowset.

* kudu-client-tools now supports exporting CSV files and importing
  Apache Parquet files. This feature is unstable and may change APIs and
  functionality in future releases.

* kudu-spark-tools now supports importing and exporting CSV, Apache Avro and
  Apache Parquet files. This feature is unstable and may change APIs and
  functionality in future releases.

[[rn_1.5.0_optimizations_improvements]]
== Optimizations and improvements

* The log block manager now performs disk synchronization in batches.
  This optimization can significantly reduce the time taken to copy tablet data
  from one server to another; in one case tablet copy time is reduced by 35%.
  It also improves the general performance of flushes and compactions.

* A new feature referred to as "tombstoned voting" is added to the Raft
  consensus subsystem to allow tablet replicas in the `TABLET_DATA_TOMBSTONED`
  state to vote in tablet leader elections. This feature increases Kudu's
  stability and availability by improving the likelihood that Kudu will be able
  to self-heal in more edge-case scenarios, such as when tablet copy operations
  fail. See link:https://issues.apache.org/jira/browse/KUDU-871[KUDU-871] for
  details.

* The tablet on-disk size metric has been made more accurate. Previously, the
  metric included only REDO deltas; it now counts all deltas. Additionally, the
  metric includes the size of bloomfiles, ad hoc indexes, and the tablet
  superblock. WAL segments and consensus metadata are still not counted. The
  latter is very small compared to the size of data, but the former may be
  significant depending on the workload (this will be resolved in a future
  release).

* The number of threads used by the Kudu tablet server has been further reduced.
  Previously, each follower tablet replica used a dedicated thread to detect
  leader tablet replica failures, and each leader replica used one dedicated
  thread per follower to send Raft heartbeats to that follower. The work
  performed by these dedicated threads has been reassigned to other threads.
  Other improvements were made to facilitate better thread sharing by tablets.
  For the purpose of capacity planning, expect the Kudu tablet server to create
  one thread for every five "cold" (i.e. those not servicing writes) tablets,
  and an additional three threads for every "hot" tablet. This will be further
  improved upon in future Kudu releases.

[[rn_1.5.0_fixed_issues]]
== Fixed Issues

* The Java Kudu client now automatically requests new authentication tokens
  after expiration. As a result, long-lived Java clients are now supported. See
  link:https://issues.apache.org/jira/browse/KUDU-2013[KUDU-2013] for more
  details.

* Multiple Kerberos compatibility bugs have been fixed, including support
  for environments with disabled reverse DNS, FreeIPA compatibility, principal
  names including uppercase characters, and hosts without a FQDN.

* A bug in the binary prefix decoder which could cause a tablet server 'check'
  assertion crash has been fixed. The crash could only be triggered in very
  specific scenarios; see
  link:https://issues.apache.org/jira/browse/KUDU-2085[KUDU-2085] for additional
  details.

[[rn_1.5.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.5.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.5 clients may connect to servers running Kudu 1.0 or later. If the client uses
  features that are not available on the target server, an error will be returned.
* Rolling upgrade between Kudu 1.4 and Kudu 1.5 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.
* Kudu 1.0 clients may connect to servers running Kudu 1.5 with the exception of the
  below-mentioned restrictions regarding secure clusters.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.5 and versions earlier than 1.3:

* If a Kudu 1.5 cluster is configured with authentication or encryption set to "required",
  clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.5 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.

[[rn_1.5.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.5.0

[[rn_1.5.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.5 Java client library is API- and ABI-compatible with Kudu 1.4. Applications
  written against Kudu 1.4 will compile and run against the Kudu 1.5 client library and
  vice-versa, unless one of the following newly added APIs is used:

* The Kudu 1.5 {cpp} client is API- and ABI-forward-compatible with Kudu 1.4.
  Applications written and compiled against the Kudu 1.4 client library will run without
  modification against the Kudu 1.5 client library. Applications written and compiled
  against the Kudu 1.5 client library will run without modification against the Kudu 1.4
  client library.

* The Kudu 1.5 Python client is API-compatible with Kudu 1.4. Applications
  written against Kudu 1.4 will continue to run against the Kudu 1.5 client
  and vice-versa.

[[rn_1.4.0]]
== Release notes specific to 1.4.0

[[rn_1.4.0_upgrade_notes]]
== Upgrade Notes

* The Maintenance Manager now fully uses the threads it's given (see the improvements
  described further below), so it's now able to generate a lot more IO by flushing and
  compacting more often. Generally, the recommended ratio of MM threads to data
  directories is 1:3; operators of clusters above that ratio should be mindful of
  this when upgrading.

[[rn_1.4.0_new_features]]
== New features

* The C++ and Java client libraries now support the ability to alter the
  storage attributes (e.g. encoding and compression) and default value
  of existing columns. Additionally, it is now possible to rename
  a column which is part of a table's primary key.

* The C++ client library now includes an experimental `KuduPartitioner` API which may
  be used to efficiently map rows to their associated partitions and hosts.
  This may be used to achieve better locality or distribution of writes
  in client applications.

* The Java client library now supports enabling fault tolerance on scanners.
  Fault tolerant scanners are able to transparently recover from concurrent
  server crashes at the cost of some performance overhead. See the Java
  API documentation for more details on usage.

* The `kudu` command line tool now includes a new advanced administrative
  command `kudu remote_replica unsafe_change_config`. This command may be used
  to force a tablet to perform an unsafe change of its Raft replication
  configuration. This can be used to recover from scenarios such as a loss
  of a majority of replicas, at the risk of losing edits.

* The `kudu` command line tool now includes the `kudu fs check` command
  which performs various offline consistency checks on the local on-disk
  storage of a Kudu Tablet Server or Master. In addition to detecting
  various inconsistencies or corruptions, it can also detect and remove
  data blocks that are no longer referenced by any tablet but were not
  fully removed from disk due to a crash or a bug in prior versions of Kudu.

* The `kudu` command line tool can now be used to list the addresses and
  identifiers of the servers in the cluster using either `kudu master list`
  or `kudu tserver list`.

* Kudu 1.4 now includes the optional ability to compute, store, and verify
  checksums on all pieces of data stored on a server. Prior versions only
  performed checksums on certain portions of the stored data. This feature
  is not enabled by default since it makes a backward-incompatible change
  to the on-disk formats and thus prevent downgrades. Kudu 1.5 will enable
  the feature by default.

== Optimizations and improvements

* `kudu cluster ksck` now detects and reports new classes of
  inconsistencies and issues. In particular, it is better able to
  detect cases where a configuration change such as a replica eviction
  or addition is pending but is unable to be committed. It also now
  properly detects and reports cases where a tablet has no elected
  leader.

* The default size for Write Ahead Log (WAL) segments has been reduced
  from 64MB to 8MB. Additionally, in the case that all replicas of a
  tablet are fully up to date and data has been flushed from memory,
  servers will now retain only a single WAL segment rather than
  two. These changes are expected to reduce the average consumption of
  disk space on the configured WAL disk by 16x, as well as improve the
  startup speed of tablet servers by reducing the number and size of
  WAL segments that need to be re-read.

* The default on-disk storage system used by Kudu servers (Log Block Manager)
  has been improved to compact its metadata and remove dead containers.
  This compaction and garbage collection occurs only at startup. Thus, the
  first startup after upgrade is expected to be longer than usual, and
  subsequent restarts should be shorter.

* The usability of the Kudu web interfaces has been improved,
  particularly for the case where a server hosts many tablets or a
  table has many partitions. Pages that list tablets now include
  a top-level summary of tablet status and show the complete list
  under a toggleable section.

* The Maintenance Manager has been improved to improve utilization of the
  configured maintenance threads. Previously, maintenance work would
  only be scheduled a maximum of 4 times per second, but now maintenance
  work will be scheduled immediately whenever any configured thread is
  available. This can improve the throughput of write-heavy workloads.

* The Maintenance Manager will now aggressively schedule flushes of
  in-memory data when memory consumption crosses 60% of the configured
  process-wide memory limit. The backpressure mechanism which begins
  to throttle client writes has been accordingly adjusted to not begin
  throttling until reaching 80% of the configured limit. These two
  changes together result in improved write throughput, more consistent
  latency, and fewer timeouts due to memory exhaustion.

* Many performance improvements were made to write performance. Applications
  which send large batches of writes to Kudu should see substantially
  improved throughput in Kudu 1.4.

* Several improvements were made to reduce the memory consumption of
  Kudu Tablet Servers which hold large volumes of data. The specific
  amount of memory saved varies depending on workload, but the expectation
  is that approximately 350MB of excess peak memory usage has been eliminated
  per TB of data stored.

* The number of threads used by the Kudu Tablet Server has been reduced.
  Previously, each tablet used a dedicated thread to append to its WAL.
  Those threads now automatically stop running if there is no activity
  on a given tablet for a short period of time.

[[rn_1.4.0_fixed_issues]]
== Fixed Issues

* link:https://issues.apache.org/jira/browse/KUDU-2020[KUDU-2020]
  Fixed an issue where re-replication after a failure would proceed
  significantly slower than expected. This bug caused many tablets
  to be unnecessarily copied multiple times before successfully
  being considered re-replicated, resulting in significantly more
  network and IO bandwidth usage than expected. Mean time to recovery
  on clusters with large amounts of data is improved by up to 10x by this
  fix.

* link:https://issues.apache.org/jira/browse/KUDU-1982[KUDU-1982]
  Fixed an issue where the Java client would call `NetworkInterface.getByInetAddress`
  very often, causing performance problems particularly on Windows
  where this function can be quite slow.

* link:https://issues.apache.org/jira/browse/KUDU-1755[KUDU-1755]
  Improved the accuracy of the `on_disk_size` replica metrics to
  include the size consumed by bloom filters, primary key indexes,
  and superblock metadata, and delta files. Note that, because the size
  metric is now more accurate, the reported values are expected to
  increase after upgrading to Kudu 1.4. This does not indicate that
  replicas are using more space after the upgrade; rather, it is
  now accurately reporting the amount of space that has always been
  used.

* link:https://issues.apache.org/jira/browse/KUDU-1192[KUDU-1192]
  Kudu servers will now periodically flush their log messages to disk
  even if no `WARNING`-level messages have been logged. This makes it
  easier to tail the logs to see progress output during normal startup.

* link:https://issues.apache.org/jira/browse/KUDU-1999[KUDU-1999]
  Fixed the ability to run Spark jobs in "cluster" mode against
  Kudu clusters secured by Kerberos.


[[rn_1.4.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.4.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.4 clients may connect to servers running Kudu 1.0 or later. If the client uses
  features that are not available on the target server, an error will be returned.
* Kudu 1.0 clients may connect to servers running Kudu 1.4 with the exception of the
  below-mentioned restrictions regarding secure clusters.
* Rolling upgrade between Kudu 1.3 and Kudu 1.4 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.

The authentication features introduced in Kudu 1.3 place the following limitations
on wire compatibility between Kudu 1.4 and versions earlier than 1.3:

* If a Kudu 1.4 cluster is configured with authentication or encryption set to "required",
  clients older than Kudu 1.3 will be unable to connect.
* If a Kudu 1.4 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.

[[rn_1.4.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.4.0

* Kudu servers, by default, will now only allow unencrypted or unauthenticated connections
  from trusted subnets, which are private networks (127.0.0.0/8,10.0.0.0/8,172.16.0.0/12,
  192.168.0.0/16,169.254.0.0/16) and local subnets of all local network interfaces.
  Unencrypted or unauthenticated connections from publicly routable IPs will be rejected,
  even if encryption and authentication are not configured.
+
The trusted subnets can be configured using the `--trusted_subnets` flag, which can be set
   to IP blocks represented in CIDR notation separated by comma. Set it to '0.0.0.0/0' to
   allow unauthenticated connections from all remote IP addresses. However, if network access
   is not otherwise restricted by a firewall, malicious users may be able to gain unauthorized
   access. This can be mitigated if authentication and encryption are configured to be
   required.

[[rn_1.4.0_client_compatibility]]
=== Client Library Compatibility
* The Kudu 1.4 Java client library is API- and ABI-compatible with Kudu 1.3. Applications
  written against Kudu 1.3 will compile and run against the Kudu 1.4 client library and
  vice-versa, unless one of the following newly added APIs is used:
** `[Async]KuduScannerBuilder.setFaultTolerant(...)`
** New methods in `AlterTableOptions`: `removeDefault`, `changeDefault`, `changeDesiredBlockSize`,
   `changeEncoding`, `changeCompressionAlgorithm`
** `KuduClient.updateLastPropagatedTimestamp`
** `KuduClient.getLastPropagatedTimestamp`
** New getters in `PartialRow`: `getBoolean`, `getByte`, `getShort`, `getInt`, `getLong`,
   `getFloat`, `getDouble`, `getString`, `getBinaryCopy`, `getBinary`, `isNull`,
   `isSet`.


* The Kudu 1.4 {cpp} client is API- and ABI-forward-compatible with Kudu 1.3.
  Applications written and compiled against the Kudu 1.3 client library will run without
  modification against the Kudu 1.4 client library. Applications written and compiled
  against the Kudu 1.4 client library will run without modification against the Kudu 1.3
  client library unless they use one of the following new APIs:
** `KuduPartitionerBuilder`
** `KuduPartitioner
** `KuduScanner::SetRowFormatFlags` (unstable API)
** `KuduScanBatch::direct_data`, `KuduScanBatch::indirect_data` (unstable API)

* The Kudu 1.4 Python client is API-compatible with Kudu 1.3. Applications
  written against Kudu 1.3 will continue to run against the Kudu 1.4 client
  and vice-versa.

[[rn_1.3.0]]
== Release notes specific to 1.3.0

[[rn_1.3.0_new_features]]
== New features

* Kudu 1.3 adds support for strong authentication based on Kerberos. This optional feature
  allows users to authenticate themselves using Kerberos tickets, and also provides
  mutual authentication of servers using Kerberos credentials stored in keytabs. This
  feature is optional, but recommended for deployments requiring security.

* Kudu 1.3 adds support for encryption of data on the network using Transport Layer Security
  (TLS). Kudu will now use TLS to encrypt all network traffic between clients and servers as
  well as any internal traffic among servers, with the exception of traffic determined to
  be within a localhost network connection. Encryption is enabled by default whenever it can
  be determined that both the client and server support the feature.

* Kudu 1.3 adds coarse-grained service-level authorization of access to the cluster.
  The operator may set up lists of permitted users who may act as administrators and
  as clients of the cluster. Combined with the strong authentication feature described
  above, this can enable a secure environment for some use cases. Note that fine-grained
  access control (e.g. table-level or column-level) is not yet supported.

* Kudu 1.3 adds a background task to tablet servers which removes historical versions of
  data which have fallen behind the configured data retention time. This reduces disk space
  usage in all workloads, but particularly in those with a higher volume of updates or
  upserts.

* Kudu now incorporates Google Breakpad, a library which writes crash reports in
  the case of a server crash. These reports can be found within the configured log directory,
  and can be useful during bug diagnosis.


== Optimizations and improvements

* Kudu servers will now change the file permissions of data directories and contained
  data files based on a new configuration flag `--umask`. As a result, after upgrading,
  permissions on disk may be more restrictive than in previous versions. The new default
  configuration improves data security.

* Kudu's web UI will now redact strings which may include sensitive user data. For example,
  the monitoring page which shows in-progress scans no longer includes the scanner predicate
  values. The tracing and RPC diagnostics endpoints no longer include contents of RPCs which
  may include table data.

* By default, Kudu now reserves 1% of each configured data volume as free space. If a volume
  is seen to have less than 1% of disk space free, Kudu will stop writing to that volume
  to avoid completely filling up the disk.

* The default encoding for numeric columns (int, float, and double) has been changed
  to `BIT_SHUFFLE`. The default encoding for binary and string columns has been
  changed to `DICT_ENCODING`. Dictionary encoding automatically falls back to the old
  default (`PLAIN`) when cardinality is too high to be effectively encoded.
+
These new defaults match the default behavior of other storage mechanisms such as
  Apache Parquet and are likely to perform better out of the box.

* Kudu now uses `LZ4` compression when writing its Write Ahead Log (WAL). This improves
  write performance and stability for many use cases.

* Kudu now uses `LZ4` compression when writing delta files. This can improve both
  read and write performance as well as save substantial disk usage, especially
  for workloads involving a high number of updates or upserts containing compressible
  data.

* The Kudu API now supports the ability to express `IS NULL` and `IS NOT NULL` predicates
  on scanners. The Spark DataSource integration will take advantage of these new
  predicates when possible.

* Both {cpp} and Java clients have been optimized to prune partitions more effectively
  when performing scans using the `IN (...)` predicate.

* The exception messages produced by the Java client are now truncated to a maximum length
  of 32KB.


[[rn_1.3.0_fixed_issues]]
== Fixed Issues

* link:https://issues.apache.org/jira/browse/KUDU-1893[KUDU-1893]
  Fixed a critical bug in which wrong results would be returned when evaluating
  predicates applied to columns added using the `ALTER TABLE` operation.

* link:https://issues.apache.org/jira/browse/KUDU-1905[KUDU-1905]
  Fixed a crash after inserting a row sharing a primary key with a recently-deleted
  row in tables where the primary key is comprised of all of the columns.

* link:https://issues.apache.org/jira/browse/KUDU-1899[KUDU-1899]
  Fixed a crash after inserting a row with an empty string as the single-column
  primary key.

* link:https://issues.apache.org/jira/browse/KUDU-1904[KUDU-1904]
  Fixed a potential crash when performing random reads against a column using RLE
  encoding and containing long runs of NULL values.

* link:https://issues.apache.org/jira/browse/KUDU-1853[KUDU-1853]
  Fixed an issue where disk space could be leaked on servers which experienced an error
  during the process of copying tablet data from another server.

* link:https://issues.apache.org/jira/browse/KUDU-1856[KUDU-1856]
  Fixed an issue in which disk space could be leaked by Kudu servers storing data on
  partitions using the XFS file system. Any leaked disk space will be automatically
  recovered upon upgrade.

* link:https://issues.apache.org/jira/browse/KUDU-1888[KUDU-1888],
  link:https://issues.apache.org/jira/browse/KUDU-1906[KUDU-1906]
  Fixed multiple issues in the Java client where operation callbacks would never be
  triggered, causing the client to hang.


[[rn_1.3.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.3.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.3 clients may connect to servers running Kudu 1.0. If the client uses features
  that are not available on the target server, an error will be returned.
* Kudu 1.0 clients may connect to servers running Kudu 1.3 with the exception of the
  below-mentioned restrictions regarding secure clusters.
* Rolling upgrade between Kudu 1.2 and Kudu 1.3 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.

The authentication features newly introduced in Kudu 1.3 place the following limitations
on wire compatibility with older versions:

* If a Kudu 1.3 cluster is configured with authentication or encryption set to "required",
  older clients will be unable to connect.
* If a Kudu 1.3 cluster is configured with authentication and encryption set to "optional"
  or "disabled", older clients will still be able to connect.


[[rn_1.3.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.3.0

* Due to storage format changes in Kudu 1.3, downgrade from Kudu 1.3 to earlier versions
  is not supported. After upgrading to Kudu 1.3, attempting to restart with an earlier
  version will result in an error.

* In order to support running MapReduce and Spark jobs on secure clusters, these
  frameworks now connect to the cluster at job submission time to retrieve authentication
  credentials which can later be used by the tasks to be spawned. This means that
  the process submitting jobs to Kudu clusters must have direct access to that cluster.

* The embedded web servers in Kudu processes now specify the `X-Frame-Options: DENY` HTTP
  header which prevents embedding Kudu web pages in HTML `iframe` elements.

[[rn_1.3.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.3 Java client library is API- and ABI-compatible with Kudu 1.2. Applications
  written against Kudu 1.2 will compile and run against the Kudu 1.3 client library and
  vice-versa, unless one of the following newly added APIs is used:
** `[Async]KuduClient.exportAuthenticationCredentials(...)` (unstable API)
** `[Async]KuduClient.importAuthenticationCredentials(...)` (unstable API)
** `[Async]KuduClient.getMasterAddressesAsString()`
** `KuduPredicate.newIsNotNullPredicate()`
** `KuduPredicate.newIsNullPredicate()`

* The Kudu 1.3 {cpp} client is API- and ABI-forward-compatible with Kudu 1.2.
  Applications written and compiled against the Kudu 1.2 client library will run without
  modification against the Kudu 1.3 client library. Applications written and compiled
  against the Kudu 1.3 client library will run without modification against the Kudu 1.2
  client library unless they use one of the following new APIs:
** `kudu::DisableOpenSSLInitialization()`
** `KuduClientBuilder::import_authentication_credentials(...)`
** `KuduClient::ExportAuthenticationCredentials(...)`
** `KuduClient::NewIsNotNullPredicate(...)`
** `KuduClient::NewIsNullPredicate(...)`

* The Kudu 1.3 Python client is API-compatible with Kudu 1.2. Applications
  written against Kudu 1.2 will continue to run against the Kudu 1.3 client
  and vice-versa.


[[rn_1.2.0]]
== Release notes specific to 1.2.0

[[rn_1.2.0_new_features]]
== New features

* Kudu clients and servers now redact user data such as cell values
  from log messages, Java exception messages, and `Status` strings.
  User metadata such as table names, column names, and partition
  bounds are not redacted.
+
Redaction is enabled by default, but may be disabled by setting the new
`log_redact_user_data` flag to `false`.

* Kudu's ability to provide consistency guarantees has been substantially
improved:

** Replicas now correctly track their "safe timestamp". This timestamp
   is the maximum timestamp at which reads are guaranteed to be
   repeatable.

** A scan created using the `SCAN_AT_SNAPSHOT` mode will now
   either wait for the requested snapshot to be "safe" at the replica
   being scanned, or be re-routed to a replica where the requested
   snapshot is "safe". This ensures that all such scans are repeatable.

** Kudu Tablet Servers now properly retain historical data when a row
   with a given primary key is inserted and deleted, followed by the
   insertion of a new row with the same key. Previous versions of Kudu
   would not retain history in such situations. This allows the server
   to return correct results for snapshot scans with a timestamp in the
   past, even in the presence of such "reinsertion" scenarios.

** The Kudu clients now automatically retain the timestamp of their latest
   successful read or write operation. Scans using the `READ_AT_SNAPSHOT` mode
   without a client-provided timestamp automatically assign a timestamp
   higher than the timestamp of their most recent write. Writes also propagate
   the timestamp, ensuring that sequences of operations with causal dependencies
   between them are assigned increasing timestamps. Together, these changes
   allow clients to achieve read-your-writes consistency, and also ensure
   that snapshot scans performed by other clients return causally-consistent
   results.

* Kudu servers now automatically limit the number of log files.
  The number of log files retained can be configured using the
  `max_log_files` flag. By default, 10 log files will be retained
  at each severity level.

== Optimizations and improvements

* The logging in the Java and {cpp} clients has been substantially quieted.
  Clients no longer log messages in normal operation unless there
  is some kind of error.

* The {cpp} client now includes a `KuduSession::SetErrorBufferSpace`
  API which can limit the amount of memory used to buffer
  errors from asynchronous operations.

* The Java client now fetches tablet locations from the Kudu Master
  in batches of 1000, increased from batches of 10 in prior versions.
  This can substantially improve the performance of Spark and Impala
  queries running against Kudu tables with large numbers of tablets.

* Table metadata lock contention in the Kudu Master was substantially
  reduced. This improves the performance of tablet location lookups on
  large clusters with a high degree of concurrency.

* Lock contention in the Kudu Tablet Server during high-concurrency
  write workloads was also reduced. This can reduce CPU consumption and
  improve performance when a large number of concurrent clients are writing
  to a smaller number of a servers.

* Lock contention when writing log messages has been substantially reduced.
  This source of contention could cause high tail latencies on requests,
  and when under high load could contribute to cluster instability
  such as election storms and request timeouts.

* The `BITSHUFFLE` column encoding has been optimized to use the `AVX2`
  instruction set present on processors including Intel(R) Sandy Bridge
  and later. Scans on `BITSHUFFLE`-encoded columns are now up to 30% faster.

* The `kudu` tool now accepts hyphens as an alternative to underscores
  when specifying actions. For example, `kudu local-replica copy-from-remote`
  may be used as an alternative to `kudu local_replica copy_from_remote`.

[[rn_1.2.0_fixed_issues]]
== Fixed Issues

* link:https://issues.apache.org/jira/browse/KUDU-1508[KUDU-1508]
  Fixed a long-standing issue in which running Kudu on `ext4` file systems
  could cause file system corruption.

* link:https://issues.apache.org/jira/browse/KUDU-1399[KUDU-1399]
  Implemented an LRU cache for open files, which prevents running out of
  file descriptors on long-lived Kudu clusters. By default, Kudu will
  limit its file descriptor usage to half of its configured `ulimit`.

* link:http://gerrit.cloudera.org:8080/5192[Gerrit #5192]
  Fixed an issue which caused data corruption and crashes in the case that
  a table had a non-composite (single-column) primary key, and that column
  was specified to use `DICT_ENCODING` or `BITSHUFFLE` encodings. If a
  table with an affected schema was written in previous versions of Kudu,
  the corruption will not be automatically repaired; users are encouraged
  to re-insert such tables after upgrading to Kudu 1.2 or later.

* link:http://gerrit.cloudera.org:8080/5541[Gerrit #5541]
  Fixed a bug in the Spark `KuduRDD` implementation which could cause
  rows in the result set to be silently skipped in some cases.

* link:https://issues.apache.org/jira/browse/KUDU-1551[KUDU-1551]
  Fixed an issue in which the tablet server would crash on restart in the
  case that it had previously crashed during the process of allocating
  a new WAL segment.

* link:https://issues.apache.org/jira/browse/KUDU-1764[KUDU-1764]
  Fixed an issue where Kudu servers would leak approximately 16-32MB of disk
  space for every 10GB of data written to disk. After upgrading to Kudu
  1.2 or later, any disk space leaked in previous versions will be
  automatically recovered on startup.

* link:https://issues.apache.org/jira/browse/KUDU-1750[KUDU-1750]
  Fixed an issue where the API to drop a range partition would drop any
  partition with a matching lower _or_ upper bound, rather than any partition
  with matching lower _and_ upper bound.

* link:https://issues.apache.org/jira/browse/KUDU-1766[KUDU-1766]
  Fixed an issue in the Java client where equality predicates which compared
  an integer column to its maximum possible value (e.g. `Integer.MAX_VALUE`)
  would return incorrect results.

* link:https://issues.apache.org/jira/browse/KUDU-1780[KUDU-1780]
  Fixed the `kudu-client` Java artifact to properly shade classes in the
  `com.google.thirdparty` namespace. The lack of proper shading in prior
  releases could cause conflicts with certain versions of Google Guava.

* link:http://gerrit.cloudera.org:8080/5327[Gerrit #5327]
  Fixed shading issues in the `kudu-flume-sink` Java artifact. The sink
  now expects that Hadoop dependencies are provided by Flume, and properly
  shades the Kudu client's dependencies.

* Fixed a few issues using the Python client library from Python 3.


[[rn_1.2.0_wire_compatibility]]
== Wire Protocol compatibility

Kudu 1.2.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.2 clients may connect to servers running Kudu 1.0. If the client uses features
  that are not available on the target server, an error will be returned.
* Kudu 1.0 clients may connect to servers running Kudu 1.2 without limitations.
* Rolling upgrade between Kudu 1.1 and Kudu 1.2 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.

[[rn_1.2.0_incompatible_changes]]
== Incompatible Changes in Kudu 1.2.0

* The replication factor of tables is now limited to a maximum of 7. In addition,
  it is no longer allowed to create a table with an even replication factor.

* The `GROUP_VARINT` encoding is now deprecated. Kudu servers have never supported
  this encoding, and now the client-side constant has been deprecated to match the
  server's capabilities.

=== New Restrictions on Data, Schemas, and Identifiers

Kudu 1.2.0 introduces several new restrictions on schemas, cell size, and identifiers:

Number of Columns:: By default, Kudu will not permit the creation of tables with
more than 300 columns. We recommend schema designs that use fewer columns for best
performance.

Size of Cells:: No individual cell may be larger than 64KB. The cells making up a
a composite key are limited to a total of 16KB after the internal composite-key encoding
done by Kudu. Inserting rows not conforming to these limitations will result in errors
being returned to the client.

Valid Identifiers:: Identifiers such as column and table names are now restricted to
be valid UTF-8 strings. Additionally, a maximum length of 256 characters is enforced.

[[rn_1.2.0_client_compatibility]]
=== Client Library Compatibility

* The Kudu 1.2 Java client is API- and ABI-compatible with Kudu 1.1. Applications
  written against Kudu 1.1 will compile and run against the Kudu 1.2 client and
  vice-versa.

* The Kudu 1.2 {cpp} client is API- and ABI-forward-compatible with Kudu 1.1.
  Applications written and compiled against the Kudu 1.1 client will run without
  modification against the Kudu 1.2 client. Applications written and compiled
  against the Kudu 1.2 client will run without modification against the Kudu 1.1
  client unless they use one of the following new APIs:
** `kudu::DisableSaslInitialization()`
** `KuduSession::SetErrorBufferSpace(...)`

* The Kudu 1.2 Python client is API-compatible with Kudu 1.1. Applications
  written against Kudu 1.1 will continue to run against the Kudu 1.2 client
  and vice-versa.


[[rn_1.1.0]]
== Release notes specific to 1.1.0

[[rn_1.1.0_new_features]]
== New features

* The Python client has been brought up to feature parity with the Java and {cpp} clients
  and as such the package version will be brought to 1.1 with this release (from 0.3). A
  list of the highlights can be found below.
    ** Improved Partial Row semantics
    ** Range partition support
    ** Scan Token API
    ** Enhanced predicate support
    ** Support for all Kudu data types (including a mapping of Python's `datetime.datetime` to
    `UNIXTIME_MICROS`)
    ** Alter table support
    ** Enabled Read at Snapshot for Scanners
    ** Enabled Scanner Replica Selection
    ** A few bug fixes for Python 3 in addition to various other improvements.

* IN LIST predicate pushdown support was added to allow optimized execution of filters which
  match on a set of column values. Support for Spark, Map Reduce and Impala queries utilizing
  IN LIST pushdown is not yet complete.

* The Java client now features client-side request tracing in order to help troubleshoot timeouts.
  Error messages are now augmented with traces that show which servers were contacted before the
  timeout occurred instead of just the last error. The traces also contain RPCs that were
  required to fulfill the client's request, such as contacting the master to discover a tablet's
  location. Note that the traces are not available for successful requests and are not
  programmatically queryable.

== Optimizations and improvements

* Kudu now publishes JAR files for Spark 2.0 compiled with Scala 2.11 along with the
  existing Spark 1.6 JAR compiled with Scala 2.10.

* The Java client now allows configuring scanners to read from the closest replica instead of
  the known leader replica. The default remains the latter. Use the relevant `ReplicaSelection`
  enum with the scanner's builder to change this behavior.

* Tablet servers use a new policy for retaining write-ahead log (WAL) segments.
  Previously, servers used the 'log_min_segments_to_retain' flag to prioritize
  any flushes which were retaining log segments past the configured value (default 2).
  This policy caused servers to flush in-memory data more frequently than necessary,
  limiting write performance.
+
The new policy introduces a new flag 'log_target_replay_size_mb' which
  determines the threshold at which write-ahead log retention will prioritize flushes.
  The new flag is considered experimental and users should not need to modify
  its value.
+
The improved policy has been seen to improve write performance in some use cases
  by a factor of 2x relative to the old policy.

* Kudu's implementation of the Raft consensus algorithm has been improved to include
  a "pre-election" phase. This can improve the stability of tablet leader election
  in high-load scenarios, especially if each server hosts a high number of tablets.

* Tablet server start-up time has been substantially improved in the case that
  the server contains a high number of tombstoned tablet replicas.

=== Command line tools

* The tool `kudu tablet leader_step_down` has been added to manually force a leader to step down.
* The tool `kudu remote_replica copy` has been added to manually copy a replica from
  one running tablet server to another.
* The tool `kudu local_replica delete` has been added to delete a replica of a tablet.
* The `kudu test loadgen` tool has been added to replace the obsoleted
  `insert-generated-rows` standalone binary. The new tool is enriched with
  additional functionality and can be used to run load generation tests against
  a Kudu cluster.

== Wire protocol compatibility

Kudu 1.1.0 is wire-compatible with previous versions of Kudu:

* Kudu 1.1 clients may connect to servers running Kudu 1.0. If the client uses the new
  'IN LIST' predicate type, an error will be returned.
* Kudu 1.0 clients may connect to servers running Kudu 1.1 without limitations.
* Rolling upgrade between Kudu 1.0 and Kudu 1.1 servers is believed to be possible
  though has not been sufficiently tested. Users are encouraged to shut down all nodes
  in the cluster, upgrade the software, and then restart the daemons on the new version.

[[rn_1.1.0_incompatible_changes]]
== Incompatible changes in Kudu 1.1.0

=== Client APIs ({cpp}/Java/Python)

* The {cpp} client no longer requires the
  link:https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html[old gcc5 ABI].
  Which ABI is actually used depends on the compiler configuration. Some new distros
  (e.g. Ubuntu 16.04) will use the new ABI. Your application must use the same ABI as is
  used by the client library; an easy way to guarantee this is to use the same compiler
  to build both.

* The {cpp} client's `KuduSession::CountBufferedOperations()` method is
  deprecated. Its behavior is inconsistent unless the session runs in the
  `MANUAL_FLUSH` mode. Instead, to get number of buffered operations, count
  invocations of the `KuduSession::Apply()` method since last
  `KuduSession::Flush()` call or, if using asynchronous flushing, since last
  invocation of the callback passed into `KuduSession::FlushAsync()`.

* The Java client's `OperationResponse.getWriteTimestamp` method was renamed to `getWriteTimestampRaw`
  to emphasize that it doesn't return milliseconds, unlike what its Javadoc indicated. The renamed
  method was also hidden from the public APIs and should not be used.

* The Java client's sync API (`KuduClient`, `KuduSession`, `KuduScanner`) used to throw either
  a `NonRecoverableException` or a `TimeoutException` for a timeout, and now it's only possible for the
  client to throw the former.

* The Java client's handling of errors in `KuduSession` was modified so that subclasses of
  `KuduException` are converted into RowErrors instead of being thrown.

[[rn_1.0.1]]
== Release notes specific to 1.0.1

Apache Kudu 1.0.1 is a bug fix release, with no new features or backwards
incompatible changes.

[[rn_1.0.1_fixed_issues]]
=== Fixed Issues

- link:https://issues.apache.org/jira/browse/KUDU-1681[KUDU-1681] Fixed a bug in
  the tablet server which could cause a crash when the DNS lookup during master
  heartbeat failed.

- link:https://issues.apache.org/jira/browse/KUDU-1660[KUDU-1660]: Fixed a bug
  which would cause the Kudu master and tablet server to fail to start on single
  CPU systems.

- link:https://issues.apache.org/jira/browse/KUDU-1651[KUDU-1652]: Fixed a bug
  that would cause the C++ client, tablet server, and Java client to crash or
  throw an exception when attempting to scan a table with a predicate which
  simplifies to `IS NOT NULL` on a non-nullable column. For instance, setting a
  `<= 127` predicate on an `INT8` column could trigger this bug, since the
  predicate only filters null values.

- link:https://issues.apache.org/jira/browse/KUDU-1651[KUDU-1651]: Fixed a bug
  that would cause the tablet server to crash when evaluating a scan with
  predicates over a dictionary encoded column containing an entire block of null
  values.

- link:https://issues.apache.org/jira/browse/KUDU-1623[KUDU-1623]: Fixed a bug
  that would cause the tablet server to crash when handling UPSERT operations
  that only set values for the primary key columns.

- link:http://gerrit.cloudera.org:8080/4488[Gerrit #4488] Fixed a bug in the
  Java client's KuduException class which could cause an unexpected
  NullPointerException to be thrown when the exception did not have an
  associated message.

- link:https://issues.apache.org/jira/browse/KUDU-1090[KUDU-1090] Fixed a bug in
  the memory tracker which could cause a rare crash during tablet server
  startup.

[[rn_1.0.0]]
== Release notes specific to 1.0.0

After approximately a year of beta releases, Apache Kudu has reached version 1.0.
This version number signifies that the development team feels that Kudu is stable
enough for usage in production environments.

If you are new to Kudu, check out its list of link:index.html[features and benefits].

[[rn_1.0.0_new_features]]
=== New features

Kudu 1.0.0 delivers a number of new features, bug fixes, and optimizations.

- Removal of multiversion concurrency control (MVCC) history is now supported.
  This is known as tablet history GC. This allows Kudu to reclaim disk space,
  where previously Kudu would keep a full history of all changes made to a
  given table since the beginning of time. Previously, the only way to reclaim
  disk space was to drop a table.
+
Kudu will still keep historical data, and the amount of history retained is
  controlled by setting the configuration flag `--tablet_history_max_age_sec`,
  which defaults to 15 minutes (expressed in seconds). The timestamp
  represented by the current time minus `tablet_history_max_age_sec` is known
  as the ancient history mark (AHM). When a compaction or flush occurs, Kudu
  will remove the history of changes made prior to the ancient history mark.
  This only affects historical data; currently-visible data will not be
  removed. A specialized maintenance manager background task to remove existing
  "cold" historical data that is not in a row affected by the normal compaction
  process will be added in a future release.

- Most of Kudu's command line tools have been consolidated under a new
  top-level `kudu` tool. This reduces the number of large binaries distributed
  with Kudu and also includes much-improved help output.

- The Kudu Flume Sink now supports processing events containing Avro-encoded
  records, using the new `AvroKuduOperationsProducer`.

- Administrative tools including `kudu cluster ksck` now support running
  against multi-master Kudu clusters.

- The output of the `ksck` tool is now colorized and much easier to read.

- The {cpp} client API now supports writing data in `AUTO_FLUSH_BACKGROUND` mode.
  This can provide higher throughput for ingest workloads.

=== Optimizations and improvements

- The performance of comparison predicates on dictionary-encoded columns has
  been substantially optimized. Users are encouraged to use dictionary encoding
  on any string or binary columns with low cardinality, especially if these
  columns will be filtered with predicates.

- The Java client is now able to prune partitions from scanners based on the
  provided predicates. For example, an equality predicate on a hash-partitioned
  column will now only access those tablets that could possibly contain matching
  data. This is expected to improve performance for the Spark integration as well
  as applications using the Java client API.

- The performance of compaction selection in the tablet server has been
  substantially improved. This can increase the efficiency of the background
  maintenance threads and improve overall throughput of heavy write workloads.

- The policy by which the tablet server retains write-ahead log (WAL) files has
  been improved so that it takes into account other replicas of the tablet.
  This should help mitigate the spurious eviction of tablet replicas on machines
  that temporarily lag behind the other replicas.

=== Wire protocol compatibility

Kudu 1.0.0 maintains client-server wire-compatibility with previous releases.
Applications using the Kudu client libraries may be upgraded either
before, at the same time, or after the Kudu servers.

Kudu 1.0.0 does _not_ maintain server-server wire compatibility with previous
releases. Therefore, rolling upgrades between earlier versions of Kudu and
Kudu 1.0.0 are not supported.

[[rn_1.0.0_incompatible_changes]]
=== Incompatible changes in Kudu 1.0.0

==== Command line tools

- The `kudu-pbc-dump` tool has been removed. The same functionality is now
  implemented as `kudu pbc dump`.

- The `kudu-ksck` tool has been removed. The same functionality is now
  implemented as `kudu cluster ksck`.

- The `cfile-dump` tool has been removed. The same functionality is now
  implemented as `kudu fs cfile dump`.

- The `log-dump` tool has been removed. The same functionality is now
  implemented as `kudu wal dump` and `kudu local_replica dump wals`.

- The `kudu-admin` tool has been removed. The same functionality is now
  implemented within `kudu table` and `kudu tablet`.

- The `kudu-fs_dump` tool has been removed. The same functionality is now
  implemented as `kudu fs dump`.

- The `kudu-ts-cli` tool has been removed. The same functionality is now
  implemented within `kudu master`, `kudu remote_replica`, and `kudu tserver`.

- The `kudu-fs_list` tool has been removed and some similar useful
  functionality has been moved under 'kudu local_replica'.

==== Configuration flags

- Some configuration flags are now marked as 'unsafe' and 'experimental'. Such flags
  are disallowed by default. Users may access these flags by enabling the additional
  flags `--unlock_unsafe_flags` and `--unlock_experimental_flags`. Usage of such flags
  is not recommended, as the flags may be removed or modified with no deprecation period
  and without notice in future Kudu releases.

==== Client APIs ({cpp}/Java/Python)

- The `TIMESTAMP` column type has been renamed to `UNIXTIME_MICROS` in order to
  reduce confusion between Kudu's timestamp support and the timestamps supported
  by other systems such as Apache Hive and Apache Impala (incubating). Existing
  tables will automatically be updated to use the new name for the type.
+
Clients upgrading to the new client libraries must move to the new name for
  the type.  Clients using old client libraries will continue to operate using
  the old type name, even when connected to clusters that have been
  upgraded. Similarly, if clients are upgraded before servers, existing
  timestamp columns will be available using the new type name.


- `KuduSession` methods in the {cpp} library are no longer advertised as thread-safe
  to have one set of semantics for both {cpp} and Java Kudu client libraries.

- The `KuduScanToken::TabletServers` method in the {cpp} library has been removed.
  The same information can now be found in the KuduScanToken::tablet method.

==== Apache Flume Integration

- The `KuduEventProducer` interface used to process Flume events into Kudu operations
  for the Kudu Flume Sink has changed, and has been renamed `KuduOperationsProducer`.
  The existing `KuduEventProducer`s have been updated for the new interface, and have
  been renamed similarly.

[[rn_0.10.0]]
== Release notes specific to 0.10.0

Kudu 0.10.0 delivers a number of new features, bug fixes, and optimizations,
detailed below.

Kudu 0.10.0 maintains wire-compatibility with previous releases, meaning
that applications using the Kudu client libraries may be upgraded either
before, at the same time, or after the Kudu servers. However, if you begin
using new features of Kudu 0.10.0 such as manually range-partitioned tables,
you must first upgrade all clients to this release.

This release does not maintain full Java API or ABI compatibility with
Kudu 0.9.x due to a package rename and some other small changes. See below for details.

See also +++<a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20KUDU%20AND%20status%20%3D%20Resolved
%20AND%20fixVersion%20%3D%200.10.0">JIRAs resolved
for Kudu 0.10.0</a>+++ and +++<a href="https://github.com/apache/kudu/compare/0.9.1...0.10.0">Git
changes between 0.9.1 and 0.10.0</a>+++.

[[rn_0.10.0_incompatible_changes]]
=== Incompatible changes and deprecated APIs in 0.10.0

- link:http://gerrit.cloudera.org:8080/3737[Gerrit #3737] The Java client has been repackaged
  under `org.apache.kudu` instead of `org.kududb`. Import statements for Kudu classes must
  be modified in order to compile against 0.10.0. Wire compatibility is maintained.

- link:https://gerrit.cloudera.org/#/c/3055/[Gerrit #3055] The Java client's
  synchronous API methods now throw `KuduException` instead of `Exception`.
  Existing code that catches `Exception` should still compile, but introspection of an
  exception's message may be impacted. This change was made to allow thrown exceptions to be
  queried more easily using `KuduException.getStatus` and calling one of `Status`'s methods.
  For example, an operation that tries to delete a table that doesn't exist would return a
  `Status` that returns true when queried on `isNotFound()`.

- The Java client's `KuduTable.getTabletsLocations` set of methods is now
  deprecated. Additionally, they now take an exclusive end partition key instead
  of an inclusive key. Applications are encouraged to use the scan tokens API
  instead of these methods in the future.

- The C++ API for specifying split points on range-partitioned tables has been improved
  to make it easier for callers to properly manage the ownership of the provided rows.
+
The `TableCreator::split_rows` API took a `vector<const KuduPartialRow*>`, which
  made it very difficult for the calling application to do proper error handling with
  cleanup when setting the fields of the `KuduPartialRow`. This API has been now been
  deprecated and replaced by a new method `TableCreator::add_range_split` which allows
  easier use of smart pointers for safe memory management.

- The Java client's internal buffering has been reworked. Previously, the number of
  buffered write operations was constrained on a per-tablet-server basis. Now, the configured
  maximum buffer size constrains the total number of buffered operations across all
  tablet servers in the cluster. This provides a more consistent bound on the memory
  usage of the client regardless of the size of the cluster to which it is writing.
+
This change can negatively affect the write performance of Java clients which rely on
  buffered writes. Consider using the `setMutationBufferSpace` API to increase a
  session's maximum buffer size if write performance seems to be degraded after upgrading
  to Kudu 0.10.0.

- The "remote bootstrap" process used to copy a tablet replica from one host to
  another has been renamed to "Tablet Copy". This resulted in the renaming of
  several RPC metrics. Any users previously explicitly fetching or monitoring metrics
  related to Remote Bootstrap should update their scripts to reflect the new names.

- The SparkSQL datasource for Kudu no longer supports mode `Overwrite`. Users should
  use the new `KuduContext.upsertRows` method instead. Additionally, inserts using the
  datasource are now upserts by default. The older behavior can be restored by setting
  the `operation` parameter to `insert`.

[[rn_0.10.0_new_features]]
=== New features

- Users may now manually manage the partitioning of a range-partitioned table.
  When a table is created, the user may specify a set of range partitions that
  do not cover the entire available key space. A user may add or drop range
  partitions to existing tables.
+
This feature can be particularly helpful with time series workloads in which
  new partitions can be created on an hourly or daily basis. Old partitions
  may be efficiently dropped if the application does not need to retain historical
  data past a certain point.
+
This feature is considered experimental for the 0.10 release. More details of
  the new feature can be found in the accompanying
  link:https://kudu.apache.org/2016/08/23/new-range-partitioning-features.html[blog post].

- Support for running Kudu clusters with multiple masters has been stabilized.
  Users may start a cluster with three or five masters to provide fault tolerance
  despite a failure of one or two masters, respectively.
+
Note that certain tools (e.g. `ksck`) are still lacking complete support for
  multiple masters. These deficiencies will be addressed in a following release.

- Kudu now supports the ability to reserve a certain amount of free disk space
  in each of its configured data directories. If a directory's free disk space
  drops to less than the configured minimum, Kudu will stop writing to that
  directory until space becomes available. If no space is available in any
  configured directory, Kudu will abort.
+
This feature may be configured using the `fs_data_dirs_reserved_bytes` and
  `fs_wal_dir_reserved_bytes` flags.

- The Spark integration's `KuduContext` now supports four new methods for writing to
  Kudu tables: `insertRows`, `upsertRows`, `updateRows`, and `deleteRows`. These are
  now the preferred way to write to Kudu tables from Spark.

[[rn_0.10.0_improvements]]
=== Improvements and optimizations

- link:https://issues.apache.org/jira/browse/KUDU-1516[KUDU-1516] The `kudu-ksck` tool
  has been improved and now detects problems such as when a tablet does not have
  a majority of replicas on live tablet servers, or if those replicas aren’t in a
  good state. Users who currently depend on the tool to detect inconsistencies may now see
  failures when before they wouldn't see any.

- link:https://gerrit.cloudera.org:8080/3477[Gerrit #3477] The way operations are buffered in
  the Java client has been reworked. Previously, the session's buffer size was set per tablet, meaning that a buffer
  size of 1,000 for 10 tablets being written to allowed for 10,000 operations to be buffered at the
  same time. With this change, all the tablets share one buffer, so users might need to set a
  bigger buffer size in order to reach the same level of performance as before.

- link:https://gerrit.cloudera.org/#/c/3674/[Gerrit #3674] Added LESS and GREATER options for
  column predicates.

- link:https://issues.apache.org/jira/browse/KUDU-1444[KUDU-1444] added support for passing
  back basic per-scan metrics (e.g cache hit rate) from the server to the C++ client. See the
  `KuduScanner::GetResourceMetrics()` API for detailed usage. This feature will be supported
  in the Java client API in a future release.

- link:https://issues.apache.org/jira/browse/KUDU-1446[KUDU-1446] improved the order in
  which the tablet server evaluates predicates, so that predicates on smaller columns
  are evaluated first. This may improve performance on queries which apply predicates
  on multiple columns of different sizes.

- link:https://issues.apache.org/jira/browse/KUDU-1398[KUDU-1398] improved the storage
  efficiency of Kudu's internal primary key indexes. This optimization should decrease space
  usage and improve random access performance, particularly for workloads with lengthy
  primary keys.

[[rn_0.10.0_fixed_issues]]
=== Fixed Issues

- link:https://gerrit.cloudera.org/#/c/3541/[Gerrit #3541] Fixed a problem in the Java client
  whereby an RPC could be dropped when a connection to a tablet server or master was forcefully
  closed on the server-side while RPCs to that server were in the process of being encoded.
  The effect was that the RPC would not be sent, and users of the synchronous API would receive
  a `TimeoutException`. Several other Java client bugs which could cause similar spurious timeouts
  were also fixed in this release.

- link:https://gerrit.cloudera.org/#/c/3724/[Gerrit #3724] Fixed a problem in the Java client
  whereby an RPC could be dropped when a socket timeout was fired while that RPC was being sent to
  a tablet server or master. This would manifest itself in the same way
  link:https://gerrit.cloudera.org/#/c/3541/[Gerrit #3541].

- link:https://issues.apache.org/jira/browse/KUDU-1538[KUDU-1538] fixed a bug in which recycled
  block identifiers could cause the tablet server to lose data. Following this bug fix, block
  identifiers will no longer be reused.

[[rn_0.10.0_changes]]
=== Other noteworthy changes

- This is the first release of Apache Kudu as a top-level (non-incubating)
  project!

- The default false positive rate for Bloom filters has been changed
  from 1% to 0.01%. This will increase the space consumption of Bloom
  filters by a factor of two (from approximately 10 bits per row to
  approximately 20 bits per row). This is expected to substantially
  improve the performance of random-write workloads at the cost of an
  incremental increase in disk space usage.

- The Kudu C++ client library now has Doxygen-based
  link:http://kudu.apache.org/cpp-client-api/[API documentation]
  available online.

- Kudu now
  link:http://kudu.apache.org/2016/06/17/raft-consensus-single-node.html[
  uses the Raft consensus algorithm even for unreplicated tables].
  This change simplifies code and will also allow administrators to enable
  replication on a previously-unreplicated table. This change is internal and
  should not be visible to users.

[[rn_0.9.1]]
== Release notes specific to 0.9.1

Kudu 0.9.1 delivers incremental bug fixes over Kudu 0.9.0. It is fully compatible with
Kudu 0.9.0.

See also +++<a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20KUDU%20AND%20status%20%3D%20Resolved
%20AND%20fixVersion%20%3D%200.9.1">JIRAs resolved
for Kudu 0.9.1</a>+++ and +++<a href="https://github.com/apache/kudu/compare/0.9.0...0.9.1">Git
changes between 0.9.0 and 0.9.1</a>+++.

[[rn_0.9.1_fixed_issues]]
=== Fixed Issues

- link:https://issues.apache.org/jira/browse/KUDU-1469[KUDU-1469] fixed a bug in
our Raft consensus implementation that could cause a tablet to stop making progress after a leader
election.

- link:https://gerrit.cloudera.org/#/c/3456/[Gerrit #3456] fixed a bug in which
servers under high load could store metric information in incorrect memory
locations, causing crashes or data corruption.

- link:https://gerrit.cloudera.org/#/c/3457/[Gerrit #3457] fixed a bug in which
errors from the Java client would carry an incorrect error message.

- Several other small bug fixes were backported to improve stability.

[[rn_0.9.0]]
== Release notes specific to 0.9.0

Kudu 0.9.0 delivers incremental features, improvements, and bug fixes over the previous versions.

See also +++<a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20KUDU%20AND%20status%20%3D%20Resolved
%20AND%20fixVersion%20%3D%200.9.0">JIRAs resolved
for Kudu 0.9.0</a>+++ and +++<a href="https://github.com/apache/kudu/compare/0.8.0...0.9.0">Git
changes between 0.8.0 and 0.9.0</a>+++.

[[rn_0.9.0_incompatible_changes]]
=== Incompatible changes

- The `KuduTableInputFormat` command has changed the way in which it handles
  scan predicates, including how it serializes predicates to the job configuration
  object. The new configuration key is `kudu.mapreduce.encoded.predicate`. Clients
  using the `TableInputFormatConfigurator` are not affected.

- The `kudu-spark` sub-project has been renamed to follow naming conventions for
  Scala. The new name is `kudu-spark_2.10`.

- Default table partitioning has been removed. All tables must now be created
  with explicit partitioning. Existing tables are unaffected. See the
  <<schema_design.adoc#no_default_partitioning,schema design guide>> for more
  details.

[[rn_0.9.0_new_features]]
=== New features
- link:https://issues.apache.org/jira/browse/KUDU-1002[KUDU-1002] Added support for
 `UPSERT` operations, whereby a row is inserted if it does not already exist, but
 updated if it does. Support for `UPSERT` is included in Java, C++, and Python APIs,
 but not in Impala.

- link:https://issues.apache.org/jira/browse/KUDU-1306[KUDU-1306] Scan token API
  for creating partition-aware scan descriptors. This API simplifies executing
  parallel scans for clients and query engines.

- link:http://gerrit.cloudera.org:8080/#/c/2848/[Gerrit 2848] Added a kudu datasource
  for Spark. This datasource uses the Kudu client directly instead of
  using the MapReduce API. Predicate pushdowns for `spark-sql` and Spark filters are
  included, as well as parallel retrieval for multiple tablets and column projections.
  See an example of link:developing.html#_kudu_integration_with_spark[Kudu integration with Spark].

- link:http://gerrit.cloudera.org:8080/#/c/2992/[Gerrit 2992] Added the ability
  to update and insert from Spark using a Kudu datasource.

[[rn_0.9.0_improvements]]
=== Improvements

- link:https://issues.apache.org/jira/browse/KUDU-1415[KUDU-1415] Added statistics in the Java
  client such as the number of bytes written and the number of operations applied.

- link:https://issues.apache.org/jira/browse/KUDU-1451[KUDU-1451] Improved tablet server restart
  time when the tablet server needs to clean up of a lot previously deleted tablets. Tablets are
  now cleaned up after they are deleted.

[[rn_0.9.0_fixed_issues]]
=== Fixed Issues

- link:https://issues.apache.org/jira/browse/KUDU-678[KUDU-678] Fixed a leak that happened during
  DiskRowSet compactions where tiny blocks were still written to disk even if there were no REDO
  records. With the default block manager, it usually resulted in block containers with thousands
  of tiny blocks.

- link:https://issues.apache.org/jira/browse/KUDU-1437[KUDU-1437] Fixed a data corruption issue
  that occured after compacting sequences of negative INT32 values in a column that
  was configured with RLE encoding.

[[rn_0.9.0_changes]]
=== Other noteworthy changes

All Kudu clients have longer default timeout values, as listed below.

.Java
- The default operation timeout and the default admin operation timeout
  are now set to 30 seconds instead of 10.
- The default socket read timeout is now 10 seconds instead of 5.

.C++
- The default admin timeout is now 30 seconds instead of 10.
- The default RPC timeout is now 10 seconds instead of 5.
- The default scan timeout is now 30 seconds instead of 15.

- Some default settings related to I/O behavior during flushes and compactions have been changed:
  The default for `flush_threshold_mb` has been increased from 64MB to 1000MB. The default
  `cfile_do_on_finish` has been changed from `close` to `flush`.
  link:http://getkudu.io/2016/04/26/ycsb.html[Experiments using YCSB] indicate that these
  values will provide better throughput for write-heavy applications on typical server hardware.


[[rn_0.8.0]]
== Release notes specific to 0.8.0

Kudu 0.8.0 delivers incremental features, improvements, and bug fixes over the previous versions.

See also +++<a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20KUDU%20AND%20status%20%3D%20Resolved
%20AND%20fixVersion%20%3D%200.8.0">JIRAs resolved
for Kudu 0.8.0</a>+++ and +++<a href="https://github.com/apache/kudu/compare/0.7.1...0.8.0">Git
changes between 0.7.1 and 0.8.0</a>+++.

To upgrade to Kudu 0.8.0, see link:installation.html#upgrade[Upgrade from 0.7.1 to 0.8.0].

[[rn_0.8.0_incompatible_changes]]
=== Incompatible changes

- 0.8.0 clients are not fully compatible with servers running Kudu 0.7.1 or lower.
In particular, scans that specify column predicates will fail. To work around this
issue, upgrade all Kudu servers before upgrading clients.

[[rn_0.8.0_new_features]]
=== New features

- link:https://issues.apache.org/jira/browse/KUDU-431[KUDU-431] A simple Flume
  sink has been implemented.

[[rn_0.8.0_improvements]]
=== Improvements

- link:https://issues.apache.org/jira/browse/KUDU-839[KUDU-839] Java RowError now uses an enum error code.

- link:http://gerrit.cloudera.org:8080/#/c/2138/[Gerrit 2138] The handling of
  column predicates has been re-implemented in the server and clients.

- link:https://issues.apache.org/jira/browse/KUDU-1379[KUDU-1379] Partition pruning
  has been implemented for C++ clients (but not yet for the Java client). This feature
  allows you to avoid reading a tablet if you know it does not serve the row keys you are querying.

- link:http://gerrit.cloudera.org:8080/#/c/2641[Gerrit 2641] Kudu now uses
  `earliest-deadline-first` RPC scheduling and rejection. This changes the behavior
  of the RPC service queue to prevent unfairness when processing a backlog of RPC
  threads and to increase the likelihood that an RPC will be processed before it
  can time out.


[[rn_0.8.0_fixed_issues]]
=== Fixed Issues

- link:https://issues.apache.org/jira/browse/KUDU-1337[KUDU-1337] Tablets from tables
  that were deleted might be unnecessarily re-bootstrapped when the leader gets the
  notification to delete itself after the replicas do.

- link:https://issues.apache.org/jira/browse/KUDU-969[KUDU-969] If a tablet server
  shuts down while compacting a rowset and receiving updates for it, it might immediately
  crash upon restart while bootstrapping that rowset's tablet.

- link:https://issues.apache.org/jira/browse/KUDU-1354[KUDU-1354] Due to a bug in Kudu's
  MVCC implementation where row locks were released before the MVCC commit happened,
  flushed data would include out-of-order transactions, triggering a crash on the
  next compaction.

- link:https://issues.apache.org/jira/browse/KUDU-1322[KUDU-1322] The C++ client
  now retries write operations if the tablet it is trying to reach has already been
  deleted.

- link:http://gerrit.cloudera.org:8080/#/c/2571/[Gerrit 2571] Due to a bug in the
  Java client, users were unable to close the `kudu-spark` shell because of
  lingering non-daemon threads.

[[rn_0.8.0_changes]]
=== Other noteworthy changes

- link:http://gerrit.cloudera.org:8080/#/c/2239/[Gerrit 2239] The concept of "feature flags"
  was introduced in order to manage compatibility between different
  Kudu versions. One case where this is helpful is if a newer client attempts to use
  a feature unsupported by the currently-running tablet server. Rather than receiving
  a cryptic error, the user gets an error message that is easier to interpret.
  This is an internal change for Kudu system developers and requires no action by
  users of the clients or API.

[[rn_0.7.1]]
== Release notes specific to 0.7.1

Kudu 0.7.1 is a bug fix release for 0.7.0.

[[rn_0.7.1_fixed_issues]]

=== Fixed Issues

- https://issues.apache.org/jira/browse/KUDU-1325[KUDU-1325] fixes a tablet server crash that could
occur during table deletion. In some cases, while a table was being deleted, other replicas would
attempt to re-replicate tablets to servers that had already processed the deletion. This could
trigger a race condition that caused a crash.

- https://issues.apache.org/jira/browse/KUDU-1341[KUDU-1341] fixes a potential data corruption and
crash that could happen shortly after tablet server restarts in workloads that repeatedly delete
and re-insert rows with the same primary key. In most cases, this corruption affected only a single
replica and could be repaired by re-replicating from another.

- https://issues.apache.org/jira/browse/KUDU-1343[KUDU-1343] fixes a bug in the Java client that
occurs when a scanner has to scan multiple batches from one tablet and then start scanning from
another. In particular, this would affect any scans using the Java client that read large numbers
of rows from multi-tablet tables.

- https://issues.apache.org/jira/browse/KUDU-1345[KUDU-1345] fixes a bug where in some cases the
hybrid clock could jump backwards, resulting in a crash followed by an inability to
restart the affected tablet server.

- https://issues.apache.org/jira/browse/KUDU-1360[KUDU-1360] fixes a bug in the kudu-spark module
which prevented reading rows with `NULL` values.

[[rn_0.7.0]]
== Release notes specific to 0.7.0

Kudu 0.7.0 is the first release done as part of the Apache Incubator and includes a number
of changes, new features, improvements, and fixes.

See also +++<a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20KUDU%20AND%20status%20in%20
(Resolved)%20AND%20fixVersion%20%3D%200.7.0%20ORDER%20BY%20key%20ASC">JIRAs resolved
for Kudu 0.7.0</a>+++ and +++<a href="https://github.com/apache/kudu/compare/branch-0.6.0...branch-0.7.0">Git
changes between 0.6.0 and 0.7.0</a>+++.

The upgrade instructions can be found at link:installation.html#upgrade[Upgrade from 0.6.0 to 0.7.0].

[[rn_0.7.0_incompatible_changes]]
=== Incompatible changes

- The C++ client includes a new API, `KuduScanBatch`, which performs better when a
large number of small rows are returned in a batch. The old API of `vector<KuduRowResult>`
is deprecated.
+
NOTE: This change is API-compatible but *not* ABI-compatible.

- The default replication factor has been changed from 1 to 3. Existing tables will
continue to use the replication factor they were created with. Applications that create
tables may not work properly if they assume a replication factor of 1 and fewer than
3 replicas are available. To use the previous default replication factor, start the
master with the configuration flag `--default_num_replicas=1`.

- The Python client has been completely rewritten, with a focus on improving code
quality and testing. The read path (scanners) has been improved by adding many of
the features already supported by the C++ and Java clients. The Python client is no
longer considered experimental.

[[rn_0.7.0_new_features]]
=== New features

- With the goal of Spark integration in mind, a new `kuduRDD` API has been added,
which wraps `newAPIHadoopRDD` and includes a default source for Spark SQL.

[[rn_0.7.0_improvements]]
=== Improvements

- The Java client includes new methods `countPendingErrors()` and
`getPendingErrors()` on `KuduSession`. These methods allow you to count and
retrieve outstanding row errors when configuring sessions with `AUTO_FLUSH_BACKGROUND`.

- New server-level metrics allow you to monitor CPU usage and context switching.

- Kudu now builds on RHEL 7, CentOS 7, and SLES 12. Extra instructions are included
for SLES 12.


[[rn_0.7.0_fixed_issues]]
=== Fixed Issues

- https://issues.apache.org/jira/browse/KUDU-1288[KUDU-1288] fixes a severe file descriptor
leak, which could previously only be resolved by restarting the tablet server.

- https://issues.apache.org/jira/browse/KUDU-1250[KUDU-1250] fixes a hang in the Java
client when processing an in-flight batch and the previous batch encountered an error.

[[rn_0.7.0_changes]]
=== Other noteworthy changes

- The file block manager's performance was improved, but it is still not recommended for
real-world use.

- The master now attempts to spread tablets more evenly across the cluster during
table creation. This has no impact on existing tables, but will improve the speed
at which under-replicated tablets are re-replicated after a tablet server failure.

- All licensing documents have been modified to adhere to ASF guidelines.

- Kudu now requires an out-of-tree build directory. Review the build instructions
for additional information.

- The `C++` client library is now explicitly built against the
link:https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html[old gcc5 ABI].
If you use gcc5 to build a Kudu application, your application must use the old ABI
as well. This is typically achieved by defining the `_GLIBCXX_USE_CXX11_ABI` macro
at compile-time when building your application. For more information, see the
previous link and link:http://developerblog.redhat.com/2015/02/05/gcc5-and-the-c11-abi/.

- The Python client is no longer considered experimental.


[[rn_0.6.0]]
== Release notes specific to 0.6.0

The 0.6.0 release contains incremental improvements and bug fixes. The most notable
changes are:

- The Java client's CreateTableBuilder and AlterTableBuilder classes have been renamed
to CreateTableOptions and AlterTableOptions. Their methods now also return `this` objects,
allowing them to be used as builders.
- The Java client's AbstractKuduScannerBuilder#maxNumBytes() setter is now called
batchSizeBytes as is the corresponding property in AsyncKuduScanner. This makes it
consistent with the C++ client.
- The "kudu-admin" tool can now list and delete tables via its new subcommands
"list_tables" and "delete_table <table_name>".
- OSX is now supported for single-host development. Please consult its specific installation
instructions in link:installation.html#osx_from_source[OS X].


[[rn_0.5.0]]
== Release Notes Specific to 0.5.0

Kudu 0.5.0 was the first public release. As such, no improvements or changes were
noted in its release notes.