The open-source database for the realtime web.

Related tags

Database rethinkdb
Overview

RethinkDB

CII Best Practices Codacy Badge

What is RethinkDB?

  • Open-source database for building realtime web applications
  • NoSQL database that stores schemaless JSON documents
  • Distributed database that is easy to scale
  • High availability database with automatic failover and robust fault tolerance

RethinkDB is the first open-source scalable database built for realtime applications. It exposes a new database access model, in which the developer can tell the database to continuously push updated query results to applications without polling for changes. RethinkDB allows developers to build scalable realtime apps in a fraction of the time with less effort.

To learn more, check out rethinkdb.com.

Not sure what types of projects RethinkDB can help you build? Here are a few examples:

Quickstart

For a thirty-second RethinkDB quickstart, check out rethinkdb.com/docs/quickstart.

Or, get started right away with our ten-minute guide in these languages:

Besides our four official drivers, we also have many third-party drivers supported by the RethinkDB community. Here are a few of them:

Looking to explore what else RethinkDB offers or the specifics of ReQL? Check out our RethinkDB docs and ReQL API.

Building

First install some dependencies. For example, on Ubuntu or Debian:

sudo apt-get install build-essential protobuf-compiler python \
    libprotobuf-dev libcurl4-openssl-dev libboost-all-dev \
    libncurses5-dev libjemalloc-dev wget m4 g++ libssl-dev

Generally, you will need

  • GCC or Clang
  • Protocol Buffers
  • jemalloc
  • Ncurses
  • Boost
  • Python 2
  • libcurl
  • libcrypto (OpenSSL)
  • libssl-dev

Then, to build:

./configure --allow-fetch
# or run ./configure --allow-fetch CXX=clang++

make -j4
# or run make -j4 DEBUG=1

sudo make install
# or run ./build/debug_clang/rethinkdb

Need help?

A great place to start is rethinkdb.com/community. Here you can find out how to ask us questions, reach out to us, or report an issue. You'll be able to find all the places we frequent online and at which conference or meetups you might be able to meet us next.

If you need help right now, you can also find us on Slack, Twitter, or IRC at #rethinkdb on Freenode.

Contributing

RethinkDB was built by a dedicated team, but it wouldn't have been possible without the support and contributions of hundreds of people from all over the world. We could use your help too! Check out our contributing guidelines to get started.

