Tarantool 2.10.0-beta1

The UUID field type is now part of the SCALAR field type (gh-6042).

The UUID field type is now available in SQL. A new UUID can be generated using the new SQL built-in function UUID() (gh-5886).

[Breaking change] The timeout() method of the net.box connection, marked deprecated more than four years ago (in 1.7.4), has been dropped. It negatively affected the performance of hot net.box methods, such as call() and select() if they were called without a specified timeout (gh-6242).

Improved net.box performance by up to 70% by rewriting hot code paths in C (gh-6241).

Introduced compact tuples that allow saving 4 bytes per tuple in case of small userdata (gh-5385).

Now streams and interactive transactions over streams are implemented in iproto. Every stream is associated with its ID, which is unique within one connection. All requests with the same non-zero stream ID belong to the same stream. All requests in the stream are processed synchronously. The next request will not start executing until the previous one is completed. If a request’s stream ID is 0, it does not belong to any stream and is processed in the old way.

In net.box, a stream is an object above the connection that has the same methods but allows executing requests sequentially. The ID is generated on the client side automatically. If a user writes his own connector and wants to use streams, they must transmit the stream_id over the iproto protocol.

The primary purpose of streams is transactions via iproto. As each stream can start a transaction, several transactions can be multiplexed over one connection. There are multiple ways to begin, commit, and rollback a transaction. One can do that using the appropriate stream methods, call, eval, or execute with the SQL transaction syntax. Users can mix these methods. For example, one might start a transaction using stream:begin(), and commit it with stream:call('box.commit') or stream:execute('COMMIT'). If any request fails during the transaction, it will not affect the other requests in the transaction. If a disconnect occurs while there is an active transaction in the stream, that transaction will be rolled back if it hasn’t been committed before the connection failure.

Added the new memtx_allocator option to box.cfg{}. It allows selecting an appropriate allocator for memtx tuples if necessary. The possible values are system for the malloc allocator and small for the default small allocator.

Implemented the system allocator based on malloc. The slab allocator, which is used for tuple allocation, has a particular disadvantage—it is prone to unresolvable fragmentation on specific workloads (size migration). In this case, the user should be able to choose another allocator. The system allocator is based on the malloc function but restricted by the same quota as the slab allocator. The system allocator does not alloc all the memory at the start. Instead, it allocates memory as needed, checking that the quota is not exceeded (gh-5419).

The log module now supports symbolic representation of log levels. Now it is possible to specify levels the same way as in the box.cfg{} call (gh-5882).

For example, instead of

require('log').cfg{level = 6}

it is possible to use

require('log').cfg{level = 'verbose'}

Descriptions of type mismatch error and inconsistent type error have become more informative (gh-6176).

Removed explicit cast from BOOLEAN to numeric types and vice versa (gh-4770).

For example, CAST(FALSE AS INTEGER) was 0 in version 2.8. Now it causes an error.

Removed explicit cast from VARBINARY to numeric types and vice versa (gh-4772, gh-5852).

Fixed a bug where a string that is not NULL-terminated could not be cast to BOOLEAN, even if the conversion would be successful according to the rules.

Now a numeric value can be cast to another numeric type only if the cast is precise. In addition, a UUID value cannot be implicitly cast to STRING/VARBINARY. Also, a STRING/VARBINARY value cannot be implicitly cast to a UUID (gh-4470).

Now any number can be compared to any other number, and values of any scalar type can be compared to any other value of the same type. A value of a non-numeric scalar type cannot be compared with a value of any other scalar type (gh-4230).

Removed SQL built-in functions from the _func system space (gh-6106).

The function is now looked up first in SQL built-in functions and then in user-defined functions.

Fixed incorrect error message in case of misuse of the function setting the default value.

The TYPEOF() function with NULL as an argument now returns NULL if the type cannot be determined from context. (gh-5956). Also, TYPEOF(-NaN) will now return DOUBLE, and TYPEOF(map_column) will now return VARBINARY instead of map.

For example, SELECT TYPEOF(NULL) was BOOLEAN in version 2.8. Now it is NULL.

Reworked the SCALAR and NUMBER types in SQL. Removed the implicit cast from SCALAR to any other scalar type. Also, removed the implicit cast from NUMBER values to any other numeric type. It means that arithmetic and bitwise operations and concatenation are no longer allowed for SCALAR and NUMBER values. In addition, any SCALAR value can now be compared with values of any other scalar type using the SCALAR rules (gh-6221).

The field type DECIMAL is now available in SQL. Added an implicit cast from INTEGER and DOUBLE to DECIMAL and vice versa. DECIMAL can participate in arithmetic operations and comparisons with other defined numeric types (gh-4415).

[Breaking change] The argument types of SQL built-in functions are now checked in most cases during parsing. In addition, the number of arguments is now always checked during parsing (gh-6105).

[Breaking change] for the NUMBER data type. Arithmetic (+ * - / % & | ~) operations and bit-shift operations (>> <<) are now illegal.

For example, SELECT number_column + 1 was legal in version 2.8. Now it causes an error.

[Breaking change] for the SCALAR data type. Arithmetic (+ * - / % & | ~) operations and bit-shift operations (>> <<) are now illegal. Concatenation (||) operations are now illegal. Values in SCALAR columns now have data type SCALAR, not the value’s data type.

