Recent releases for rethinkdb

rethinkdb v2.0.0-0RC1

2015-03-20T17:03:23+00:00

This is a release candidate for the upcoming RethinkDB 2.0 release. **It is not for production use. It might still have bugs.** If you decide to test it, please [back up all](http://www.rethinkdb.com/docs/backup/) your data first. Please report any bugs you find on GitHub (http://github.com/rethinkdb/rethinkdb/issues/new) or on our mailing list (https://groups.google.com/forum/#!forum/rethinkdb). Release highlights: - Support for attaching a changefeed to the `get_all` and `union` commands - Improved support for asynchronous queries Read the [blog post](http://rethinkdb.com/blog/2.0-release-candidate/) for more details. ## Download ### 1. Download the server - **Source** [tarball](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb-2.0.0-0RC1.tgz) - **OS X** [64 bit dmg](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb-2.0.0-0RC1.dmg) - **CentOS 6 and 7** [64 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb-2.0.0_0RC1.x86_64.rpm) | [32 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb-2.0.0_0RC1.i686.rpm) - **Ubuntu 10.04 lucid** [64 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0lucid_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0lucid_i386.deb) - **Ubuntu 12.04 precise** [64 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0precise_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0precise_i386.deb) - **Ubuntu 13.10 saucy** [64 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0saucy_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0saucy_i386.deb) - **Ubuntu 14.04 trusty** [64 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0trusty_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0trusty_i386.deb) - **Ubuntu 14.10 utopic** [64 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0utopic_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0utopic_i386.deb) - **Debian wheezy** [64 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0wheezy_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0wheezy_i386.deb) - **Debian jessie** [64 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0jessie_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb_2.0.0%2b0RC1~0jessie_i386.deb) ### 2. Download a driver **Update (03/31/2015):** _The drivers have been updated to include EventMachine (Ruby) and Tornado (Python) integration._ #### JavaScript ``` $ npm install http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb-2.0.0-RC1.nodejs.tgz ``` #### Python ``` $ pip install http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb-2.0.0rc2.python.tar.gz ``` #### Ruby ``` $ wget http://download.rethinkdb.com/dev/2.0.0-0RC1/rethinkdb-2.0.0.rc.2.gem $ gem install rethinkdb-2.0.0.rc.2.gem ``` ## Compatibility Data files accessed with this release candidate might be incompatible with the final version of RethinkDB 2.0. ### Handling of negative zero in indexes IEEE 754 floating point numbers distinguish between negative (-0) and positive (+0) zero. The following information is only relevant if you are storing negative zero values in your documents. We expect very few users to be affected by this change. ReQL compares -0 and +0 as equal in accordance with IEEE 754. In previous versions of RethinkDB, -0 and +0 were however treated as distinct values in primary and secondary indexes. This could lead to inconsistent behavior and wrong query results in some rare cases. Starting with RethinkDB 2.0, -0 and +0 are indexed as equal values. Secondary indexes can be [migrated online](http://rethinkdb.com/docs/troubleshooting/#my-secondary-index-is-outdated) using the `rethinkdb index-rebuild` utility. If any of your documents have negative zero values in their primary keys, those documents will become partially inaccessible in RethinkDB 2.0. You will need to re-import the affected tables using the `rethinkdb dump` and `rethinkdb restore` commands. See the article "[Back up your data](http://www.rethinkdb.com/docs/backup/)" for more information. If you are unsure if any of your documents are affected, you can run `python -m rethinkdb._negative_zero_check` after upgrading both the server and Python driver. See the output of `python -m rethinkdb._negative_zero_check --help` for additional options. ### API-breaking changes - `between` no longer accepts `null` bounds. The new `r.minval` and `r.maxval` can be used instead - The `any` and `all` commands have been removed. The `or` and `and` commands can be used instead - `indexes_of` has been renamed to `offsets_of` - The `squash` argument to `changes` now defaults to `false` - The type hierarchy for exception types in the Python driver changed. All exceptions including `RqlDriverError` now inherit from the `RqlError` type. `RqlRuntimeError`, `RqlCompileError` and `RqlClientError` additionally inherit from the new `RqlQueryError` type ## New Features - ReQL - Added support for changefeeds on `get_all` and `union` queries (#3642) - `between` no longer accepts `null` as a bound. The new `r.minval` and `r.maxval` can be used instead (#1023) - Added support for getting the state of a changefeed using the new `include_states` optarg to `changes` (#3709) - Drivers - Added support for non-blocking `cursor.next` (#3529) - Added support for executing multiple queries in parallel on a single connection (#3754) - Consolidated the return types and use the new `ResponseNotes` field to convey extra information (#3715) - Python driver - Added an optional script that warns for documents with negative zero in a primary key (#3637) ## Improvements - Server - Report open cursors as a single entry in the jobs table (#3662) - Timestamps are no longer sent between servers in `batchspec_t` (#2671) - Some expensive changefeed checks are no longer performed in release mode (#3656) - Include the remote port number in the heartbeat timeout message (#2891) - Improved the ordering and throttling of reads and writes (#1606) - Limit the number of documents per write batch to reduce the impact of large writes on other queries (#3806) - Execute multiple queries in parallel on a single connection (#3296) - Improved the performance of sending responses (#3744) - Immediately send back an empty first batch when the result is a changefeed (#3852) - Web UI - Added a configurable limit for the results per page in the Data Explorer (#3910) - Added an "add table" button to each database (#3522) - ReQL - `table.rebalance` with insufficient data is no longer an error (#3679) - Renamed `indexes_of` to `offsets_of` to avoid confusion with secondary indexes (#3265) - Removed `any` and `all` in favor of `or` and `and` (#1581) - Trivial changes are filtered out from `return_changes` (#3697) - Reduced the size of profiles (#3218) - Changefeeds are no longer squashed by default (#3904) - JavaScript driver - Added an upper bound to the bluebird dependency (#3823) - Ruby driver - Added a `timeout` option to `r.connect` (#1666) - Improved the code style (#3900, #3901, #3906) - Strings are now allowed as keys in the config options (#3905) - Build - Upgraded to a more recent version of V8 and dropped support for out-of-tree V8 (#3472) - Added support for building with Python 3 (#3731) - Packaging - Got rid of the outdated bash completion script (#719) - Allow installing RethinkDB in 32-bit OS X on a 64-bit processor (#1595) - Tests - Increased the number of retries in the `RDBBtree` tests to avoid false positives (#3805) ## Bug Fixes - Server - Fixed a race condition that could be caused by concurrent queries (#3766) - Deleted servers and tables are no longer counted during version checks (#3692) - Made JSON parsing more strict (#3810) - Fixed a bug that could cause the server to crash when killed (#3792) - Databases can no longer be renamed to "rethinkdb" (#3858) - Return an initial value for point changefeeds on system tables (#3723) - Improved the handling of negative zero (#3637) - Correctly abort `order_by.limit` changefeeds when a table become unavailable (#3932) - Do not unlink files early to avoid crashing in virtual environments (#3791) - ReQL - Fixed the behavior of point changefeeds on system tables (#3944) - `noreplyWait` no longer waits for non-`noreply` queries (#3812) - Web UI - Fixed a bug that caused the status icon to be green when a table was unavailable (#3500) - Fixed a bug that truncated labels in the performance graph (#3751) - Correctly handle the escape key in modal dialogs (#3872) - Fixed a bug that caused an `InternalError` when loading large tables (#3873) - Fixed a bug that caused the Data Explorer to break when reading older data from `localStorage` (#3935) - Fixed a bug that caused autocompletion to fail in certain cases (#3143) - Python driver - Fixed `rethinkdb export` compatibility between Python 2 and Python 3 (#3911) - JavaScript driver - Fixed a bug that caused `cursor.each` to fail with an exception (#3826) - Fixed a bug that caused connection errors to be discarded (#3733) - Ruby driver - Fixed a bug that caused failures when using JRuby (#3795) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship the RethinkDB 2.0 release candidate. In no particular order: - Andrey Deryabin (@aderyabin) - Angelo Ashmore (@angeloashmore) - Armen Filipetyan (@armenfilipetyan) - Bill Barsch (@billbarsch) - Tinco Andringa (@d-snp) - Elian Gidoni (@eliangidoni) - Ed Costello (@epc) - Jonathan Ong (@jonathanong) - Justin Mealey (@justinmealey) - Krishna Narasimhan (@krishnanm86) - Andrei Horak (@linkyndy) - Loring Dodge (@loringdodge) - Mike Marcacci (@mike-marcacci) - Param Aggarwal (@paramaggarwal) - @sharow - @tundrax - Kai Curry (@webmasterkai)

rethinkdb v1.16.3

2015-03-27T22:01:31+00:00

Bug fix update. - Fixed a bug that could cause a crash when reading from a secondary index in some rare circumstances (#3976) - Fixed a bug that could cause a connection to hang indefinitely on OS X (#3954) - Fixed `rethinkdb export` compatibility between Python 2 and Python 3 (#3911) - Heartbeat timeout messages now include the remote port number (#2891) - Python driver: patched to work in PyPy (#3969) - Python driver: fixed an "Unterminated string" error during `rethinkdb restore` (#3859) - JavaScript driver: fixed a bug that caused `cursor.each` to fail with an exception (#3826) - JavaScript driver: fixed a bug that caused connection errors to be discarded (#3733) - Ruby driver: fixed a bug that caused failures when using JRuby (#3795) ## Contributors - Sherzod Kuchkarov (@tundrax) - Elian Gidoni (@eliangidoni)

rethinkdb v2.0.0

2015-04-14T15:01:57+00:00

Release highlights: - Support for attaching a changefeed to the `get_all` and `union` commands - Improved support for asynchronous queries - The first production-ready release of RethinkDB Read the [release blog post](http://rethinkdb.com/blog/2.0-release/) for more details. ## Compatibility Data files from RethinkDB versions 1.13.0 onward will be automatically migrated to version 2.0. As with any major release, back up your data files before performing the upgrade. ### Handling of negative zero in indexes IEEE 754 floating point numbers distinguish between negative (-0) and positive (+0) zero. The following information is only relevant if you are storing negative zero values in your documents. We expect very few users to be affected by this change. ReQL compares -0 and +0 as equal in accordance with IEEE 754. In previous versions of RethinkDB, -0 and +0 were however treated as distinct values in primary and secondary indexes. This could lead to inconsistent behavior and wrong query results in some rare cases. Starting with RethinkDB 2.0, -0 and +0 are indexed as equal values. Secondary indexes can be [migrated online](http://rethinkdb.com/docs/troubleshooting/#my-secondary-index-is-outdated) using the `rethinkdb index-rebuild` utility. If any of your documents have negative zero values in their primary keys, those documents will become partially inaccessible in RethinkDB 2.0. You will need to re-import the affected tables using the `rethinkdb dump` and `rethinkdb restore` commands. See the article "[Back up your data](http://www.rethinkdb.com/docs/backup/)" for more information. If you are unsure if any of your documents are affected, you can run `python -m rethinkdb._negative_zero_check` after upgrading both the server and Python driver. See the output of `python -m rethinkdb._negative_zero_check --help` for additional options. ### API-breaking changes - `between` no longer accepts `null` bounds. The new `r.minval` and `r.maxval` can be used instead - The `any` and `all` commands have been removed. The `or` and `and` commands can be used instead - `indexes_of` has been renamed to `offsets_of` - The `squash` argument to `changes` now defaults to `false` - The type hierarchy for exception types in the Python driver changed. All exceptions including `RqlDriverError` now inherit from the `RqlError` type. `RqlRuntimeError`, `RqlCompileError` and `RqlClientError` additionally inherit from the new `RqlQueryError` type ## New features - Overall - Reached a production-ready state (#1174) - ReQL - Added support for changefeeds on `get_all` and `union` queries (#3642) - `between` no longer accepts `null` as a bound. The new `r.minval` and `r.maxval` can be used instead (#1023) - Added support for getting the state of a changefeed using the new `include_states` optarg to `changes` (#3709) - Drivers - Added support for non-blocking `cursor.next` (#3529) - Added support for executing multiple queries in parallel on a single connection (#3754) - Consolidated the return types and use the new `ResponseNotes` field to convey extra information (#3715) - Python driver - Added an optional script that warns for documents with negative zero in a primary key (#3637) - Added an asynchronous API based on Tornado (#2622) - Ruby driver - Added an asynchronous API based on EventMachine (#2622) ## Improvements - Server - Report open cursors as a single entry in the jobs table (#3662) - Timestamps are no longer sent between servers in `batchspec_t` (#2671) - Some expensive changefeed checks are no longer performed in release mode (#3656) - Include the remote port number in the heartbeat timeout message (#2891) - Improved the ordering and throttling of reads and writes (#1606) - Limit the number of documents per write batch to reduce the impact of large writes on other queries (#3806) - Execute multiple queries in parallel on a single connection (#3296) - Improved the performance of sending responses (#3744) - Immediately send back an empty first batch when the result is a changefeed (#3852) - Simplified the `multi_throttling` infrastructure (#4021) - The server now reports handshake errors to client drivers earlier (#4011) - Set `TCP_NODELAY` in the Python and Ruby driver to avoid delays in combination with `noreply` (#3998) - Web UI - Added a configurable limit for the results per page in the Data Explorer (#3910) - Added an "add table" button to each database (#3522) - ReQL - `table.rebalance` with insufficient data is no longer an error (#3679) - Renamed `indexes_of` to `offsets_of` to avoid confusion with secondary indexes (#3265) - Removed `any` and `all` in favor of `or` and `and` (#1581) - Trivial changes are filtered out from `return_changes` (#3697) - Reduced the size of profiles (#3218) - Changefeeds are no longer squashed by default (#3904) - JavaScript driver - Added an upper bound to the bluebird dependency (#3823) - Ruby driver - Added a `timeout` option to `r.connect` (#1666) - Improved the code style (#3900, #3901, #3906) - Strings are now allowed as keys in the config options (#3905) - Build - Upgraded to a more recent version of V8 and dropped support for out-of-tree V8 (#3472) - Added support for building with Python 3 (#3731) - Packaging - Got rid of the outdated bash completion script (#719) - Allow installing RethinkDB in 32-bit OS X on a 64-bit processor (#1595) - Tests - Increased the number of retries in the `RDBBtree` tests to avoid false positives (#3805) ## Bug Fixes - Server - Fixed a race condition that could be caused by concurrent queries (#3766) - Deleted servers and tables are no longer counted during version checks (#3692) - Made JSON parsing more strict (#3810) - Fixed a bug that could cause the server to crash when killed (#3792) - Databases can no longer be renamed to "rethinkdb" (#3858) - Return an initial value for point changefeeds on system tables (#3723) - Improved the handling of negative zero (#3637) - Correctly abort `order_by.limit` changefeeds when a table become unavailable (#3932) - Do not unlink files early to avoid crashing in virtual environments (#3791) - Fallback to TCP4 when binding sockets (#4000) - No longer crash when the data files are in a VirtualBox shared folder (#3791) - ReQL - Fixed the behavior of point changefeeds on system tables (#3944) - `noreplyWait` no longer waits for non-`noreply` queries (#3812) - Initial values for `order_by` changefeeds are now returned in order (#3993) - Reduced the size of profiles when deleting documents (#3218) - Web UI - Fixed a bug that caused the status icon to be green when a table was unavailable (#3500) - Fixed a bug that truncated labels in the performance graph (#3751) - Correctly handle the escape key in modal dialogs (#3872) - Fixed a bug that caused an `InternalError` when loading large tables (#3873) - Fixed a bug that caused the Data Explorer to break when reading older data from `localStorage` (#3935) - Fixed a bug that caused autocompletion to fail in certain cases (#3143) - Python driver - Fixed `rethinkdb export` compatibility between Python 2 and Python 3 (#3911) - Fixed a bug that caused `rethinkdb export` to hang when certain errors occur (#4005) - JavaScript driver - Fixed a bug that caused `cursor.each` to fail with an exception (#3826) - Fixed a bug that caused connection errors to be discarded (#3733) - Fixed a bug that could be triggered by calling `close` twice (#4017) - Fixed a bug in `feed.close` (#3967) - Ruby driver - Fixed a bug that caused failures when using JRuby (#3795) - Signals are now handled correctly (#4029) - Fixed a bug in the arity check (#3968) - Build - Fetching Browserify during the build process is now more reliable (#4009) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.0. In no particular order: - Andrey Deryabin (@aderyabin) - Krishna Narasimhan (@krishnanm86) - Elian Gidoni (@eliangidoni) - Sherzod Kuchkarov (@tundrax) - Jason Dobry (@jmdobry) - Justin Mealey (@justinmealey) - Jonathan Ong (@jonathanong) - Andrey Deryabin (@aderyabin) - Angelo Ashmore (@angeloashmore) - Bill Barsch (@billbarsch) - Ed Costello (@epc) - Ilya Radchenko (@knownasilya) - Kai Curry (@webmasterkai) - Loring Dodge (@loringdodge) - Mike Marcacci (@mike-marcacci) - Param Aggarwal (@paramaggarwal) - Tinco Andringa (@tinco) - Armen Filipetyan (@armenfilipetyan) - Andrei Horak (@linkyndy) - Shirow Miura (@sharow)

rethinkdb v2.0.1

2015-04-21T02:06:04+00:00

Bug fix update - Fixed a regression in the backup scripts that detected the server version incorrectly (#3706) - Fixed a bug in the cache balancer that could degrade performance (#4066)

rethinkdb v2.0.2

2015-05-21T20:50:18+00:00

Bug fix release - Fixed "duplicate token" error in the web UI that happened with certain browsers (#4174) - Fixed a cross site request forgery vulnerability in the HTTP admin interface (#2018) - Fixed the EventEmitter interface in the JavaScript driver (#4192) - Fixed a problem with the RDBInterrupt.InsertOp unit test in some compilation modes (#4038) - Added packages for Ubuntu 15.04 (#4123) - Added a `return_changes: 'always'` option to restore the `return_changes` behavior from before 2.0.0 (#4068) - Fixed a bug with `return_changes` where it would populate `changes` despite an error occurring (#4208) - Fixed a performance regression when calling `get_all` with many keys (#4218) - Added support for using `r.row` with the `contains` command in the JavaScript driver (#4125)

rethinkdb v2.0.3

2015-06-11T16:52:26+00:00

Bug fix release - Fixed a bug that broke autocompletion in the Data Explorer (#4261) - No longer crash for certain types of stack overflows during query execution (#2639) - No longer crash when returning a function from `r.js` (#4190) - Fixed a race condition when closing cursors in the JavaScript driver (#4240) - Fixed a race condition when closing connections in the JavaScript driver (#4250) - Added support for building with GCC 5.1 (#4264) - Improved handling of coroutine stack overflows on OS X (#4299) - Removed an invalid assertion in the server (#4313)

rethinkdb v2.0.4

2015-07-08T02:40:05+00:00

Bug fix release - Fixed the version number used by the JavaScript driver (#4436) - Fixed a bug that caused crashes with a "Guarantee failed: [stop]" error (#4430) - Fixed a latency issue when processing indexed `distinct` queries over low-cardinality data sets (#4362) - Changed the implementation of compile time assertions (#4346) - Changed the Data Explorer to render empty results more clearly (#4110) - Fixed a linking issue on ARM (#4064) - Improved the message showing the query execution time in the Data Explorer (#3454, #3927) - Fixed an error that happened when calling `info` on an ordered table stream (#4242) - Fixed a bug that caused an error to be thrown for certain streams in the Data Explorer (#4242) - Increased the coroutine stack safety buffer to detect stack overflows in optarg processing (#4473)

rethinkdb v2.1.0-0BETA1

2015-07-16T16:54:06+00:00

This is a beta release for RethinkDB 2.1. **It is not for production use and has known bugs.** Please do not use this version for production data. We are looking forward to your bug reports on [GitHub](http://github.com/rethinkdb/rethinkdb/issues/) or on our [mailing list](https://groups.google.com/forum/#!forum/rethinkdb). Release highlights: - Automatic failover using a Raft-based protocol - More flexible administration for servers and tables - Advanced recovery features Read the [blog post](http://rethinkdb.com/blog/rethinkdb-2.1-beta/) for more details. ## Download **Update 07/27/2015:** The server downloads have been updated to include additional bug fixes and improvements. ### 1. Download the server - **Source** [tarball](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb-2.1.0-0BETA2.tgz) - **OS X** [64 bit dmg](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb-2.1.0-0BETA2.dmg) - **CentOS 6 and 7** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb-2.1.0_0BETA2.x86_64.rpm) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb-2.1.0_0BETA2.i686.rpm) - **Ubuntu 10.04 lucid** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0lucid_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0lucid_i386.deb) - **Ubuntu 12.04 precise** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0precise_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0precise_i386.deb) - **Ubuntu 13.10 saucy** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0saucy_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0saucy_i386.deb) - **Ubuntu 14.04 trusty** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0trusty_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0trusty_i386.deb) - **Ubuntu 14.10 utopic** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0utopic_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0utopic_i386.deb) - **Ubuntu 15.04 vivid** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0vivid_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0vivid_i386.deb) - **Debian wheezy** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0wheezy_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0wheezy_i386.deb) - **Debian jessie** [64 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0jessie_amd64.deb) | [32 bit](http://download.rethinkdb.com/dev/2.1.0-0BETA2/rethinkdb_2.1.0%2b0BETA2~0jessie_i386.deb) ### 2. Download a driver #### JavaScript ``` $ npm install http://download.rethinkdb.com/dev/2.1.0-0BETA1/rethinkdb-2.1.0-BETA1.nodejs.tgz ``` #### Python ``` $ pip install http://download.rethinkdb.com/dev/2.1.0-0BETA1/rethinkdb-2.1.0beta1.python.tar.gz ``` #### Ruby ``` $ wget http://download.rethinkdb.com/dev/2.1.0-0BETA1/rethinkdb-2.1.0.beta.1.gem $ gem install rethinkdb-2.1.0.beta.1.gem ``` ## Compatibility This beta release does not include automatic migration of data directories from older versions of RethinkDB. The final release of RethinkDB 2.1 will automatically migrate data from RethinkDB 1.14 and up. If you're upgrading directly from RethinkDB 1.13 or earlier, you will need to manually upgrade using `rethinkdb dump`. ### Changed handling of server failures This release introduces a new system for dealing with server failures and network partitions based on the Raft consensus algorithm. Previously, unreachable servers had to be manually removed from the cluster in order to restore availability. RethinkDB 2.1 can resolve many cases of availability loss automatically, and keeps the cluster in an administrable state even while servers are missing. There are three important scenarios in RethinkDB 2.1 when it comes to restoring the availability of a given table after a server failure: - The table has three or more replicas, and a majority of the servers that are hosting these replicas are connected. RethinkDB 2.1 automatically elects new primary replicas to replace unavailable servers and restore availability. No manual intervention is required, and data consistency is maintained. - A majority of the servers for the table are connected, regardless of the number of replicas. The table can be manually reconfigured using the usual commands, and data consistency is always maintained. - A majority of servers for the table are unavailable. The new `emergency_repair` option to `table.reconfigure` can be used to restore table availability in this case. ### System table changes To reflect changes in the underlying cluster administration logic, some of the tables in the `rethinkdb` database changed. **Changes to `table_config`:** - Each shard subdocument now has a new field `nonvoting_replicas`, that can be set to a subset of the servers in the `replicas` field. - `write_acks` must now be either `"single"` or `"majority"`. Custom write ack specifications are no longer supported. Instead, non-voting replicas can be used to set up replicas that do not count towards the write ack requirements. - Tables that have all of their replicas disconnected are now listed as special documents with an `"error"` field. - Servers that are disconnected from the cluster are no longer included in the table. **Changes to `table_status`:** - The `primary_replica` field is now called `primary_replicas` and has an array of current primary replicas as its value. While under normal circumstances only a single server will be serving as the primary replica for a given shard, there can temporarily be multiple primary replicas during handover or while data is being transferred between servers. - The possible values of the `state` field now are `"ready"`, `"transitioning"`, `"backfilling"`, `"disconnected"`, `"waiting_for_primary"` and `"waiting_for_quorum"`. - Servers that are disconnected from the cluster are no longer included in the table. **Changes to `current_issues`:** - The issue types `"table_needs_primary"`, `"data_lost"`, `"write_acks"`, `"server_ghost"` and `"server_disconnected"` can no longer occur. - A new issue type `"table_availability"` was added and appears whenever a table is missing at least one server. Note that no issue is generated if a server which is not hosting any replicas disconnects. ### Other API-breaking changes - `.split('')` now treats the input as UTF-8 instead of an array of bytes - `null` values in compound index are no longer discarded - The new `read_mode="outdated"` optional argument replaces `use_outdated=True` ## New features - Server - Added automatic failover and semi-lossless rebalance based on Raft (#223) - Backfills are now interuptible and reversible (#3886, #3885) - `table.reconfigure` now works even if some servers are disconnected (#3913) - Replicas can now be marked as voting or non-voting (#3891) - Added an emergency repair feature to restore table availability if consensus is lost (#3893) - Reads can now be made against a majority of replicas (#3895) - Added an emergency read mode that extracts data directly from a given replica for data recovery purposes (#4388) - Servers with no responsibilities can now be removed from clusters without raising an issue (#1790) - ReQL - Added `ceil`, `floor` and `round` (#866) - All drivers - Added driver-side support for SSL connections and CA verification (#4075, #4076, #4080) - Python driver - Added asyncio support (#4071) - `rethinkdb export` now supports the `--delimiter` option for CSV files (#3916) ## Improvements - Server - Improved the handling of cluster membership and removal of servers (#3262, #3897, #1790) - Changed the formatting of the `table_status` system table (#3882, #4196) - Added an `indexes` field to the `table_config` system table (#4525) - Improved efficiency by making `datum_t` movable (#4056) - ReQL backtraces are now faster and smaller (#2900) - Replaced cJSON with rapidjson (#3844) - Failed meta operations are now transparently retried (#4199) - Added more detailed logging of cluster events (#3878) - Improved unsaved data limit throttling (#4441) - ReQL - `.split('')` is now UTF-8 aware (#2518) - Improved the behaviour of compound index values containing `null` (#4146) - Errors now distinguish failed writes from indeterminate writes (#4296) - `r.union` is now a top-level term (#4030) - `condition.branch(...)` now works just like `r.branch(condition, ...)` (#4438) - Web UI - Added new dependency and namespace management system to the web UI (#3465, #3660) - Improved the information visible on the dashboard (#4461) - Improved layout of server and replica assignment lists (#4372) - Updated to reflect the new clustering features and changes (#4283, #4330, #4288, ...) - JavaScript driver - The version of bluebird was updated to 2.9.32 (#4178, #4475) - Python driver - Added an `r.__version__` property (#3100) ## Bug fixes - `time_of_date` and `date` now respect timezones (#4149) - Added code to work around a bug in some versions of GLIBC and EGLIBC (#4470) - Python driver - Fixed a missing argument error (#4402) - JavaScript driver - Made the handling of the `db` optional argument to `run` consistent with the Ruby and Python drivers (#4347) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.1. In no particular order: - Thomas Kluyver (@takluyver) - Jonathan Phillips (@jipperinbham) - Yohan Graterol (@yograterol) - Adam Grandquist (@grandquista) - Peter Hamilton (@hamiltop) - Marshall Cottrell (@marshall007) - Elias Levy (@eliaslevy) - Ian Beringer (@ianberinger) - Jason Dobry (@jmdobry) - Wankai Zhang (@wankai) - Elifarley Cruz (@elifarley) - Brandon Mills (@btmills) - Daniel Compton (@danielcompton) - Ed Costello (@epc) - Lowe Thiderman (@thiderman) - Andy Wilson (@wilsaj)

rethinkdb v2.1.0-1

2015-08-11T11:11:51+00:00

Release highlights: - Automatic failover using a Raft-based protocol - More flexible administration for servers and tables - Advanced recovery features Read the [blog post](http://rethinkdb.com/blog/2.1-release/) for more details. ## Compatibility Data files from RethinkDB versions 1.14.0 onward will be automatically migrated. As with any major release, back up your data files before performing the upgrade. If you're upgrading directly from RethinkDB 1.13 or earlier, you will need to manually upgrade using `rethinkdb dump`. Note that files from the RethinkDB 2.1.0 beta release are not compatible with this version. ### Changed handling of server failures This release introduces a new system for dealing with server failures and network partitions based on the Raft consensus algorithm. Previously, unreachable servers had to be manually removed from the cluster in order to restore availability. RethinkDB 2.1 can resolve many cases of availability loss automatically, and keeps the cluster in an administrable state even while servers are missing. There are three important scenarios in RethinkDB 2.1 when it comes to restoring the availability of a given table after a server failure: - The table has three or more replicas, and a majority of the servers that are hosting these replicas are connected. RethinkDB 2.1 automatically elects new primary replicas to replace unavailable servers and restore availability. No manual intervention is required, and data consistency is maintained. - A majority of the servers for the table are connected, regardless of the number of replicas. The table can be manually reconfigured using the usual commands, and data consistency is always maintained. - A majority of servers for the table are unavailable. The new `emergency_repair` option to `table.reconfigure` can be used to restore table availability in this case. ### System table changes To reflect changes in the underlying cluster administration logic, some of the tables in the `rethinkdb` database changed. **Changes to `table_config`:** - Each shard subdocument now has a new field `nonvoting_replicas`, that can be set to a subset of the servers in the `replicas` field. - `write_acks` must now be either `"single"` or `"majority"`. Custom write ack specifications are no longer supported. Instead, non-voting replicas can be used to set up replicas that do not count towards the write ack requirements. - Tables that have all of their replicas disconnected are now listed as special documents with an `"error"` field. - Servers that are disconnected from the cluster are no longer included in the table. - The new `indexes` field lists the secondary indexes on the given table. **Changes to `table_status`:** - The `primary_replica` field is now called `primary_replicas` and has an array of current primary replicas as its value. While under normal circumstances only a single server will be serving as the primary replica for a given shard, there can temporarily be multiple primary replicas during handover or while data is being transferred between servers. - The possible values of the `state` field now are `"ready"`, `"transitioning"`, `"backfilling"`, `"disconnected"`, `"waiting_for_primary"` and `"waiting_for_quorum"`. - Servers that are disconnected from the cluster are no longer included in the table. **Changes to `current_issues`:** - The issue types `"table_needs_primary"`, `"data_lost"`, `"write_acks"`, `"server_ghost"` and `"server_disconnected"` can no longer occur. - A new issue type `"table_availability"` was added and appears whenever a table is missing at least one server. Note that no issue is generated if a server which is not hosting any replicas disconnects. **Changes to `cluster_config`:** - A new document with the `id` `"heartbeat"` allows configuring the heartbeat timeout for intracluster connections. ### New ReQL error types RethinkDB 2.1 introduces new error types that allow you to handle different error classes separately in your application if you need to. You can find the [complete list](http://rethinkdb.com/docs/error-types/) of new error types in the documentation. As part of this change, ReQL error types now use the `Reql` name prefix instead of `Rql` (for example `ReqlRuntimeError` instead of `RqlRuntimeError`). The old type names are still supported in our drivers for backwards compatibility. ### Other API-breaking changes - `.split('')` now treats the input as UTF-8 instead of an array of bytes - `null` values in compound index are no longer discarded - The new `read_mode="outdated"` optional argument replaces `use_outdated=True` ### Deprecated functionality The older protocol-buffer-based client protocol is deprecated in this release. RethinkDB 2.2 will no longer support clients that still use it. All "current" drivers listed on the [drivers page](http://rethinkdb.com/docs/install-drivers/) use the new JSON-based protocol and will continue to work with RethinkDB 2.2. ## New features - Server - Added automatic failover and semi-lossless rebalance based on Raft (#223) - Backfills are now interuptible and reversible (#3886, #3885) - `table.reconfigure` now works even if some servers are disconnected (#3913) - Replicas can now be marked as voting or non-voting (#3891) - Added an emergency repair feature to restore table availability if consensus is lost (#3893) - Reads can now be made against a majority of replicas (#3895) - Added an emergency read mode that extracts data directly from a given replica for data recovery purposes (#4388) - Servers with no responsibilities can now be removed from clusters without raising an issue (#1790) - Made the intracluster heartbeat timeout configurable (#4449) - ReQL - Added `ceil`, `floor` and `round` (#866) - Extended the ReQL error type hierarchy to be more fine-grained (#4544) - All drivers - Added driver-side support for SSL connections and CA verification (#4075, #4076, #4080) - Python driver - Added Python 3 asyncio support (#4071) - Added Twisted support (#4096) - `rethinkdb export` now supports the `--delimiter` option for CSV files (#3916) ## Improvements - Server - Improved the handling of cluster membership and removal of servers (#3262, #3897, #1790) - Changed the formatting of the `table_status` system table (#3882, #4196) - Added an `indexes` field to the `table_config` system table (#4525) - Improved efficiency by making `datum_t` movable (#4056) - ReQL backtraces are now faster and smaller (#2900) - Replaced cJSON with rapidjson (#3844) - Failed meta operations are now transparently retried (#4199) - Added more detailed logging of cluster events (#3878) - Improved unsaved data limit throttling to increase write performance (#4441) - Improved the performance of the `is_empty` term (#4592) - Small backfills are now prioritized to make tables available more quickly after a server restart (#4383) - Reduced the memory requirements when backfilling large documents (#4474) - Changefeeds using the `squash` option now send batches early if the changefeed queue gets too full (#3942) - ReQL - `.split('')` is now UTF-8 aware (#2518) - Improved the behaviour of compound index values containing `null` (#4146) - Errors now distinguish failed writes from indeterminate writes (#4296) - `r.union` is now a top-level term (#4030) - `condition.branch(...)` now works just like `r.branch(condition, ...)` (#4438) - Improved the detection of non-atomic `update` and `replace` arguments (#4582) - Web UI - Added new dependency and namespace management system to the web UI (#3465, #3660) - Improved the information visible on the dashboard (#4461) - Improved layout of server and replica assignment lists (#4372) - Updated to reflect the new clustering features and changes (#4283, #4330, #4288, ...) - JavaScript driver - The version of bluebird was updated to 2.9.32 (#4178, #4475) - Improved compatibility with Internet Explorer 10 (#4534) - TCP keepalive is now enabled for all connections (#4572) - Python driver - Added a new `--max-document-size` option to the `rethinkdb import` script to handle very large JSON documents (#4452) - Added an `r.__version__` property (#3100) - TCP keepalive is now enabled for all connections (#4572) - Ruby driver - TCP keepalive is now enabled for all connections (#4572) ## Bug fixes - `time_of_date` and `date` now respect timezones (#4149) - Added code to work around a bug in some versions of GLIBC and EGLIBC (#4470) - Updated the OS X uninstall script to avoid spurious error messages (#3773) - Fixed a starvation issue with squashing changefeeds (#3903) - `has_fields` now returns a selection when called on a table (#2609) - Fixed a bug that caused intermittent server crashes with the message `Guarantee failed: [fn_id != __null]` in combination with the `r.js` command (#4611) - Web UI - Fixed an issue in the table list that caused it to get stuck showing "Loading tables..." if no database existed (#4464) - Fixed the tick marks in the shard distribution graph (#4294) - Python driver - Fixed a missing argument error (#4402) - JavaScript driver - Made the handling of the `db` optional argument to `run` consistent with the Ruby and Python drivers (#4347) - Fixed a problem that could cause connections to not be closed correctly (#4526) - Ruby driver - Made the EventMachine API raise an error when a connection is closed while handlers are active (#4626) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.1. In no particular order: - Thomas Kluyver (@takluyver) - Jonathan Phillips (@jipperinbham) - Yohan Graterol (@yograterol) - Adam Grandquist (@grandquista) - Peter Hamilton (@hamiltop) - Marshall Cottrell (@marshall007) - Elias Levy (@eliaslevy) - Ian Beringer (@ianberinger) - Jason Dobry (@jmdobry) - Wankai Zhang (@wankai) - Elifarley Cruz (@elifarley) - Brandon Mills (@btmills) - Daniel Compton (@danielcompton) - Ed Costello (@epc) - Lowe Thiderman (@thiderman) - Andy Wilson (@wilsaj) - Nicolas Viennot (@nviennot) - bnosrat (@bnosrat) - Mike Mintz (@mikemintz) - Lahfa Ryan (@raitobezarius) - Sebastien Diaz (@sebadiaz)

rethinkdb v2.1.1

2015-08-12T18:10:31+00:00

Bug fix release - Fixed a problem where after migration, some replicas remained unavailable when reconfiguring a table (#4668) - Removed the defunct `--migrate-inconsistent-data` command line argument (#4665) - Fixed the slider for setting write durability during table creation in the web UI (#4660) - Fixed a race condition in the clustering subsystem (#4670) - Improved the handling of error messages in the testing system (#4657)

rethinkdb v2.1.2

2015-08-26T04:59:06+00:00

Bug fix release ### Compatibility - RethinkDB 2.1.2 servers cannot be mixed with servers running earlier versions in the same cluster - Changefeeds on a `get_all` query no longer return initial values. This restores the behavior from RethinkDB 2.0 ### Bug fixes - Fixed an issue where writes could be acknowledged before all necessary data was written to disk - Restored the 2.0 behavior for changefeeds on `get_all` queries to avoid various issues and incompatibilities - Fixed an issue that caused previously migrated tables to be shown as unavailable (#4723) - Made outdated secondary index warnings disappear once the problem is resolved (#4664) - Made `index_create` atomic to avoid race conditions when multiple indexes were created in quick succession (#4694) - Improved how query execution times are reported in the Data Explorer (#4752) - Fixed a memory leak in `r.js` (#4663) - Fixed the `Branch history is missing pieces` error (#4721) - Fixed a race condition causing a crash with `Guarantee failed: [!send_mutex.is_locked()]` (#4710) - Fixed a bug in the changefeed code that could cause crashes with the message `Guarantee failed: [active()]` (#4678) - Fixed various race conditions that could cause crashes if changefeeds were present during resharding (#4735, #4734, #4678) - Fixed a race condition causing a crash with `Guarantee failed: [val.has()]` (#4736) - Fixed an `Assertion failed` issue when running a debug-mode binary (#4685) - Added a workaround for an `eglibc` bug that caused an `unexpected address family` error on startup (#4470) - Added precautions to avoid secondary index migration issues in subsequent releases - Out-of-memory errors in the server's JSON parser are now correctly reported (#4751)

rethinkdb v2.0.5

2015-09-01T00:04:44+00:00

**Deprecated version:** This release is a bug fix release for the deprecated 2.0.x version branch. For new installations, we recommend using the latest version of RethinkDB (currently 2.1.2). Bug fix release - Added precautions to avoid secondary index migration issues in subsequent releases - Fixed a memory leak in `r.js` (#4663) - Added a workaround for an `eglibc` bug that caused an `unexpected address family` error on startup (#4470) - Fixed a bug in the changefeed code that could cause crashes with the message `Guarantee failed: [active()]` (#4678) - Fixed a bug that caused intermittent server crashes with the message `Guarantee failed: [fn_id != __null]` in combination with the `r.js` command (#4611) - Improved the performance of the `is_empty` term (#4592)

rethinkdb v2.1.3

2015-09-05T02:27:59+00:00

Bug fix release ### Compatibility - RethinkDB 2.1.3 servers cannot be mixed with servers running RethinkDB 2.1.1 or earlier in the same cluster ### Bug fixes - Fixed a data corruption bug in the b-tree implementation (#4769) - Fixed the `ssl` option in the JavaScript driver (#4786) - Made the Ruby driver compatible with Ruby on Rails 3.2 (#4753) - Added the `backports.ssl_match_hostname` library to the Python driver package (#4683) - Changed the update check to use an encrypted https connection (#3988, #4643) - Fixed access to `https` sources in `r.http` on OS X (#3112) - Fixed an `Unexpected exception` error (#4758) - Fixed a `Guarantee failed: [pair.second]` crash that could occur during resharding (#4774) - Fixed a bug that caused some queries to not report an error when interrupted (#4762) - Added a new `"_debug_recommit"` recovery option to `emergency_repair` (#4720) - Made error reporting in the Python driver compatible with `celery` and `nose` (#4764) - Changed the handling of outdated indexes from RethinkDB 1.13 during an import to no longer terminate the server (#4766) ### Performance improvements - Improved the latency when reading from a system table in `r.db('rethinkdb')` while the server is under load (#4773) - Improved the parallelism of JSON encoding on the server to utilize multiple CPU cores - Refactored JSON decoding in the Python driver to allow the use of custom JSON parsers and to speed up pseudo type conversion (#4585) - Improved the prefetching logic in the Python driver to increase the throughput of cursors - Changed the Python driver to use a more efficient data structure to store cursor results (#4782) ### Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.1.3. In no particular order: - Adam Grandquist (@grandquista) - ajose01 (@ajose01) - Paulius Uza (@pauliusuza)

rethinkdb v2.1.4

2015-09-16T07:24:00+00:00

Bug fix release ### Compatibility - RethinkDB 2.1.4 servers cannot be mixed with servers running RethinkDB 2.1.1 or earlier in the same cluster ### Bug fixes - Fixed a data corruption bug that could occur when deleting documents (#4769) - The web UI no longer ignores errors during table configuration (#4811) - Added a check in case `reconfigure` is called with a non-existent server tag (#4840) - Removed a spurious debug-mode assertion that caused a server crash when trying to write to the `stats` system table (#4837) - The `rethinkdb restore` and `rethinkdb import` commands now wait for secondary indexes to become ready before beginning the data import (#4832)

rethinkdb v2.1.5-2

2015-10-07T06:18:08+00:00

Bug fix release _Note:_ If you are building RethinkDB from source and you have built older versions of RethinkDB before, you might need to run `make clean` before building RethinkDB 2.1.5. ### Compatibility - RethinkDB 2.1.5 servers cannot be mixed with servers running RethinkDB 2.1.4 or earlier in the same cluster ### Bug fixes - Fixed a memory corruption bug that caused segmentation faults on some systems (#4917) - Made the build system compatible with OS X El Capitan (#4602) - Fixed spurious "Query terminated by `rethinkdb.jobs` table" errors (#4819) - Fixed an issue that caused changefeeds to keep failing after a table finished reconfiguring (#4838) - Fixed a race condition that resulted in a crash with the message `std::terminate() called without any exception.` when losing a cluster connection (#4878) - Fixed a segmentation fault in the `mark_ready()` function that could occur when reconfiguring a table (#4875) - Fixed a segmentation fault when using changefeeds on `orderBy.limit` queries (#4850) - Made the Data Explorer handle changefeeds on `orderBy.limit` queries correctly (#4852) - Fixed a "Branch history is incomplete" crash when reconfiguring a table repeatedly in quick succession (#4866) - Fixed a problem that caused `indexStatus` to report results for additional indexes that were not specified in its arguments (#4868) - Fixed a segmentation fault when running RethinkDB on certain ARM systems (#4839) - Fixed a compilation issue in the UTF-8 unit test with recent versions of Xcode (#4861) - Fixed an `Assertion failed: [ptr_]` error when reconfiguring tables quickly with a debug-mode binary (#4871) - Improved the detection of unsupported values in `r.js` functions to avoid a `Guarantee failed: [!key.IsEmpty() && !val.IsEmpty()]` crash in the worker process (#4879) - Fixed an unitialized data access issue on shutdown (#4918) ### Performance improvements - Improved the performance of `getAll` queries that fetch multiple keys at once (#1526) - Optimized the distribution of tasks across threads on multi-core servers (#4905)

rethinkdb v2.2.0

2015-11-12T15:26:33+00:00

RethinkDB 2.2 introduces atomic changefeeds. Atomic changefeeds include existing values from the database into the changefeed result, and then atomically transition to streaming updates. Atomic changefeeds make building realtime apps dramatically easier: you can use a single code path to populate your application with initial data, and continue receiving realtime data updates. This release also includes numerous performance and scalability improvements designed to help RethinkDB clusters scale to larger sizes while using fewer resources. Read the [blog post](http://rethinkdb.com/blog/2.2-release/) for more details. ## Compatibility Data files from RethinkDB version 1.16 onward will be automatically migrated. As with any major release, back up your data files before performing the upgrade. If you're upgrading from RethinkDB 1.14.x or 1.15.x, you need to migrate your secondary indexes first. You can do this by following these steps: - Install RethinkDB 2.0.5. - Update the RethinkDB Python driver (`sudo pip install 'rethinkdb<2.1.0'`). - Rebuild your indexes with `rethinkdb index-rebuild`. Afterwards, you can install RethinkDB 2.2 and start it on the existing data files. If you're upgrading directly from RethinkDB 1.13 or earlier, you will need to manually upgrade using `rethinkdb dump`. ### API-breaking changes - Changefeeds on `.orderBy.limit` as well as `.get` queries previously provided initial results by default. You now need to include the optional argument `includeInitial: true` to `.changes` to achieve the same behavior. - The deprecated protocol buffer driver protocol is no longer supported. The newer JSON protocol is now the only supported driver protocol. Older drivers using the deprecated protocol no longer work with RethinkDB 2.2.0. See the [drivers](http://rethinkdb.com/docs/install-drivers/) list for up-to-date drivers. - If you're using Java, please note that at the time of writing, existing community drivers have not been updated to use the newer JSON protocol. However, an [official Java driver](https://github.com/rethinkdb/rethinkdb/issues/3930) is in active development and will be available soon. - Certain argument errors that used to throw `ReqlDriverError` exceptions now throw `ReqlCompileError` exceptions. See [#4669](https://github.com/rethinkdb/rethinkdb/issues/4669#issue-100428248) for a full list of changes. ### Supported distributions RethinkDB 2.2.0 now comes with official packages for Ubuntu 15.10 (Wily Werewolf) and CentOS 7. We no longer provide packages for Ubuntu 10.04 (Lucid Lynx), which has reached end of life. ## New features - Added full support for atomic changefeeds through the `include_initial` optarg (#3579) - Added a `values` command to obtain the values of an object as an array (#2945) - Added a `conn.server` command to identify the server for a given connection (#3934) - Extended `r.uuid` to accept a string and work as a hash function (#4636) ## Improvements - Server - Improved the scalability of range queries on sharded tables (#4343) - Improved the performance of `between` queries on secondary indexes (#4862) - Reduced the memory overhead for large data sets (#1951) - Redesigned the internal representation of queries to improve efficiency (#4601) - Removed the deprecated protocol buffer driver protocol (#4601) - Improved the construction of secondary indexes to make them resumable and to reduce their impact on any production workload (#4959) - Improved the performance when using `getAll` with a secondary index in some edge cases (#4948) - Removed the limit of 1024 concurrent changefeeds on a single connection (#4732) - Implemented automatically growing coroutine stacks to avoid stack overflows (#4462) - Optimized the deserialization of network messages to avoid an extra copy (#3734) - Added a `raft_leader` field to a table's status to expose its current Raft leader (#4902) - Made the handling of invalid lines in the `'logs'` system table more robust (#4929) - ReQL - `indexStatus` now exposes the secondary index function (#3231) - Added an optarg called `changefeed_queue_size` to specify how many changes the server should buffer on a changefeed before generating an error (#3607) - Extended `branch` to accept an arbitrary number of conditions and values (#3199) - Strings can now contain null characters (except in primary keys) (#3163) - Streams can now be coerced directly to an object (#2802) - Made `coerceTo('BOOL')` consistent with `branch` (#3133) - Changefeeds on `filter` and `map` queries involving geospatial terms are now allowed (#4063) - Extended `or` and `and` to accept zero arguments (#4132) - Web UI - The Data Explorer now allows executing only parts of a query be selecting them (#4814) - All drivers - Improved the consistency of ReQL error types by throwing `ReqlCompileError` rather than `ReqlDriverError` for certain errors (#4669) - JavaScript driver - Added an `eachAsync` method on cursors that behaves like `each` but also returns a promise (#4784) - Python driver - Implemented an API to override the default JSON encoder and decoder (#4825, #4818) ## Bug fixes - Server - Fixed a segmentation fault that could happen when disconnecting a server while having open changefeeds (#4972) - Updated the description of the `--server-name` parameter in `rethinkdb --help` (#4739) - Fixed a crash with the message "Guarantee failed: [ts->tv_nsec >= 0 && ts->tv_nsec < (1000LL \* (1000LL \* 1000LL))] " (#4931) - Fixed a problem where backfill jobs didn't get removed from the `'jobs'` table (#4923) - Fixed a memory corruption that could trigger a segmentation fault during `getIntersecting` queries (#4937) - Fixed an issue that could stop data files from RethinkDB 1.13 from migrating properly (#4991) - Fixed a "Guarantee failed: [pair.second] key for entry_t already exists" crash when rapidly reconnecting servers (#4968) - Fixed an "Uncaught exception of type interrupted_exc_t" crash (#4977) - Added a check to catch `r.minval` and `r.maxval` values when writing to the `'_debug_scratch'` system table (#4032) - ReQL - Fixed the error message that's generated when passing in a function with the wrong arity (#4189) - Fixed a regression that caused `r.asc("test")` to not fail as it should (#4951) - JavaScript driver - Object keys in `toString` are now properly quoted (#4997) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.2. In no particular order: - Peter Hollows (@captainpete) - Zhenchao Li (@fantasticsid) - Marshall Cottrell (@marshall007) - Adam Grandquist (@grandquista) - Ville Immonen (@fson) - Matt Broadstone (@mbroadst) - Pritam Baral (@pritambaral) - Elian Gidoni (@eliangidoni) - Mike Mintz (@mikemintz) - Daniel Compton (@danielcompton) - Vinh Quốc Nguyễn (@kureikain) - Shayne Hodge (@schodge) - Alexander Zeillinger (@alexanderzeillinger) - Ben Gesoff (@bengesoff) - Dmitriy Lazarev (@wKich) - Chris Gaudreau (@clessg) - Paweł Świątkowski (@katafrakt) - Wang Zuo (@wangzuo) - Chris Goller (@goller) - Mateus Craveiro (@mccraveiro)

rethinkdb v2.2.1

2015-11-17T09:14:41+00:00

Bug fix release ### Compatibility RethinkDB 2.2.1 is fully compatible with RethinkDB 2.2.0. Please read the [RethinkDB 2.2.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.2.0) if you're upgrading from an older version. ### Bug fixes - Fixed a crash with the message "Guarantee failed: [found_hash_pair]" when running `getAll` queries (#5085) - `rethinkdb export` and `rethinkdb dump` now limit the number of subprocesses to reduce memory consumption (#4809) - Fixed a segmentation fault in `orderBy.limit` changefeeds (#5081) - Fixed a crash when using `getAll` with illegal keys (#5086) - `r.uuid` is now considered a deterministic operation if it is passed a single argument (#5092) - Fixed the "Task was destroyed but it is pending!" error when using the `asyncio` event loop on Python (#5043)

rethinkdb v2.2.2

2015-12-21T09:02:59+00:00

Bug fix release ### Compatibility RethinkDB 2.2.2 servers cannot be mixed with servers running RethinkDB 2.2.1 or earlier in the same cluster. The protocol change was necessary to address correctness issues in the changefeed implementation. No migration is required when upgrading from RethinkDB 2.2.0 or higher. Please read the [RethinkDB 2.2.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.2.0) if you're upgrading from an older version. ### Bug fixes - Server - Fixed an issue causing `include_initial` changefeeds to miss changes (#5216) - Fixed an issue causing `include_initial` changefeeds to stall and never reach the `"ready"` state (#5157) - Fixed an issue causing `include_initial` changefeeds to emit unexpected initial results with a `null` value (#5153) - Improved the efficiency of `skip` in combination with `limit` (#5155) - Fixed an issue with determinism checking in geospatial commands (#5130) - Fixed an invalid memory access that caused segmentation faults on ARM (#5093) - Fixed a crash with "Unreachable code" when migrating from versions of RethinkDB older than 1.16 (#5158) - Fixed an issue where the server would send an extra response to the client after a cursor completed (#5159) - Fixed a build dependency issue with OpenSSL on OS X 10.11 (#4963) - Fixed compiler warnings on ARM (#4541) - Made the APT repository compatible with APT 1.1 (#5174) - Drivers - Fixed missing backtraces on `ReQLCompileError` in the JavaScript driver (#4803) - Upgraded the version of CoffeeScript used to compile the JavaScript driver in order to avoid errors in strict mode (#5198) - Fixed a syntax error warning in the Python driver during installation on older Python versions (#4702) - `rethinkdb restore` now waits for tables to be available (#5154)

rethinkdb v2.2.3-1

2016-01-11T20:22:20+00:00

Bug fix release ### Compatibility RethinkDB 2.2.3 servers cannot be mixed with servers running RethinkDB 2.2.1 or earlier in the same cluster. No migration is required when upgrading from RethinkDB 2.2.0 or higher. Please read the [RethinkDB 2.2.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.2.0) if you're upgrading from an older version. ### Bug fixes - Fixed a bug in the changefeed code that caused crashes with the message `Guarantee failed: [env.has()]` (#5238) - Fixed a crash in `r.http` when using pagination (#5256) - Fixed a bug that made `orderBy.limit` changefeeds prevent other changefeeds on the same table from becoming ready (#5247) - Replaced a call to the deprecated `Object#timeout` function in the Ruby driver (#5232)

rethinkdb v2.1.6

2016-02-01T19:14:47+00:00

Legacy bug fix release ### Legacy support release This release maintains full compatibility with RethinkDB 2.1.5, while fixing a [critical bug](https://github.com/rethinkdb/rethinkdb/issues/5289#issuecomment-175394540) in RethinkDB's clustering system. We recommend installing this version only if upgrading to RethinkDB 2.2.4 is not an option, for example if you depend on a driver that still uses the old protocol buffer client protocol. ### Bug fixes - Fixed a bug in the clustering system that could lead to data loss, inconsistent reads, and server crashes after reconfiguring a table during incomplete connectivity (#5289, #4949)

rethinkdb v2.2.4

2016-02-01T19:17:04+00:00

This bug fix release addresses a [critical bug](https://github.com/rethinkdb/rethinkdb/issues/5289#issuecomment-175394540) in RethinkDB's clustering system, that can lead to data loss and invalid query results under certain rare circumstances. The bug can appear if a table is reconfigured during a network partition (read more in [GitHub issue #5289](https://github.com/rethinkdb/rethinkdb/issues/5289#issuecomment-175394540)). We recommend upgrading to this release as soon as possible to avoid data loss. If you see replicas get stuck in the `transitioning` state during a reconfiguration after upgrading, you can run `.reconfigure({emergencyRepair: '_debug_recommit'})` on the table to allow the reconfiguration to complete. Please make sure that the cluster is idle when running this operation, as RethinkDB does not guarantee consistency during the emergency repair. ### Compatibility RethinkDB 2.2.4 servers cannot be mixed with servers running RethinkDB 2.2.1 or earlier in the same cluster. No migration is required when upgrading from RethinkDB 2.2.0 or higher. Please read the [RethinkDB 2.2.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.2.0) if you're upgrading from an older version. ### Bug fixes - Fixed a bug in the clustering system that could lead to data loss, inconsistent reads, and server crashes after reconfiguring a table during incomplete connectivity (#5289, #4949) - Fixed a segmentation fault that occurred when requesting certain documents from the `stats` system table (#5327) - Changefeeds on system tables now support `map`, `filter` and related commands (#5241) - Backtraces are now printed even if the `addr2line` tool is not installed (#5321) - The Java driver now supports SSL connections thanks to a contribution by @pires (#5284) - Fixed the "Serialized query" debug output in the Java driver (#5306) - Fixed an incompatibility of the `rethinkdb import` script with Python 2.6 (#5294)

rethinkdb v2.2.5

2016-02-24T23:33:36+00:00

Bug fix release ### Compatibility RethinkDB 2.2.5 servers cannot be mixed with servers running RethinkDB 2.2.1 or earlier in the same cluster. No migration is required when upgrading from RethinkDB 2.2.0 or higher. Please read the [RethinkDB 2.2.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.2.0) if you're upgrading from an older version. ### Improvements - Improved the CPU efficiency of `orderBy` queries on secondary indexes (#5280) - Improved the efficiency of geospatial queries on indexes with point values (#5411) - Connections in the Java driver are now thread-safe (#5166) - Made the JavaScript driver compatible with Internet Explorer 10 (#5067) - The Ruby driver now supports nested pseudotypes (#5373) ### Bug fixes - Fixed an issue that caused servers to not connect and/or reconnect properly (#2755) - Fixed an issue that caused servers to time out when running queries on secondary indexes with long index keys (#5280) - Changefeeds now always emit events for documents leaving or entering the changefeed range (#5205) - Fixed a bug in the Java driver that caused null pointer exceptions (#5355) - Fixed the `isFeed()` function in the Java driver (#5390, #5400) - The `r.now` command now performs arity checking correctly (#5405) - Fixed a test failure in the `unit.ClusteringBranch` test (#5182) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.2.5. In no particular order: - Mike Mintz (@mikemintz) - Paulo Pires (@pires) - Nicolas Viennot (@nviennot) - Brian Chavez (@bchavez)

rethinkdb v2.2.6

2016-03-28T18:08:01+00:00

Bug fix release ### Compatibility **Warning**: Due to a bug ([#5570](https://github.com/rethinkdb/rethinkdb/issues/5570)), RethinkDB 2.2.6 fails to migrate data directories from RethinkDB 2.0.x or earlier. Please use RethinkDB 2.2.5 for migrating your data, and then upgrade to RethinkDB 2.2.5 in a second step. ## RethinkDB 2.2.6 servers cannot be mixed with servers running RethinkDB 2.2.1 or earlier in the same cluster. No migration is required when upgrading from RethinkDB 2.2.0 or higher. Please read the [RethinkDB 2.2.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.2.0) if you're upgrading from an older version. ### Bug fixes - Fixed two bugs in the changefeed code that caused crashes with an "Unreachable code" error in certain edge cases (#5438, #5535) - Fixed a `SANITY CHECK FAILED: [d.has()]` error when using the `map` command on a combination of empty and non-empty input streams (#5481) - The result of `conn.server()` now includes a `proxy` field (#5485) - Changed the connection behavior of proxy servers to avoid repeating "Rejected a connection from server X since one is open already" warnings (#5456) - The Python driver now supports connecting to a server via IPv6, even when using the async API (asyncio, tornado, twisted) (#5445) - Fixed an incompatibility with certain versions of Python that made the driver unable to load the `backports.ssl_match_hostname` module (#5470) - Fixed a resource leak in the Java driver's `cursor.close()` call (#5448) - Cursors in the Java driver now implement the `Closeable` interface (#5468) - Fixed a remaining incompatibility with Internet Explorer 10 in the JavaScript driver (#5499) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.2.6. In no particular order: - Paulo Pires (@pires) - Mike Mintz (@mikemintz)

rethinkdb v2.3.0

2016-04-06T15:57:30+00:00

RethinkDB 2.3 introduces a users and permissions system, TLS encrypted connections, a Windows beta, and numerous improvements to the ReQL query language. ReQL improvements include up to 10x better performance for distributed joins, and a new `fold` command that allows you to implement efficient stateful transformations on streams. Read the [blog post](http://rethinkdb.com/blog/2.3-release/) for more details. ## Compatibility Data files from RethinkDB version 1.16 onward will be automatically migrated. As with any major release, back up your data files before performing the upgrade. If you're upgrading from RethinkDB 1.15.x or earlier, please read the [data migration guide](http://www.rethinkdb.com/docs/migration/) to find out about the required migration steps. RethinkDB 2.3.0 servers cannot be mixed with servers running RethinkDB 2.2.x or earlier in the same cluster. ### Managing password-protected clusters If you migrate a cluster from a previous version of RethinkDB and have an `auth_key` set, the `auth_key` is turned into the password for the `"admin"` user. If no `auth_key` is set, a new `"admin"` user with an empty password is automatically created during migration. RethinkDB 2.3 adds a new restriction when adding a server to an existing cluster. If the existing cluster has a non-empty password set for the `"admin"` user, a new server is only allowed to join the cluster if it has a password set as well. This is to avoid insecure states during the join process. You can use the new `--initial-password auto` command line option for joining a new server or proxy to a password-protected cluster. The `--initial-password auto` option assigns a random `"admin"` password on startup, which gets overwritten by the previously configured password on the cluster once the join process is complete. ### API-breaking changes - The `eqJoin` command no longer returns results in the order of its first input. You can pass in the new `{ordered: true}` option to restore the previous behavior. - Operations on geospatial multi-indexes now emit duplicate results if multiple index keys of a given document match the query. You can append the `.distinct()` command in order to restore the previous behavior. - Changefeeds on queries of the form `orderBy(...).limit(...).filter(...)` are no longer allowed. Previous versions of RethinkDB allowed the creation of such changefeeds, but did not provide the correct semantics. - The commands `r.wait`, `r.rebalance` and `r.reconfigure` can no longer be called on the global `r` scope. Previously, these commands defaulted to the `"test"` database implicitly. Now they have to be explicitly called on either a database or table object. For example: `r.db("test").wait()`, `r.db("test").rebalance()`, etc. - The `{returnChanges: "always"}` option with the `insert` command will now add `{error: "..."}` documents to the `changes` array if the insert fails for some documents. Previously failed documents were simply omitted from the `changes` result. - The special values `r.minval` and `r.maxval` are no longer permitted as return values of secondary index functions. ### Deprecated APIs - The JavaScript `each` function is deprecated in favor of `eachAsync`. In a future release, `each` will be turned into an alias of `eachAsync`. We recommend converting existing calls of the form `.each(function(err, row) {})` into the `eachAsync` equivalent `.eachAsync(function(row) {}, function(err) {})`. You can read more about [`eachAsync` in the documentation](http://rethinkdb.com/api/javascript/each_async/). - The `auth_key` option to `connect` in the official drivers is deprecated in favor of the new `user` and `password` options. For now, a provided `auth_key` value is mapped by the drivers to a password for the `"admin"` user, so existing code will keep working. ### Discontinued packages We no longer provide packages for the Debian oldstable distribution 7.x (Wheezy). When compiling from source, the minimum required GCC version is now 4.7.4. ## New features - Added support for user accounts, user authentication, and access permissions. Users can be configured through the `"users"` system table. Permissions can be configured through either the new `"permissions"` system table or through the `grant` command. (#4519) - Driver, intracluster and web UI connections can now be configured to use TLS encryption. For driver and intracluster connections, the server additionally supports certificate verification. (Linux and OS X only, #5381) - Added beta support for running RethinkDB on Windows (64 bit only, Windows 7 and up). (#1100) - Added a `fold` command to allow stateful transformations on ordered streams. (#3736) - Added support for changefeeds on `getIntersecting` queries. (#4777) ## Improvements - Server - The `--bind` option can now be specified separately for the web UI (`--bind-http`), client driver port (`--bind-driver`) and cluster port (`--bind-cluster`). (#5467) - RethinkDB servers now detect non-transitive connectivity in the cluster and raise a `"non_transitive_error"` issue in the `"current_issues"` system table when detecting an issue. Additionally, the `"server_status"` system table now contains information on each server's connectivity in the new `connected_to` field. (#4936) - Added a new `"memory_error"` issue type for the `"current_issues"` system table that is displayed when the RethinkDB process starts using swap space. (Linux only) (#1023) - Reduced the number of scenarios that require index migration after a RethinkDB upgrade. Indexes no longer need to be migrated unless they use a custom index function. (#5175) - Added support for compiling RethinkDB on Alpine Linux. (#4437) - Proxy servers now print their server ID on startup. (#5515) - Raised the maximum query size from 64 MB to 128 MB. (#4529) - Increased the maximum number of shards for a table from 32 to 64. (#5311) - Implemented a `--join-delay` option to better tolerate unstable network conditions (#5319) - Added an `--initial-password` command line option to secure the process of adding new servers to a password-protected cluster. (#5490) - Implemented a new client protocol handshake to support user authentication. (#5406) - ReQL - Added an `interleave` option to the `union` command to allow merging streams in a particular order. (#5090) - Added support for custom conflict-resolution functions to the `insert` command. (#3753) - The `insert` command now returns changes in the same order in which they were passed in when the `returnChanges` option is used. (#5041) - Added an `includeOffsets` option to the `changes` command to obtain the positions of changed elements in an `orderBy.limit` changefeeds. (#5334) - Added an `includeTypes` option to the `changes` command that adds a `type` field to every changefeed result. (#5188) - Made geospatial multi-indexes behave consistently with non-geospatial multi-indexes if a document is indexed under multiple matching keys. `getIntersecting` and `getNearest` now return duplicates if multiple index keys match. (#3351) - The `and`, `or` and `getAll` commands can now be called with zero arguments. (#4696, #2588) - Disallowed calling `r.wait`, `r.rebalance` and `r.reconfigure` on the global scope to avoid confusing semantics. (#4382) - The `count` and `slice` commands can now be applied to strings. (#4227, #4228) - Improved the error message from `reconfigure` if too many servers are unreachable. (#5267) - Improved the error message for invalid timezone specifications. (#1280) - Performance - Implemented efficient batching for distributed joins using the `eqJoin` command. (#5115) - Optimized `tableCreate` to complete more quickly. (#4746) - Reduced the CPU overhead of ReQL function calls and term evaluation. (no issue number) - Web UI - The web UI now uses the `conn.server()` command for getting information about the connected server. (#5059) - All drivers - Implemented a new protocol handshake and added `user` and `password` options to the `connect` method to enable user authentication. (#5458, #5459, #5460, #5461) - Added `clientPort` and `clientAddress` functions to the connection objects in the JavaScript, Python and Ruby drivers. (#4796) - JavaScript driver - Added new variants of the `cursor.eachAsync` function. (#5056) - Added a `concurrency` option for `cursor.eachAsync`. (#5529) - `r.min`, `r.max`, `r.sum`, `r.avg` and `r.distinct` now accept an array argument (#4594) - Python driver - Added a `"gevent"` loop type to the Python driver. (#4433) - Printing a cursor object now displays the first few results. (#5331) - Removed the dependency on `tar` for the `rethinkdb restore` and `rethinkdb dump` commands. (#5399) - Added a `--tls-cert` option to the `rethinkdb import`, `rethinkdb export`, `rethinkdb dump`, `rethinkdb restore` and `rethinkdb index-rebuild` commands to enable TLS connections. (#5330) - Added `--password` and `--password-file` options to the `rethinkdb import`, `rethinkdb export`, `rethinkdb dump`, `rethinkdb restore` and `rethinkdb index-rebuild` commands to connect to password-protected servers. (#5464) - Added a `--format ndjson` option to `rethinkdb export` that allows exporting tables in a newline-separated JSON format. (#5101) - Made `rethinkdb dump` `rethinkdb restore` and `rethinkdb import` able to write to stdout and load data from stdin respectively. (#5525, #3838) - `r.min`, `r.max`, `r.sum`, `r.avg` and `r.distinct` now accept an array argument (#5494) - Java driver: - Made it easier to publish the driver on local Ivy and Maven repositories. (#5054) ## Bug fixes - Server - Fixed a crash with the message `[cmp != 0]` when querying with `r.minval` or `r.maxval` values inside of an array. (#5542) - Fixed in issue that caused orphaned tables to be left behind when deleting a database through the `"db_config"` system table. (#4465) - Fixed a crash when trying to restore a backup from a version of RethinkDB that is too new. (#5104) - Fixed a bug in data migration from RethinkDB 2.0.x and earlier. (#5570) - Fixed a race condition causing server crashes with the message `Guarantee failed: [!pair.first.inner.overlaps(region.inner)]` when rebalancing a table while simultaneously opening new changefeeds. (#5576) - Fixed an issue causing backfill jobs to remain in the `jobs` system table even after finishing. (#5223) - ReQL - Disallowed changefeeds on queries of the form `orderBy(...).limit(...).filter(...)`, since they do not provide the correct semantics. (#5325) - Coercing a binary value to a string value now properly checks for illegal characters in the string. (#5536) - Web UI - Fixed the "The request to retrieve data failed" error when having an orphaned table whose database has been deleted. (#4985) - Fixed the maximum number of shards display for clusters with more than 32 servers. (#5311) - Fixed an empty "Connected to" field when accessing the web UI through a RethinkDB proxy server. (#3182) - JavaScript driver - Fixed the behavior of `cursor.close` when there are remaining items in the buffer. (#5432) - Python driver - Fixed a bug in the `__str__` function of cursor objects. (#5567) - Fixed the handling of the error generated for over-sized queries. (#4771) - Ruby driver - Fixed the handling of the error generated for over-sized queries. (#4771) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.3. In no particular order: - Aaron Rosen (@aaronorosen) - @crockpotveggies - Daniel Hokka Zakrisson (@dhozac) - Igor Lukanin (@igorlukanin) - @janisz - Joshua Bronson (@jab) - Josh Hawn (@jlhawn) - Josh Smith (@Qinusty) - Marshall Cottrell (@marshall007) - Mike Mintz (@mikemintz) - Niklas Hambüchen (@nh2) - Qian Jin (@QianJin2013) - Taylor Murphy (@tayloramurphy) - Vladislav Botvin (@darrrk) - Adam Grandquist (@grandquista) - @bakape - Bernardo Santana (@bsantanas) - Bheesham Persaud (@bheesham) - Christopher Cadieux (@ccadieux) - Chuck Bassett (@chuckSMASH) - Diney Wankhede (@dineyw23) - Heinz Fiedler (@heinzf) - Mark Yu (@vafada) - Mike Krumlauf (@mjkrumlauf) - Nicolás Santángelo (@NicoSantangelo) - Samuel Volin (@untra) - Stefan de Konink (@skinkie) - Tommaso (@raspo)

rethinkdb v2.3.1

2016-04-23T02:13:43+00:00

Bug fix release ### Compatibility RethinkDB 2.3.1 servers can be mixed with RethinkDB 2.3.0 servers in the same cluster. We recommend that you run a mixed-version cluster only temporarily for upgrading purposes. No migration is required when upgrading from RethinkDB 2.3.0. Please read the [RethinkDB 2.3.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.3.0) if you're upgrading from an older version. ### Supported systems We now provide packages for Ubuntu 16.04 (Xenial Xerus). The `r.http` command no longer supports fetching data from encrypted `https` resources on OS X 10.7 and 10.8 (#5681). Newer releases of OS X are not affected. ### Bug fixes - Server - Fixed a segmentation fault triggered by performing a batched `insert` with multiple occurrences of the same primary key (#5683) - Fixed an uncaught exception bug in the `hostname_to_ips` function that could be triggered by connecting a server with an unresolvable address (#5629) - Fixed a query failure when opening a changefeed with the `squash: true` option on a system table (#5644) - Fixed a crash that was triggered when joining servers with identical server names (#5643) - Fixed an issue with the random number generator that stopped initial server names from getting randomized correctly (#5655) - Fixed a bug that caused memory to not be released properly after dropping a table or removing its replicas from a server (#5666) - Fixed a bug causing `eqJoin` to freeze the server when chained after a `changes` command (#5696) - Fixed an issue that caused the `returnChanges: "always"` option of the `insert` command to miss certain types of errors in the `changes` result (#5366) - Fixed a crash on OS X 10.7 when using the .dmg uninstaller (#5671) - The OS X .dmg uninstaller is now signed (#5615) - Fixed an edge case in the error handling for auto-generated primary keys when inserting into a system table (#5691) - RethinkDB can now be compiled with GCC 5.3 (#5635) - JavaScript driver - Renamed the `username` option of the `r.connect` command to `user`. The `username` option is still supported for backwards-compatibility with existing code (#5659) - Improved the error message shown when connecting with the 2.3 driver to an older server (#5667) - Python driver - Improved the error message that is emitted when trying to connect to a server with a wrong password (#5624) - Fixed the "global name 'options' is not defined" bug in the `rethinkdb import` script (#5637) - Fixed a Python 3 incompatibility in the `rethinkdb restore` script (#5647) - Java driver - Implemented the timeout option for `getNext` (#5603) - Losing the server connection while having a changefeed open now correctly results in an error (#5660) - The driver now caches authentication nonces in order to speed up connection setup (#5614) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.3.1. In no particular order: - Brian Chavez (@bchavez) - Neil Hanlon (@NeilHanlon) - Jason Soares (@JasonSoares) - Magnus Lundgren (@iorlas1)

rethinkdb v2.3.2

2016-05-06T19:00:05+00:00

Bug fix release ### Compatibility RethinkDB 2.3.2 servers can be mixed with older RethinkDB 2.3.x servers in the same cluster. We recommend that you run a mixed-version cluster only temporarily for upgrading purposes. No migration is required when upgrading from RethinkDB 2.3.x. Please read the [RethinkDB 2.3.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.3.0) if you're upgrading from an older version. ### Bug fixes - Server - Fixed a data corruption issue in the secondary index construction logic. The issue could be triggered by creating a secondary index while the table is under write load and could result in a `Guarantee failed: [token.has()]` error when accessing the index (#5715) - Fixed an issue in the Windows beta release that caused data corruption whenever growing a table to more than 4 GB (#5719) - Fixed a crash with the message `Guarantee failed: [num_subs == 0]` that could occur when shutting down a server while trying to start new changefeeds at the same time (#5708) - Fixed a crash with the message `Guarantee failed: [!pair.first.inner.overlaps(region.inner)]` that could occur when using changefeeds while resharding (#5745) - Added a `--tls-min-protocol` server option for reducing the minimum required TLS protocol version. Drivers using an old OpenSSL version (e.g. on OS X) might require this option in order to connect to a TLS-enabled RethinkDB server (#5734) - Added a check to disallow using `order_by` with a non-deterministic predicate function (#5548) - Fixed a segmentation fault at address 0x18 that could occur in low-memory conditions on Linux (#5348) - Fixed a stack overflow issue when parsing very deeply nested objects (#5601) - Improved the stack protection logic in order to avoid exceeding the system's memory map limit. This issue affected Linux servers when having a very high number of concurrently running queries (#5591) - The server is now built with jemalloc version 4.1 on Linux (#5712) - Fixed the message that is displayed when a query times out in the Data Explorer (#5113) - Improved the handling and reporting of OpenSSL-related errors (#5551) - Added a new server option `--cluster-reconnect-timeout` to control how quickly RethinkDB gives up trying to reconnect to a previously connected server (#5701) - Fixed a race condition when writing to system tables that could lead to incorrect update results (#5711) - A custom conflict resolution function for the `insert` command can now return `null` in order to delete a conflicting document (#5713) - Improved the error message emitted when opening a changefeed on an `orderBy.limit` query that has additional transformations (#5721) - Fixed an incompatibility with Safari that could cause undesired page reloads in the web UI (#3983) - Python driver - The Python driver's `ssl` option now supports older Python versions from 2.7 up (#4815) - Added a REPL mode that can be launched through the new `python -m rethinkdb` command (#5147) - Added a cache for PBKDF2 authentication tokens to reduce the costs of repeatedly opening connections (#5614) - Refactored how the RethinkDB import and export scripts load the driver (#4970) - Improved the error message reported when attempting to connect to a pre-2.3.0 server (#5678) - Fixed an incompatibility with Python 3 in the `rethinkdb dump` script that caused `name 'file' is not defined` errors (#5694) - Fixed an incompatibility with Python 3.3 in the protocol handshake code (#5742) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.3.2. In no particular order: - Matt Broadstone (@mbroadst) - Saad Abdullah (@saadqc)

rethinkdb v2.3.3

2016-06-01T18:54:14+00:00

Bug fix release ### Compatibility RethinkDB 2.3.3 servers can be mixed with older RethinkDB 2.3.x servers in the same cluster. We recommend that you run a mixed-version cluster only temporarily for upgrading purposes. No migration is required when upgrading from RethinkDB 2.3.x. Please read the [RethinkDB 2.3.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.3.0) if you're upgrading from an older version. ### Windows support RethinkDB 2.3.0 was the first version to include native Windows compatibility. In RethinkDB 2.3.3, the Windows port is ready to emerge from "beta" testing. We now officially support RethinkDB on the Windows platform alongside our existing support for Linux and Mac OS X. We're also extending our [commercial support](https://rethinkdb.com/services/) services to include RethinkDB on Windows. Although RethinkDB is now stable on Windows, there are still a few [remaining limitations](https://github.com/rethinkdb/rethinkdb/issues?q=is%3Aopen+is%3Aissue+label%3Awindows) that we are actively working to address. We also haven't yet carried out as much performance tuning on the Windows port as we have on the Linux and OS X releases. ### Bug fixes - Server - Fixed a bug in `orderBy.limit` changefeeds that caused the server to crash with `Guarantee failed: [sub_it != real_added.end()]` (#5561) - Improved the performance of the `table_status` system table when the cluster is under high load (#5586) - Fixed a race condition in the cluster connection logic that could cause occasional crashes with a `Guarantee failed: [refcount == 0]` error (#5783) - Fixed a stack overflow when executing queries with a very high number of chained commands (#5792) - Made the `fold` command work on a changefeed stream (#5800) - Fixed the server uptime calculation on Windows (#5388) - Fixed source code incompatibilities with GCC 6.0 (#5757) - JavaScript driver - The `Connection` class is now exported from the RethinkDB JavaScript module (#5758) - Java driver - Added the `clientPort` and `clientAddress` methods to the `Connection` class in the Java driver (#5571) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.3.3. - Gergely Nemeth (@gergelyke)

rethinkdb v2.3.4

2016-06-04T05:27:48+00:00

Bug fix release ### Compatibility On 32-bit platforms and on Windows (64 and 32 bit), RethinkDB 2.3.4 servers should not be mixed with older RethinkDB 2.3.x servers in the same cluster. Doing so can lead to server crashes when using the web UI or when accessing the `logs` system table. On 64-bit platforms, RethinkDB 2.3.4 servers can be mixed with older RethinkDB 2.3.x servers in the same cluster. We recommend that you run a mixed-version cluster only temporarily for upgrading purposes. No migration is required when upgrading from RethinkDB 2.3.x. Please read the [RethinkDB 2.3.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.3.0) if you're upgrading from an older version. ### Bug fixes - Server - Fixed a segmentation fault in the `orderBy.limit` changefeed implementation (#5824) - Fixed an incompatibility in the cluster protocol between Windows and Linux / OS X servers (#5819) - Python driver - Fixed various bugs in the connection class for the asyncio event loop (#5795, #5816, #5820) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.3.4. - Ultrabug (@ultrabug)

rethinkdb v2.3.5

2016-08-29T21:19:52+00:00

Bug fix release ### Compatibility On 32-bit platforms and on Windows (64 and 32 bit), RethinkDB 2.3.5 servers should not be mixed with servers running RethinkDB 2.3.3 or older in the same cluster. Doing so can lead to server crashes when using the web UI or when accessing the `logs` system table. On 64-bit platforms other than Windows, RethinkDB 2.3.5 servers can be mixed with older RethinkDB 2.3.x servers in the same cluster. We recommend that you run a mixed-version cluster only temporarily for upgrading purposes. No migration is required when upgrading from RethinkDB 2.3.x. Please read the [RethinkDB 2.3.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.3.0) if you're upgrading from an older version. ### Bug fixes - Server - Improved the efficiency of the on-disk garbage collector to reduce the risk of excessive file growth (#5923) - Improved the latency of read queries under heavy write loads (#6072) - Fixed a bug that could cause the server to crash with a deserialization error or to stop completing any table reads (#6033) - Fixed a bug in the implementation of the `interleave` option of the `union` command, which could potentially lead to results being generated in the wrong order (#6041) - Fixed a bug in the batch handling of the `fold` and multi-stream `map` commands, that would stop results from being generated correctly if these commands were applied to a changefeed (#6007) - Fixed an issue that could cause proxies to remain listed in the `connected_to` field of the `server_status` table, even after they had disconnected (#5871) - Fixed the detection of non-deterministic conflict functions in the `insert` command (#5842) - Improved the Raft election timeout logic to avoid infinite Raft election loops (#6038) - Improved the response time when reading from the `table_status` system table (#4589) - The server no longer logs the message `Rejected a connection from server X since one is already open` when trying to connect to itself (#5456) - Fixed a bug that could cause an `Uncaught exception` server crash if a TLS-encrypted connection was closed during a certain connection stage (#5904) - Fixed a bug in `merge` that could cause `r.literal` objects to remain after the `merge` and be stored in a table (#5977) - On Windows: Fixed a bug in the `r.http` command that resulted in decoding issues (#5924) - On Windows: RethinkDB now binds TCP ports exclusively (#6008) - On Windows: No longer print an error to the log whenever a connection attempt fails (no issue #) - Fixed a build issue that caused system libraries to not be found during `make` on OpenSUSE (#2363) - JavaScript driver - Fixed the server nonce validation in the connection handshake (#5916) - The `host` argument to `connect` is now optional (#5846) - Java driver - Cursors now implement the `Closeable` interface (#5468) - Fixed no-reply queries as run through `runNoReply` (#5938) - Fixed a bug in the `reconnect` method (#5841) - Fixed a memory leak in the `Connection` object that was caused by the driver not properly cleaning up closed cursors (#5980) - Python driver - The `asyncio` loop type is now available when using the driver from a Python .egg file (#6043) - Ruby driver - Fixed a rounding issue with time objects (#5825) ## Contributors Many thanks to external contributors from the RethinkDB community for helping us ship RethinkDB 2.3.5. - Arve Seljebu (@arve0) - Ben Sharpe (@bsharpe) - Brian Chavez (@bchavez) - Dan Wiechert (@DWiechert) - mbains (@mbains) - QianJin2013 (@QianJin2013) - Raman Gupta (@rocketraman)

rethinkdb v2.3.6

2017-07-23T02:20:28+00:00

Bug fix release ### Notes ### This is the first release of RethinkDB since October 2016. The RethinkDB project has [joined the Linux Foundation][blog-new-rethinkdb]. This release is brought to you by volunteers from the Open RethinkDB team. The RethinkDB source code is now licensed under an [ASLv2 license][ASLv2-license]. [blog-new-rethinkdb]: https://rethinkdb.com/blog/rethinkdb-joins-linux-foundation/ [ASLv2-license]: https://www.apache.org/licenses/LICENSE-2.0 ### Compatibility ### On 32-bit platforms and on Windows (64 and 32 bit), RethinkDB 2.3.6 servers should not be mixed with servers running RethinkDB 2.3.3 or older in the same cluster. Doing so can lead to server crashes when using the web UI or when accessing the `logs` system table. On 64-bit platforms, RethinkDB 2.3.6 servers can be mixed with older RethinkDB 2.3.x servers in the same cluster. We recommend that you run a mixed-version cluster only temporarily for upgrading purposes. No migration is required when upgrading from RethinkDB 2.3.x. Please read the [RethinkDB 2.3.0 release notes][release-notes-2.3.0] if you're upgrading from an older version. ### Changes ### * Server * Improved the compatibility of the web UI with Chrome 49 and Edge (#5878, #5426, #5300) -- @danielmewes * Fixed a crash caused by unwanted connections (#6084) -- @danielmewes * Fixed a crash caused by recreating indexes with active changefeeds (#6093) -- @danielmewes * Sizes passed to `sample` are now bound by the array size limit (#6148) -- @AtnNn * Fixed a crashing bug in the implementation of the `interleave` argument to `union` (#6139) -- @AtnNn * Fixed a crash caused by `eqJoin` of system tables when using the `uuid` `identifierFormat` (#6108) -- @nighelles * Fixed a bug that caused `r.match('')` to return wrong results (#6241) -- @AtnNn * Miscellaneous regression fixes and code improvements by @srh and @VeXocide * Fixed argument order in pretty-printed queries in the jobs table (#6240) -- @AtnNn * Packaging * Fix glibc version detection in RPM packaging script (#6229) -- @gamename * Add packages for Ubuntu Yakkety and Zesty (#6364) -- @AtnNn Official Downloads: https://rethinkdb.com/docs/install/

rethinkdb v2.4.0-beta.1

2018-07-02T04:53:49+00:00

The release is a beta release of 2.4 for testing and compatibility checking with new drivers. Once stabilized, 2.4 will be released

rethinkdb v2.4.0

2019-12-19T18:30:54+00:00

RethinkDB 2.4 introduces write hooks and bitwise operations besides bug fixes. Read the [blog post](https://rethinkdb.com/blog/2.4.0-release) for more details. ### Compatibility ### Data files from RethinkDB version 1.16 onward will be automatically migrated. As with any major release, back up your data files before performing the upgrade. Please read the [RethinkDB 2.4.0 release notes][release-notes-2.4.0] if you're upgrading from version 2.3.x or earlier. [release-notes-2.4.0]: https://github.com/rethinkdb/rethinkdb/releases/tag/v2.4.0 RethinkDB 2.4.0 servers cannot be mixed with servers running RethinkDB 2.3.x or earlier in the same cluster. ### Official Drivers ### Except for JavaScript, the official drivers are now generally maintained as separate projects. But note that there is some coupling of RethinkDB console commands, like `rethinkdb dump`, with the Python driver. RethinkDB 2.4 contains some old copies of the drivers to keep `./test/run` working with minimal effort. The JavaScript driver is still used in the Web UI. However, the web assets are now pre-generated, at src/gen/web_assets.cc, making the presence of the driver in the repository not strictly necessary. Here are links to the official drivers: * Python: https://github.com/rethinkdb/rethinkdb-python/ * Ruby: https://github.com/rethinkdb/rethinkdb-ruby/ * Java: https://github.com/rethinkdb/rethinkdb-java/ * JavaScript: https://github.com/rethinkdb/rethinkdb/tree/next/drivers/javascript ### API-breaking changes ### * Write hooks add a new field to the table configuration. * A bugfix changes the `match` command's behavior on empty regexes. It had previously been behaving incorrectly. ### Substantive Changes ### (Issue numbers point into the https://github.com/rethinkdb/rethinkdb bugtracker.) * ReQL * Added the `set_write_hook` and `get_write_hook` commands, which attach to tables a function that can modify the behavior of any write. (#5813) * Added bitwise operators for number types: `bit_and`, `bit_not`, `bit_or`, `bit_sal` (or `bit_shl`), `bit_sar`, `bit_shr`, and `bit_xor`. (#6534) * Permitted the hyphen character (`-`) to be used in table names. (#5537) * Users may be granted permissions on system tables. (#5692) * Make `iso8601` command round, not truncate. (#6909) * Fix timestamp millisecond down-truncation bug. (#6272) * Server * Fixed crash with limit change feed `inserted` guarantee failure. (#6710) * Avoid using DNS resolution when finding network interface addresses. (#6588) * Removed update checker. (#6791) * Added experimental support for arm64/aarch64. (#6438) * Added experimental support for Power8/LE platform. (#6317) * Fixed race condition in the query cache. (#6564) * Avoid quadratic growth in segmented vector. (#6385) * Big-Endian fixes and s390x support. (#6242) * Web UI * Implemented a new table viewer widget for browsing the contents of tables. (#6767) * Improved table page performance in case with many databases. (#6790) * Compilation * The web assets are now pre-generated, so that macOS users can build them. (#6770) * Debian package building is now parallelized. (#6780) * Fixed extproc spawner bug. (#5572) * Allowed building against libressl. (#6671) * JavaScript Driver * Avoided mutating object passed to `r.connect`. (#6575) * Python Driver * See more details at https://github.com/rethinkdb/rethinkdb-python/releases * Other Drivers * Changes omitted, as they're in separate repositories.

rethinkdb v2.4.1

2020-08-14T19:51:04+00:00

Bug fix release. ### Compatibility ### No migration is required when upgrading from RethinkDB 2.4.x. Please read the [RethinkDB 2.4.0 release notes][release-notes-2.4.0] if you're upgrading from an older version. [release-notes-2.4.0]: https://github.com/rethinkdb/rethinkdb/releases/tag/v2.4.0 RethinkDB 2.4.0 servers cannot be mixed with servers running RethinkDB 2.3.x or earlier in the same cluster. ### Changes ### (Issue numbers point into the https://github.com/rethinkdb/rethinkdb bugtracker.) * Server * Force flushing when stdout isn't on a TTY (#6819) * Fix code style issues (#6842) * Fix warnings about missing assignment definitions in clang 10.0.0 (commit 3ca96904) * Compilation * Fix aarch64 builds in 2.4.x using clang++ (commit 01683d3e) * Fix Linux Mint 20 build errors (commit 328ebfb) * Web UI * Reintroduce update checker (#6879) * Allow hyphens in table and database names (#6908)

rethinkdb v2.4.2

2022-05-07T19:28:23+00:00

Bitrot, futureproofing, and bug fix release. ### Compatibility ### No migration is required when upgrading from RethinkDB 2.4.x. Please read the [RethinkDB 2.4.0 release notes][release-notes-2.4.0] if you're upgrading from an older version. [release-notes-2.4.0]: https://github.com/rethinkdb/rethinkdb/releases/tag/v2.4.0 RethinkDB 2.4.x servers cannot be mixed with servers running RethinkDB 2.3.x or earlier in the same cluster. ### API-breaking changes ### The `r.js` ReQL command now uses QuickJS to run instead of v8. Because RethinkDB's v8 version was old, this will allow you to use newer JavaScript features. However, performance and the results of your JavaScript code may differ. ### Substantive Changes ### (Issue numbers point into the https://github.com/rethinkdb/rethinkdb bugtracker. For a completionist list of changes, run `git log v2.4.1..v2.4.2`.) * Server * Fix 32-bit overflow bug with Raft log indexes (#7036) * Make `r.http` requests use HTTP/1.1 (#7012). This works around `r.http`'s inability to parse HTTP/2 responses. * Fix saslname decode logic (#7016) * The limit of 127 threads has been removed (#6895) * On newer MacOSes, make assertion failures abort the process (#7049) * On newer MacOS builds, upon assertion failures, generate backtraces correctly (#7049) * Fix an O(1) memory leak (#7010) * Fix some newer MacOS warnings and compilation errors (#7014) * Fix some other GCC warnings (various commits) * Update curl dependency to 7.82.0 * Update jemalloc dependency to 5.2.1 * Update libidn dependency to 1.38 * Update openssl dependency (if fetched) to 3.0.1 * Get Apple M1 building working * Compilation * Split out web assets code and its build dependency chain to the `old_admin` branch (#6979) * Package generation updates for Ubuntu 21.10, 22.04, and Debian Bullseye (#7021) * More package generation updates for Debian (commit da34c2f) * Make install-include depend on dependency install witness (commit 79c6857) * Make RPM building explicitly name fetched dependencies and dynamically link (#7035) * Add RDB_NO_BACKTRACE flag for musl users (#7052) * A patch for wider boost compatibility was supplied (#6934) * Web UI * The web UI was excised to the branch https://github.com/rethinkdb/rethinkdb/tree/old_admin (#6979) ## Contributors ## Many thanks to the following contributors whose patches made it into the RethinkDB 2.4.2 server release: * Rui Chen (@chenrui333) * Mathieu Schroeter (@Skywalker13) * Yong-Hao Zou (@zouyonghao) * zadcha (@zadsza) * Leo Arias (@elopio) And many thanks go to the driver committers, alternative admin console client developers, bug reporters, and other helpful people who are not listed here.

rethinkdb v2.4.3

2023-02-05T01:14:53+00:00

# 2.4.3 - Night of the Living Dead Windows release, FreeBSD 13 compilation, certificate chain support, no update checker complaint. Brings some low-key compilation future-proofing. ### Compatibility No migration is required when upgrading from RethinkDB 2.4.x. Please read the [RethinkDB 2.4.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.4.0) if you're upgrading from an older version. RethinkDB 2.4.x servers cannot be mixed with servers running RethinkDB 2.3.x or earlier in the same cluster. ### API-breaking changes ### None. Some console output is altered, though. ### Changes ### * Server * Fail correctly when failing to remove directory (#4647) * Improve --initial-password help text (#7064) * Add machine arch and uname to rethinkdb version output (#7060) * Improve general help formatting (#7095) * Update OpenSSL version (if fetched and statically linked) to 3.0.7 (#7099) * Make TLS configuration support certificate chains (#6969) * Regenerate the version correctly (eliminating update checker annoyance) (#7100) * Compilation * Get the Windows build working (#7074, #7075, #7082, #7083) * Switch from QuickJS to QuickJSpp (our fork hosted at https://github.com/rethinkdb/quickjspp ) * Include in files using time function (#7091) * and add more explicit includes for future-proofing (#7098) * Get FreeBSD build working (#7088, #7098) * Avoid some uses of egrep (#7092) * Web UI * Update jQuery to 3.6.1 (#6937) ### Contributors ### * Mariano Rodríguez (@MarianoRD) * Hung-Te Lin (@hungte) * Antoni Mróz (@MrBoombastic) * unx (@unxcepted) * Russel Beswick (@besworks) * Sam Hughes (@srh) * Gábor Boros (@gabor-boros) Special thanks are due to Antoni Mróz and unx for getting the Windows release working.

rethinkdb v2.4.4

2023-12-11T01:42:50+00:00

# 2.4.4 - Night of the Living Dead Fixes for Data Explorer autocomplete, compilation fixes, other small fixes. ### Compatibility No migration is required when upgrading from RethinkDB 2.4.x. Please read the [RethinkDB 2.4.0 release notes](https://github.com/rethinkdb/rethinkdb/releases/tag/v2.4.0) if you're upgrading from an older version. RethinkDB 2.4.x servers cannot be mixed with servers running RethinkDB 2.3.x or earlier in the same cluster. ### API-breaking changes ### None. ### Changes ### * Server * Avoid unaligned memory accesses and bus errors on 32-bit ARM (#7128) * Compilation * Replace bad zlib URL with working one (#7121) * Fix new include errors (#7119) * Avoid using deprecated `fstat64` function (#7141) * Web UI * Fix data explorer auto-complete (#7111, #7113) * Update ReQL documentation link (#7112, #7114) ### Contributors ### * @sg5506844 * Sam Hughes (@srh)