Donors

  • CNCF
  • Digital Ocean provides infrastructure and servers needed for serving mission-critical sites like download.rethinkdb.com or update.rethinkdb.com
  • Atlassian provides OSS license to be able to handle internal tickets like vulnerability issues
  • Netlify OSS license to be able to migrate rethinkdb.com
  • DNSimple provides DNS services for the RethinkDB project
  • ZeroTier sponsored the development of per-table configurable write aggregation including the ability to set write delay to infinite to create a memory-only table (PR #6392)

Licensing

RethinkDB is licensed by the Linux Foundation under the open-source Apache 2.0 license. Portions of the software are licensed by Google and others and used with permission or subject to their respective license agreements.

Where's the changelog?

We keep a list of changes and feature explanations here.

Comments
  • Windows support

    Windows support

    Windows compatibility could be a good thing for wamp-like dev environnement. be able to test a project with a dummy local db is easyer than binding in dev config file to use a distant one (for windows developer of course)

    windows 
    opened by 1000i100 184
  • Proposal: Dates

    Proposal: Dates

    I propose that we introduce three new pseudo-types: dates (by which I mean date, time, and optional timezone), durations, and intervals, all cribbed from ISO 8601 (http://en.wikipedia.org/wiki/ISO_8601), which we represent as strings.

    We introduce the following terms:

    date.date_sub(other_date) => duration
    date.dur_sub(duration) => other_date
    date.dur_add(duration) => other_date
    duration.dur_sub(other_duration) => third_duration
    duration.dur_add(other_duration) => third_duration
    
    date.date_{lt/gt/le/ge/eq/ne}(other_date) => bool
    duration.dur_{lt/gt/le/ge/eq/ne}(other_date) => bool
    
    # intervals can also be specified directly as strings
    r.interval(date, other_date) => interval
    r.interval(date, duration) => interval
    date.during(interval) => bool
    

    We should also update the drivers to automatically render native dates/durations/intervals as the appropriate strings.

    So, for example, in Ruby you could get all rows inserted in the last day with:

    table.between(Date.today, Date.today - 1, :index => :timestamp)
    

    Or, if Ruby didn't have easy date manipulation:

    table.between(Time.now, r(Time.now).dur_sub("P1M"), :index => :timestamp)
    
    tp:ReQL_proposal tp:API_settled 
    opened by mlucy 164
  • Proposal: triggers

    Proposal: triggers

    // r.createTrigger(name, table, type, condition, action)
    // r.dropTrigger(name)
    
    // Every time someone inserts a new user older than 20, beep
    r.createTrigger('test', 'users', r.insert,
      function(new_user) {
        return new_user('age').gt(20);
      },
      r.js('npm.beep()'))
    
    // Every time someone turns 18, beep
    r.createTrigger('test2', 'users', r.update,
      function(old_row, new_row) {
        return r.and(old_row('age').ne(18),
                     new_row('age').eq(18));
      },
      r.js('npm.beep()'))
    
    // Stop beeping for twenty year olds
    r.dropTrigger('test');
    

    A couple of things:

    1. While the action could be any ReQL expression, to be really useful we have to run nodejs on the server. Then people can use things like RabbitMQ to communicate with other applications, which is immensely useful.
    2. The triggers are defined with respect to a single table, and can be run on a predefined set of operations (presumably inserts, updates/replaces, and deletes). Defining triggers with arbitrary conditions would be way too slow (since we'd have to evaluate potentially expensive conditions on every single mutation operation, it's questionable how to do that cross cluster, etc.)
    3. I think this functionality would be awesome. Obviously it's a bit away.
    tp:ReQL_proposal tp:API_settled 
    opened by coffeemug 150
  • ReQL proposal: Geospatial support

    ReQL proposal: Geospatial support

    Edit: Note the updated proposal below https://github.com/rethinkdb/rethinkdb/issues/2571#issuecomment-47298184

    In contrast to #1158, I would like to use this issue solely to track the ReQL API side of things.

    This proposal is limited to two-dimensional geodesic geometry (geometry on the earth's surface). We can add support for Euclidean geometry later if necessary.

    Geospatial data representation

    • Support at least Points, LineStrings and Polygons compatible to GeoJSON (Wikipedia, full specs ). I think MultiPoint, MultiLineString and MultiPolygon are less important. Once we add them we could support operations such as addition (union) and subtraction on geometry, but I'm going to skip them for now.
    • Define a new ReQL geometry pseudo-type
    • Provide two functions to convert from/to GeoJSON:
      • r.geoJSON(object) : object -> geometry converts from the GeoJSON object object to the geometry pseudo type
      • r.geoJSON(string) : string -> geometry (optional): equivalent to r.geoJSON(r.json(string))
      • geometry.toGeoJSON() : geometry -> object does the opposite of r.geoJSON(object)
    • Provide constructors:
      • r.geoPoint(x, y) : float, float -> geometry
      • r.geoLine(p1, p2, ...) : geometry, geometry, ... -> geometry where the input arguments must be points
      • r.geoLine([x1, y1], [x2, y2], ...) : [float, float], [float, float], ... -> geometry
      • r.geoPolygon(p1, p2, ...) : geometry, geometry, ... -> geometry where the input arguments must be points
      • r.geoPolygon([x1, y1], [x2, y2], ...) : [float, float], [float, float], ... -> geometry
      • polygon1.sub(polygon2) : geometry, geometry -> geometry subtracts polygon2 from polygon1. For now, we should make the following requirement: polygon2 must be completely inside of polygon1. This allows to construct polygons with holes in them.
      • For convenience: r.geoCircle(center, radius) : geometry, float -> geometry, r.geoRectangle(bottomLeft, upperRight) : geometry, geometry -> geometry create a line describing the corresponding shape. Can be combined with fill() (see Misc) to get spheres / filled rectangles.

    Creating a geospatial index

    • Any secondary index can store geospatial data. There is no distinction between geospatial and other indexes. If we index field a of a table, some documents in the table can have geometry in a and others can have strings, numbers or whatever.
    • We can later add special opt args to indexCreate() when we want to support different types of geometry.
    • (Internally geometry objects will probably be indexed similar to arrays in a multi index, where e.g. a polygon is "expanded" to a set of grid cells that it intersects with. We will probably want to limit the number of how many geometry objects can be stored in a composite index. Otherwise if for example we expand each polygon to ~10 grid cells, insert a document into a composite index that has three polygons as the composite index keys, we would end up with 10^3 index entries. Will have to determine later how we fail in such cases.)

    Misc

    • p1.distance(p2) : geometry, geometry -> float computes the minimal geodesic distance between points p1 and p2. Let's ignore distances to/between polygons and lines for now. Other geometries can be supported through opt args later.
    • l.fill() : geometry -> geometry Takes a line, makes it the outline of a polygon. The line has to be closed (and possibly must not intersect with itself, not sure about that yet).
    • geometry.isContained(polygon) : geometry, geometry -> bool tests whether geometry is completely contained in polygon
    • geometry1.intersects(geometry2) : geometry, geometry -> bool tests whether geometry1 and geometry2 intersect
    • Bonus: set1.isContained(set2) : array, array -> bool isContained() for two arrays. Tests whether all elements of set1 are found in set2.
    • Bonus: set1.intersects(set2) : array, array -> bool intersects() for two arrays.

    Querying

    • Ideally, we would provide a predicate function to table.getAll() such as table.getAll(function (x) { return x('position').isContained(polygon); } ) or table.getAll(function (x) { return x('position').distance(center).le(5.0); } ) and have an optimizer automatically make use of an index. However to avoid having to analyze the function, I propose introducing simplified predicates for getAll that can use secondary indexes (comparable to r.desc() and r.asc() for orderBy()):
      • table.getAll(geometry, {index: ...})
      • table.getAll(r.intersects(polygon), {index: ...})
      • table.getAll(r.isContained(polygon), {index: ...})
      • table.getAll(r.withinDistance(center, radius), {index: ...}) (sugar for r.intersects(r.geoCircle(center, radius).fill()), except that we might want to restrict it to points)
      • Bonus: table.getAll(r.isBetween(left, right)) as an alternative to r.between()
    • The predicates can also be combined for querying composite indexes: table.getAll([pred1, pred2, ...]). Note that such a query wouldn't always be efficient, and might have to rely heavily on post-filtering (or alternatively trigger a lot of smaller index lookups). Consider the example of table.getAll([r.isBetween(-inf, +inf), "foo"]) to see why this is the case. Not sure if we want to support this for the first version.
    • I would prefer restricting the previous composite query to having a non-equality predicate only as the final entry in the array. E.g. table.getAll(["foo", r.isBetween(-inf, +inf)]) would be legal, while the previously mentioned table.getAll([r.isBetween(-inf, +inf), "foo"]) would not be allowed. Such queries would always be efficient, and much easier to implement.
    • r.orderBy(r.distance(p), {index: ...}) (note that this is a single-argument p.distance() variant)

    Open questions:

    • Can we support querying by whether an entry in the index contains a given query geometry, rather than the other way around? Something like table.getAll(r.contains(geometry))?
    • Should we prefix all geo operations by geo? E.g. should we call intersects() geoIntersects() instead? This has the advantage that we can provide a reversed variant of isContained() called geoContains() without clashing with the existing object.contains(fieldNames) term.
    • For the first implementation, we might want to skip support for composite geospatial indexes altogether. I think it would be immensely useful though, and we should support it soon.
    tp:ReQL_proposal tp:API_settled 
    opened by danielmewes 145
  • Proposal: `r.group.map.reduce`

    Proposal: `r.group.map.reduce`

    This proposal includes a number of changes.

    • Introduce the group command
    r.table('foo').group('a', 'b').typeOf()
    // GROUPEDSTREAM
    
    r.table('foo').group('a', 'b')
    // Errors: `GROUPEDSTREAM is an opaque type`
    
    r.table('foo').group('a', 'b').map(...).typeOf()
    // GROUPEDSTREAM
    
    // Finally, google/hadoop-style map reduce is accessible to regular people:
    r.table('foo').group('a', 'b').map(...).reduce(...).typeOf()
    // STREAM
    
    • Get rid of base in reduce, and make reduce variadic. Have reduce accept either reduction functions, or aggregators:
    r.table('users').group('location').reduce(r.sum('age'),
                                              r.avg('age'),
                                              function(i, j) { return ...; })
    // returns [{group: ..., reduction1: ..., reduction2: ..., reduction3: ...}]
    
    • Allow naming groups and reductions because calling them group and reduction1, reduction2 isn't extremely useful.
    r.table('users').group('location', {'name': location}).
      reduce(r.sum('age', {name: 'age_sum'}),
             r.avg('age', {name: 'age_avg'}),
             function(i, j) { return ...; } // TODO: not sure how to name this. Ideas?
             )
    // returns [{location: ..., age_sum: ..., age_avg: ..., ???: ...}]
    
    • Consider dropping groupBy. We might want to consider leaving it as sugar for .group.reduce, because people are used to things like groupBy. I'm not 100% sure what to do here.
    tp:ReQL_proposal 
    opened by coffeemug 122
  • Improve the cache quota system

    Improve the cache quota system

    We can't have the OOM killer wreaking havoc on our users' processes willy-nilly. We need to have a smarter cache memory manager that limits the total cache size per machine to some reasonable number, and allows stealing cache memory between tables. We can discuss the details when we get to this feature.

    Additionally, we need to do memory profiling on large queries -- it seems that memory usage is higher than it should be.

    opened by coffeemug 107
  • Create official Java driver

    Create official Java driver

    https://github.com/npiv/rethink-java-driver might be a good jumping off point. It seems both of the 3rd party drivers for Java are abandoned or very out of date

    Java 
    opened by deontologician 100
  • Reading from multiple changefeeds in Python

    Reading from multiple changefeeds in Python

    The next operation in Python on cursors is a blocking operation, making it impossible to read from multiple changefeeds at once. This makes it very hard to take full advantage of changefeeds in Python.

    tp:ReQL_proposal tp:API_settled 
    opened by AtnNn 97
  • Evaluate options for project stewardship, non-profit

    Evaluate options for project stewardship, non-profit

    A straightforward possibility is to apply for membership in the Software Freedom Conservancy, which offers important services such as the ability to accept donations:

    https://sfconservancy.org/members/services/

    Another path would be to join Apache: https://incubator.apache.org/

    (This would require relicensing, if I'm interpreting https://incubator.apache.org/ correctly, so should probably be taken care of ASAP if that's the path you want to take.)

    open-rethinkdb 
    opened by eloquence 94
  • Support binary data type

    Support binary data type

    We need to ease the burden of storing binary data for people (saying 'encode it' into string isn't acceptable). We'd presumably do this by adding a BINARY term (as we discussed).

    Obviously, in backlog.

    opened by coffeemug 91
  • Job control API

    Job control API

    I discussed this in person with @timmaxw and @Tryneus -- this would be a spectacular addition to the reql admin release, and would take care of a number of related issues:

    • long running query log (and ability to kill)
    • much needed visibility into internal system processes

    I propose to create a system table jobs, and include any tasks that might make significant impact on the performance of the system. Off the top of my head:

    • user queries
    • any time GC spins up
    • secondary index post-construction
    • replication

    The user ought to be able to delete documents from the table to kill jobs (we may not let them delete everything; but certainly user queries and index post-construction).

    I'm purposely omitting the structure of the document from the spec. I think the implementer should take a pass at it first and let us play with a prototype. Once we do, we can tune the API to make it more user-friendly (like we did with other parts of the reql admin).

    opened by coffeemug 88
  • Fix typos

    Fix typos

    Addresses #7102. Didn't fix any comments.

    Some error message strings in the server were affected.

    • [x] I have read and agreed to the RethinkDB Contributor License Agreement http://rethinkdb.com/community/cla/
    opened by srh 1
  • Codespell report for

    Codespell report for "RethinkDB" (on fossies.org)

    The FOSS server fossies.org - supporting now also the RethinkDB project - offers among others a feature named "Source code misspelling reports". Such reports are normally only generated on request, but as Fossies administrator I have just created such a codespell based analysis for the "RethinkDB" GitHub v2.4.x development version:

     https://fossies.org/linux/test/rethinkdb-v2.4.x-snap.tar.gz/codespell.html

    That URL should redirect always to the report for the latest version identified by the short GitHub commit ID and a year-month-day string (YYMMDD) representing the according git pull date (mostly = commit date). The data are residing within a special restricted "test" folder that isn't really integrated into the standard Fossies services and should also not be accessible to search engines. The report should be available at least for some weeks and is continuously updated (currently with a half-hourly refresh rate).

    By the way, the context type of the spelling errors and typos are marked by a single character (within the sortable column "T"): The less interesting, probably not user visible ones (in "comments") are greyed, while the probably more interesting ones are black-colored. Especially interesting may be unassigned errors marked by a "?" since they may be contained in the source code itself. Some more according information is offered by a tooltip if the mouse is over the string "error context type character" above the table, over the "T" in the table header or over such a context character itself within the table. If JavaScript is enabled all table columns are sortable.

    Although after a first review some obviously wrong matches ("False Positives" = FPs) are already filtered out (ignored) please inform me if you find more of them so that I can exclude them if applicable.

    Most misspellings are found only in source code comments but e.g. the typo "processs" in the file test/common/driver.py (at line 892) may affect the code itself.

    Just for information there are also three supplemental pages showing some used "codespell" configuration details, all obvious false positives and a misspelling history (log).

    OK, spelling corrections certainly have a low priority, but they may also contribute to the overall quality of a software project. So I hope that the report can nevertheless be a little bit useful.

    opened by jschleus 1
  • RethinkDB 2.4.3 release list

    RethinkDB 2.4.3 release list

    The current checklist for releasing RethinkDB 2.4.3 has just one dev item (a PR is up), and then some builds to verify still compile, before cutting a version and releasing:

    Code:

    • [ ] Merge #7100

    Builds:

    • [ ] Linux amd64 builds
    • [ ] Linux ARM builds
    • [ ] Windows amd64 build
    • [ ] MacOS amd64 build
    opened by srh 0
  • Regenerate web assets for v2.4.3

    Regenerate web assets for v2.4.3

    • [x] I have read and agreed to the RethinkDB Contributor License Agreement http://rethinkdb.com/community/cla/

    Description

    Regenerates the web assets.cc from the old_admin branch with the version number 2.4.3.

    opened by srh 0
  • Error running on production, log

    Error running on production, log

    Hi, i wan't to report this error:

    2022-09-05T23:09:57.257906287 1813871.533910s error: Error in thread 8 in src/btree/leaf_node.cc at line 178:
    2022-09-05T23:09:57.258012477 1813871.534012s error: Guarantee failed: [offset <= bs] offset=65500, bs=4088
    2022-09-05T23:09:57.258034334 1813871.534034s error: Backtrace:
    2022-09-05T23:10:09.651544508 1813883.927551s error: Mon Sep  5 23:09:57 2022\n\n1 [0xcf0200]: backtrace_t::backtrace_t() at ??:?\n2 [0xcf0560]: format_backtrace(bool) at ??:?\n3 [0x9d090f]: report_fatal_error(char const*, int, char const*, ...) at ??:?\n4 [0x9fa084]: leaf::prepare_space_for_new_entry(value_sizer_t*, leaf_node_t*, btree_key_t const*, int, repli_timestamp_t, repli_timestamp_t, bool, char**) at ??:?\n5 [0x9fa11f]: leaf::insert(value_sizer_t*, leaf_node_t*, btree_key_t const*, void const*, repli_timestamp_t, repli_timestamp_t) at ??:?\n6 [0x9efe0b]: apply_keyvalue_change(value_sizer_t*, keyvalue_location_t*, btree_key_t const*, repli_timestamp_t, value_deleter_t const*, delete_mode_t) at ??:?\n7 [0xd0ad05]: kv_location_set(keyvalue_location_t*, store_key_t const&, ql::datum_t, repli_timestamp_t, deletion_context_t const*, rdb_modification_info_t*) at ??:?\n8 [0xd0b117]: rdb_replace_and_return_superblock(btree_loc_info_t const&, btree_point_replacer_t const*, deletion_context_t const*, promise_t<superblock_t*>*, rdb_modification_info_t*, profile::trace_t*) at ??:?\n9 [0xd1243e]: do_a_replace_from_batched_replace(auto_drainer_t::lock_t, fifo_enforcer_sink_t*, fifo_enforcer_write_token_t const&, btree_loc_info_t const&, one_replace_t, ql::configured_limits_t const&, promise_t<superblock_t*>*, rdb_modification_report_cb_t*, bool, ql::datum_t*, profile::trace_t*, std::set<std::string, std::less<std::string>, std::allocator<std::string> >*) at ??:?\n10 [0xd134f7]: std::_Function_handler<void (), std::_Bind<void (*(auto_drainer_t::lock_t, fifo_enforcer_sink_t*, fifo_enforcer_write_token_t, btree_loc_info_t, one_replace_t, ql::configured_limits_t, promise_t<superblock_t*>*, rdb_modification_report_cb_t*, bool, ql::datum_t*, profile::trace_t*, std::set<std::string, std::less<std::string>, std::allocator<std::string> >*))(auto_drainer_t::lock_t, fifo_enforcer_sink_t*, fifo_enforcer_write_token_t const&, btree_loc_info_t const&, one_replace_t, ql::configured_limits_t const&, promise_t<superblock_t*>*, rdb_modification_report_cb_t*, bool, ql::datum_t*, profile::trace_t*, std::set<std::string, std::less<std::string>, std::allocator<std::string> >*)> >::_M_invoke(std::_Any_data const&) at ??:?\n11 [0xbc0ba2]: coro_pool_t<std::function<void ()> >::worker_run(std::function<void ()>, auto_drainer_t::lock_t) at ??:?\n12 [0xbc0f26]: callable_action_instance_t<std::_Bind<std::_Mem_fn<void (coro_pool_t<std::function<void ()> >::*)(std::function<void ()>, auto_drainer_t::lock_t)> (coro_pool_t<std::function<void ()> >*, std::function<void ()>, auto_drainer_t::lock_t)> >::run_action() at ??:?\n13 [0xf15e64]: coro_t::run() at ??:?
    2022-09-05T23:10:09.651765126 1813883.927765s error: Exiting.
    

    Never happen before.

    What could be?

    opened by dpineiden 5
  • Failed to determine absolute path for Metadata (Docker - Linux on Windows)

    Failed to determine absolute path for Metadata (Docker - Linux on Windows)

    Running RethinkDB inside a Docker container running on Windows will give the following error when we try customize the database initialization with the following command before building from image. While running it with Docker on Linux provides no Error.

    rethinkdb create
    
    • Image rethinkdb:2.4.2
    • Running on Linux 4.19.128-microsoft-standard x86_64

    Error in Docker

    rethinkdb  | Recursively removing directory rethinkdb_data/tmp
    rethinkdb  | Version: rethinkdb 2.4.2~0bullseye (GCC 10.2.1)
    rethinkdb  | error: Error in thread 8 in src/arch/io/disk.cc at line 645:
    rethinkdb  | error: Guarantee failed: [abs_res != nullptr]  (errno 2 - No such file or directory) Failed to determine absolute path for 'rethinkdb_data/metadata'
    rethinkdb  | error: Backtrace:
    rethinkdb  | error: Mon Aug 15 03:47:31 2022
    rethinkdb  |
    rethinkdb  |        1 [0x55bfa4e9cfcf]: backtrace_t::backtrace_t() at 0x55bfa4e9cfcf (rethinkdb)
    rethinkdb  |        2 [0x55bfa4e9d5c2]: lazy_backtrace_formatter_t::lazy_backtrace_formatter_t() at 0x55bfa4e9d5c2 (rethinkdb)
    rethinkdb  |        3 [0x55bfa4e9d6c8]: format_backtrace[abi:cxx11](bool) at 0x55bfa4e9d6c8 (rethinkdb)
    rethinkdb  |        4 [0x55bfa4a2e536]: report_fatal_error(char const*, int, char const*, ...) at 0x55bfa4a2e536 (rethinkdb)
    rethinkdb  |        5 [0x55bfa5165ddc]: fsync_parent_directory(char const*) at 0x55bfa5165ddc (rethinkdb)
    rethinkdb  |        6 [0x55bfa51661e3]: warn_fsync_parent_directory(char const*) at 0x55bfa51661e3 (rethinkdb)
    rethinkdb  |        7 [0x55bfa49ec211]: filepath_file_opener_t::move_serializer_file_to_permanent_location() at 0x55bfa49ec211 (rethinkdb)
    rethinkdb  |        8 [0x55bfa4baa9ad]: metadata_file_t::metadata_file_t(io_backender_t*, base_path_t const&, perfmon_collection_t*, std::function<void (metadata::write_txn_t*, signal_t*)> const&, signal_t*) at 0x55bfa4baa9ad (rethinkdb)
    rethinkdb  |        9 [0x55bfa4be8b50]: run_rethinkdb_create(base_path_t const&, name_string_t const&, std::set<name_string_t, std::less<name_string_t>, std::allocator<name_string_t> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, optional<unsigned long>, file_direct_io_mode_t, int, bool*) at 0x55bfa4be8b50 (rethinkdb)
    rethinkdb  |        10 [0x55bfa4bea97c]: std::_Function_handler<void (), std::_Bind<void (*(base_path_t, name_string_t, std::set<name_string_t, std::less<name_string_t>, std::allocator<name_string_t> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, optional<unsigned long>, file_direct_io_mode_t, int, bool*))(base_path_t const&, name_string_t const&, std::set<name_string_t, std::less<name_string_t>, std::allocator<name_string_t> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, optional<unsigned long>, file_direct_io_mode_t, int, bool*)> >::_M_invoke(std::_Any_data const&) at 0x55bfa4bea97c (rethinkdb)
    rethinkdb  |        11 [0x55bfa5151071]: starter_t::run_wrapper(std::function<void ()> const&) at 0x55bfa5151071 (rethinkdb)
    rethinkdb  |        12 [0x55bfa514ed1d]: coro_t::run() at 0x55bfa514ed1d (rethinkdb)
    rethinkdb  | error: Exiting.
    rethinkdb exited with code 133
    

    Recreating error

    Dockerfile

    FROM rethinkdb:2.4.2
    
    RUN apt-get update && apt-get install -y --no-install-recommends \
        wget && \
        apt-get autoremove -y && \
        apt-get clean
    
    
    VOLUME ["/data"]
    WORKDIR /data
    
    EXPOSE 28015 8080
    
    CMD ["rethinkdb", "create"]
    

    Docker-Compose file

    services:
      rethinkdb:
        container_name: rethinkdb
        build: ./rethinkdb
        ports:
          - 28015:28015
          - 8080:8080
        networks:
          - default
        volumes:
          - ./data/rethinkdb_data:/data/rethinkdb_data
    networks:
      default:
        name: rethinkdb
        driver: bridge
    
    • Even if the build failed on error, it will have created the rethinkdb_data/metadata file.

    Comments :

    • Is it possible issues like this happens because RethinkDB isn't fully supported for Windows Docker Containers ?
    • I assume RethinkDB will create metadata and the needed directories on initialization ? Regardless, the error will only be shown if I run it inside a Docker Container from Windows.
    opened by ibpme 0
Releases(v2.4.2)
  • v2.4.2(May 7, 2022)

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

    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.

    Source code(tar.gz)
    Source code(zip)
  • v2.4.1(Aug 14, 2020)

    Bug fix release.

    Compatibility

    No migration is required when upgrading from RethinkDB 2.4.x. Please read the RethinkDB 2.4.0 release notes if you're upgrading from an older version.

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.4.0(Dec 19, 2019)

    RethinkDB 2.4 introduces write hooks and bitwise operations besides bug fixes.

    Read the blog post 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 if you're upgrading from version 2.3.x or earlier.

    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, bit_sar 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.
    Source code(tar.gz)
    Source code(zip)
  • v2.3.6(Jul 23, 2017)

    Bug fix release

    Notes

    This is the first release of RethinkDB since October 2016. The RethinkDB project has joined the Linux Foundation. This release is brought to you by volunteers from the Open RethinkDB team. The RethinkDB source code is now licensed under an ASLv2 license.

    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/

    Source code(tar.gz)
    Source code(zip)
  • v2.3.5(Aug 29, 2016)

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.3.4(Jun 4, 2016)

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.3.3(Jun 1, 2016)

    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 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 services to include RethinkDB on Windows.

    Although RethinkDB is now stable on Windows, there are still a few remaining limitations 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.3.2(May 6, 2016)

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.3.1(Apr 23, 2016)

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.3.0(Apr 6, 2016)

    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 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 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.
    • 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.2.6(Mar 28, 2016)

    Bug fix release

    Compatibility

    Warning: Due to a bug (#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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.2.5(Feb 24, 2016)

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.2.4(Feb 1, 2016)

    This bug fix release addresses a critical bug 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).

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.6(Feb 1, 2016)

    Legacy bug fix release

    Legacy support release

    This release maintains full compatibility with RethinkDB 2.1.5, while fixing a critical bug 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.2.3-1(Jan 11, 2016)

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.2.2(Dec 21, 2015)

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.2.1(Nov 17, 2015)

    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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.2.0(Nov 12, 2015)

    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 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 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 is in active development and will be available soon.
    • Certain argument errors that used to throw ReqlDriverError exceptions now throw ReqlCompileError exceptions. See #4669 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.5-2(Oct 7, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.4(Sep 16, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.3(Sep 5, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.0.5(Sep 1, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.2(Aug 26, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.1(Aug 12, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.0-1(Aug 11, 2015)

    Release highlights:

    • Automatic failover using a Raft-based protocol
    • More flexible administration for servers and tables
    • Advanced recovery features

    Read the blog post 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 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 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)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.0-0BETA1(Jul 16, 2015)

    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 or on our mailing list.

    Release highlights:

    • Automatic failover using a Raft-based protocol
    • More flexible administration for servers and tables
    • Advanced recovery features

    Read the blog post 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

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.0.4(Jul 8, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.0.3(Jun 11, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.0.2(May 21, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
  • v2.0.1(Apr 21, 2015)

    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)
    Source code(tar.gz)
    Source code(zip)
A mini database for learning database

A mini database for learning database

Chuckie Tan 4 Nov 14, 2022
Nebula Graph is a distributed, fast open-source graph database featuring horizontal scalability and high availability

Nebula Graph is an open-source graph database capable of hosting super large scale graphs with dozens of billions of vertices (nodes) and trillions of edges, with milliseconds of latency.

vesoft inc. 833 Nov 26, 2022
TimescaleDB is an open-source database designed to make SQL scalable for time-series data.

An open-source time-series SQL database optimized for fast ingest and complex queries. Packaged as a PostgreSQL extension.

Timescale 14.1k Nov 22, 2022
PolarDB for PostgreSQL (PolarDB for short) is an open source database system based on PostgreSQL.

PolarDB for PostgreSQL (PolarDB for short) is an open source database system based on PostgreSQL. It extends PostgreSQL to become a share-nothing distributed database, which supports global data consistency and ACID across database nodes, distributed SQL processing, and data redundancy and high availability through Paxos based replication. PolarDB is designed to add values and new features to PostgreSQL in dimensions of high performance, scalability, high availability, and elasticity. At the same time, PolarDB remains SQL compatibility to single-node PostgreSQL with best effort.

Alibaba 2.5k Nov 17, 2022
DB Browser for SQLite (DB4S) is a high quality, visual, open source tool to create, design, and edit database files compatible with SQLite.

DB Browser for SQLite What it is DB Browser for SQLite (DB4S) is a high quality, visual, open source tool to create, design, and edit database files c

null 17.3k Nov 21, 2022
GridDB is a next-generation open source database that makes time series IoT and big data fast,and easy.

Overview GridDB is Database for IoT with both NoSQL interface and SQL Interface. Please refer to GridDB Features Reference for functionality. This rep

GridDB 1.9k Nov 24, 2022
ESE is an embedded / ISAM-based database engine, that provides rudimentary table and indexed access.

Extensible-Storage-Engine A Non-SQL Database Engine The Extensible Storage Engine (ESE) is one of those rare codebases having proven to have a more th

Microsoft 789 Nov 20, 2022
DuckDB is an in-process SQL OLAP Database Management System

DuckDB is an in-process SQL OLAP Database Management System

DuckDB 7.4k Nov 23, 2022
YugabyteDB is a high-performance, cloud-native distributed SQL database that aims to support all PostgreSQL features

YugabyteDB is a high-performance, cloud-native distributed SQL database that aims to support all PostgreSQL features. It is best to fit for cloud-native OLTP (i.e. real-time, business-critical) applications that need absolute data correctness and require at least one of the following: scalability, high tolerance to failures, or globally-distributed deployments.

yugabyte 7.3k Nov 24, 2022
Beryl-cli is a client for the BerylDB database server

Beryl-cli is a client for the BerylDB database server. It offers multiple commands and is designed to be fast and user-friendly.

BerylDB 11 Oct 9, 2022
A MariaDB-based command line tool to connect to OceanBase Database.

什么是 OceanBase Client OceanBase Client(简称 OBClient) 是一个基于 MariaDB 开发的客户端工具。您可以使用 OBClient 访问 OceanBase 数据库的集群。OBClient 采用 GPL 协议。 OBClient 依赖 libobclie

OceanBase 51 Nov 9, 2022
A proxy server for OceanBase Database.

OceanBase Database Proxy TODO: some badges here OceanBase Database Proxy (ODP for short) is a dedicated proxy server for OceanBase Database. OceanBase

OceanBase 78 Nov 9, 2022
OceanBase is an enterprise distributed relational database with high availability, high performance, horizontal scalability, and compatibility with SQL standards.

What is OceanBase database OceanBase Database is a native distributed relational database. It is developed entirely by Alibaba and Ant Group. OceanBas

OceanBase 5k Nov 20, 2022
SOCI - The C++ Database Access Library

Originally, SOCI was developed by Maciej Sobczak at CERN as abstraction layer for Oracle, a Simple Oracle Call Interface. Later, several database backends have been developed for SOCI, thus the long name has lost its practicality. Currently, if you like, SOCI may stand for Simple Open (Database) Call Interface or something similar.

SOCI 1.2k Nov 24, 2022
StarRocks is a next-gen sub-second MPP database for full analysis senarios, including multi-dimensional analytics, real-time analytics and ad-hoc query, formerly known as DorisDB.

StarRocks is a next-gen sub-second MPP database for full analysis senarios, including multi-dimensional analytics, real-time analytics and ad-hoc query, formerly known as DorisDB.

StarRocks 3.6k Nov 26, 2022
BaikalDB, A Distributed HTAP Database.

BaikalDB supports sequential and randomised realtime read/write of structural data in petabytes-scale. BaikalDB is compatible with MySQL protocol and it supports MySQL style SQL dialect, by which users can migrate their data storage from MySQL to BaikalDB seamlessly.

Baidu 991 Nov 19, 2022
Velox is a new C++ vectorized database acceleration library aimed to optimizing query engines and data processing systems.

Velox is a C++ database acceleration library which provides reusable, extensible, and high-performance data processing components

Facebook Incubator 1.8k Nov 27, 2022
Test any type of cloud database on Android apps. No need of a dedicated backend.

DB Kong - Database connections simplified DB Kong is an Android library that allows you to connect, interact and test any type of cloud database on An

Arjun 9 May 9, 2022
The fastest database-library on Android OS.

Android SQLite3 NDK 封装 Demo下载 (操作:按钮新增 按钮查询 点按编辑 长按删除) 写在前面 sqlite3 开源、集成简单(现在的版本只有2个文件 sqlite3.h sqlite3.c) 这个库抽离自 Telegram 的开源代码、作者:DrKLO 我个人感觉 Tele

水银灯、 2 Dec 27, 2021