For example, TYPEOF(CAST(1 AS SCALAR)) was INTEGER in version 2.8. Now it is SCALAR.

[Breaking change]: Arithmetic operators must now have numeric operands. String operands are illegal.

For example, SELECT 1 + '1' was 2 in version 2.8. Now it causes an error.

[Breaking change] in operations on SCALAR columns. Since the type of a value no longer determines whether an operation is valid, comparisons and functions that require a specific type no longer work.

For example, table T has only one row with a scalar column containing 'a'. UPPER(scalar_column) was 'A' in version 2.8. Now it causes an error.

[Breaking change] for the HEX() function. STRING arguments are no longer acceptable; only VARBINARY arguments are allowed.

For example, HEX('a') was '41' in version 2.8. Now it causes an error.

[Breaking change] for the POSITION() function. VARBINARY arguments are no longer acceptable; only STRING arguments are allowed.

For example, POSITION(X'41',X'41') was 1 in version 2.8. Now it causes an error.

[Breaking change] fiber.wakeup() in Lua and fiber_wakeup() in C became NOP on the currently running fiber. Previously they allowed ignoring the next yield or sleep, which resulted in unexpected erroneous wake-ups. Calling these functions right before fiber.create() in Lua or fiber_start() in C could lead to a crash (in debug build) or undefined behaviour (in release build) (gh-6043).

There was a single use case for the previous behaviour: rescheduling in the same event loop iteration, which is not the same as fiber.sleep(0) in Lua and fiber_sleep(0) in C. It could be done in the following way:

in C:

fiber_wakeup(fiber_self());
fiber_yield();

and in Lua:

fiber.self():wakeup()
fiber.yield()

To get the same effect in C, one can now use fiber_reschedule(). In Lua, it is now impossible to reschedule the current fiber directly in the same event loop iteration. One can reschedule self through a second fiber, but it is strongly discouraged:

-- do not use this code
local self = fiber.self()
fiber.new(function() self:wakeup() end)
fiber.sleep(0)

Fixed memory leak on box.on_commit() and box.on_rollback() (gh-6025).

fiber_join() now checks if the argument is a joinable fiber. The absence of this check could lead to unpredictable results. Note that the change affects the C level only; in the Lua interface, fiber:join() protection is already enabled.

Now Tarantool yields when it scans .xlog files for the latest applied vclock and finds the right place to start recovering from. It means that the instance becomes responsive right after the box.cfg call even if an empty .xlog was not created on the previous exit.

This fix also prevents the relay from timing out when a freshly subscribed replica needs rows from the end of a relatively long (hundreds of MBs) .xlog file (gh-5979).

The counter in N rows processed log messages no longer resets on each newly recovered xlog.

Fixed wrong type specification when printing fiber state change. It could lead to negative fiber IDs in the logs (gh-5846).

For example,

main/-244760339/cartridge.failover.task I> Instance state changed

instead of proper

main/4050206957/cartridge.failover.task I> Instance state changed

Fiber IDs are now switched to monotonically increasing unsigned 8-byte integers, so there is no ID wrapping anymore. It allows detecting fiber precedence by ID (gh-5846).

Fixed a crash in JSON update on tuple/space, where the update included two or more operations that accessed fields in reversed order and these fields didn’t exist. Example: box.tuple.new({1}):update({{'=', 4, 4}, {'=', 3, 3}}) (gh-6069).

Fixed invalid results of the json module’s encode function when it was used from the Lua garbage collector. For example, this could happen in functions used as ffi.gc() (gh-6050).

Added a check for user input of the number of iproto threads: value must be greater than zero and less than or equal to 1000 (gh-6005).

Changing a listed address can no longer cause iproto threads to close the same socket several times.

Simultaneously updating a key in different transactions does not longer result in a MVCC crash (gh-6131).

Fixed a bug where memtx MVCC crashed during reading uncommitted DDL (gh-5515).

Fixed a bug where memtx MVCC crashed if an index was created in the transaction thread (gh-6137).

Fixed a MVCC segmentation fault that arose when updating the entire space concurrently (gh-5892).

Fixed a bug with failed assertion after a stress update of the same key (gh-6193).

Fixed a crash where box.snapshot could be called during an incomplete transaction (gh-6229).

Fixed console client connection failure in case of request timeout (gh-6249).

Added a missing broadcast to net.box.future:discard() so that now fibers waiting for a request result wake up when the request is discarded (gh-6250).

box.info.uuid, box.info.cluster.uuid, and tostring(decimal) with any decimal number in Lua could sometimes return garbage if there were __gc handlers in the user’s code (gh-6259).

Fixed an error message that appeared in a particular case during MVCC operation (gh-6247).

Fixed a repeatable read violation after delete (gh-6206).

Fixed a bug where the MVCC engine didn’t track the select{} hash (gh-6040).

Fixed a crash in MVCC after a drop of space with several indexes (gh-6274).

Fixed a bug where the GC could leave tuples in secondary indexes (gh-6234).

Disallow yields after DDL operations in MVCC mode. It fixes a crash that took place when several transactions referred to system spaces (gh-5998).

Fixed a bug in MVCC that happened on rollback after a DDL operation (gh-5998).

Fixed a bug where rollback resulted in unserializable behavior (gh-6325).