* delete old small parser with nginx tested one
* functionality is not changed

If a key is updated after a secondary index scan, but before a
primary index lookup, then ignore this update.

Closes #2442

If a column is nullable and is the last defined one (via index parts
or space format), it can be omited on insertion. Such absent fields
are treated as NULLs in comparators and are not stored.

Closes #2988

This template parameter serves to detect, if two sequences of
key parts are actually parts of tuples. In such a case
key_compare_parts does additional comparison by primary key parts,
if a NULL was met.

This parameters is actually a crutch, put by me to avoid code
doubling in tuple_compare_sequential_nullable. And this parameter
complicates #2988, where a sequential nullable tuple contains
optional parts.

Needed for #2988

Closes #2048

They have no sense without key_def.h.

Needed for #2048

Update comments and move space_def_check_compatibility to
space_def.[hc].

On a single field two restrictions exist: tuple format and index part.

The proposal is to allow to use different types for different restrictions,
if these types are compatible. And for tuples validation use the most
strict type.

For example, one field can be number in space format, unsigned in one index,
integer in another index and scalar in a third index. Configuration like this
can be allowed, because all of these types can store unsigned. And unsigned is
used to validate tuples.

Besides, it allows incremental DDL. For example, now if you want to change a
type of a field, which is used by several indexes, then it is impossible on
a non-empty space, even if a new type is less strict than the old one.
Lets allow this too.

Closes #3008

At first, now if a space is not empty, its format can not be
restricted by nullability removal, or by restriction of a field type.

The workaround was format removal and reset. Lets allow normal format
restriction followed by space format checking.

At second, now an index is rebuild on any change of its key definition.
But there is no sense to rebuild it, if uniqueness is turned off, part
field numbers and collations are not changed, because it means, that
only types was restricted or extended. So format checking is enough.

Needed for #3008

Compatibility must be commutative, but this function is not
commutative. It checks, that one type can store values of another
type, but not conversely.

Closes #2973

Not all workloads need bloom filters enabled for all indexes. Let's
allow to disable them on per-index basis by setting bloom_fpr to 1.
This will allow to save some memory if bloom filters are unused.

Closes #3138

Currently, one can set insane values for most vinyl index options, which
will most certainly result in a crash (e.g. bloom_fpr = 100). Add some
sanity checks.

While a node of the cluster is re-bootstrapping (joining again),
other nodes may try to re-subscribe to it. They will fail, because
the rebootstrapped node hasn't tried to subscribe hence hasn't been
added to the _cluster table yet and so is not present in the hash
at the subscriber's side for replica_on_applier_reconnect() to look
it up.

Fix this by making a subscriber create an id-less (REPLICA_ID_NIL)
struct replica in this case and reattach the applier to it. It will
be assigned an id when it finally subscribes and is registered in
_cluster.

Fixes 71b33405 replication: reconnect applier on master rebootstrap

If box.cfg() successfully connects to a number of replicas sufficient to
form a quorum (>= box.cfg.replication_connect_quorum), it won't return
until it syncs with all of them (lag <= box.cfg.replication_sync_lag).
If one of the replicas forming a quorum disconnects permanently while
sync is in progress, box.cfg() will hang forever.

Such a behavior is rather unreasonable. After all, syncing a quorum is
best-effort. It would be much more sensible to return from box.cfg()
leaving the instance in the 'orphan' mode in this case. This patch does
exactly that: now if we detect that not enough replicas are connected to
form a quorum while we are syncing we stop syncing immediately.

Currently, the max time box.cfg() may wait for connection to replicas to
be established is hardcoded to box.cfg.replication_timeout times 4. As
a result, users can't revert to pre replication_connect_quorum behavior,
when box.cfg() blocks until it connects to all replicas. To fix that,
let's introduce a new configuration option, replication_connect_timeout,
which determines the replication configuration timeout. By default the
option is set to 4 seconds.

Closes #3151

If a unique index includes all parts of another unique index, we can
skip the check for duplicates for it on INSERT. Let's mark all such
indexes with a special flag on CREATE/ALTER and optimize out the check
if the flag is set. If there are two indexes that index the same set
of fields, check uniqueness for the one with a lower id, because it
is likelier to have have a "warmer" cache.

Closes #3154

We keep run files corresponding to (at least) the last snapshot, because
we need them for backups and replication. Deletion of compacted run
files is postponed until the next snapshot. As a consequence, we don't
delete run files created on a replica during the join stage. However, in
contrast to run files created during normal operation, these are pure
garbage and should be deleted right away. Not deleting them can result
in depletion of disk space, because vinyl has quite high write
amplification by design.

We can't write a functional test for this, because there's no way to
guarantee that compaction started during join will finish before join
completion - if it doesn't, compacted runs won't be removed, because
they will be assigned to the snapshot created by join.

Closes #3162

Vinyl index key definition is stored in vylog even if an index is
empty, and we while do not have a method to update it. So vinyl
index key definition alter is forbidden even on an empty space.

Closes #3169

Closes #3173

If any ddl operation is in progress then all other ddls are
waiting on schema latch. But after first ddl will be done any
other request may be issued just after it and commit order will be
broken in case of multimaster replication.  To prevent this
behavior any ddl operation should wait until all queued ddls are
done.

Fixes #2951

Prevent latch lock interception by other already scheduled or active
fiber if there is only one waiting. This is needed for strict latch
ordering.

Incomming ACK lead to race condition and prevent heartbeat
messages. It ends up with disconnect on timeout.
This fix is based on @locker proposal to send vclock only
to reply master (since it itself sends heartbeat messages).

Closes #3160

This reverts commit a7871247.

This reverts commit 99c7a971.

If a vinyl transaction stalls waiting for quota for more than
box.cfg.too_long_threshold seconds, emit a warning to the log:

  W> waited for 699089 bytes of vinyl memory quota for too long: 0.504 sec

This will help us understand whether our users experience lags
due to absence of throttling in vinyl (see #1862).

Closes #3096

The name of the universe is optional, so we don't check it. If a user
wants to specify extra options in the grant, such as if_not_exists, and
mistakes object name argument with options argument, options are
silently ignored:

  box.schema.user.grant('tnt', 'read,write,execute', 'universe', {if_not_exists = true})

Fix this by adding Lua code that ensures that universe name is a scalar
(string or nil).

Closes #3146

In replication schema if one of the instances was powered off, it isn't
detected by others and the connection hangs. Alive machines show
'follow' state. Add timeout to solve this issue. It's safe since
applier and relay both send messages every replication_timeout so we can
assume that if we read nothing we have problem with connection. Use
replication_disconnect_timeout which is replication_timeout * 4 as for
now.

The test fixed and comments improved by @locker.

Closes #3025

If an instance is 'orphan', it is read-only hence box.ctl.wait_rw()
should block until the instance syncs, but currently it doesn't. Fix it.

vy_log_rotate() releases the log latch between reading the last vylog
file and writing the new vylog file. This works as long as the latch
implementation guarantees that latch_lock() called immediately after
latch_unlock() on the same lock doesn't yield. Although this is true
now, we shouldn't rely on that, because this may change any time.

Closes #2789

* Create constant SUPER - id of super role
* Forward the constant to box.schema
* Add checks on drop super role

Closes #3084

 - space.bsize returns the size of user data stored in the space.
   It is the sum of memory.bytes and disk.bytes as reported by
   the primary index.

 - index.bsize returns the size of memory used for indexing data.
   It is the sum of memory.index_size, disk.index_size, and
   disk.bloom_size as reported by index.info. For secondary indexes
   we also add the size of binary data stored on disk (disk.bytes),
   because it is only needed to build the index.

 - index.len returns the total number of rows stored in the index.
   It is the sum of memory.rows and disk.rows as reported by
   index.info. Note, it may be greater than the number of tuples
   stored in the space, because it includes DELETE and UPDATE
   statements.

Closes #2863
Closes #3056

This patch adds the following statistics to index.info:

 - memory.index_size - size of memory tree extents
 - cache.index_size - size of cache tree extents
 - disk.index_size - size of page index
 - disk.bloom_size - size of bloom filters

This patch adds a new connection option to http client, 'unix_socket'.
The option specifies the path to the unix socket to use as connection
endpoint instead of TCP:

  httpc = require('http.client')
  httpc.request('GET', 'http://localhost/index.html', nil,
                {unix_socket = '/var/run/docker.sock'})

The option is supported only if tarantool was built with libcurl 7.40.0
or newer. For older versions, an attempt to use the option will result
in a Lua exception.

Suggested and first implemented by @rosik.
The test was refactored by @locker.

Closes #3040

It will help resolve box.once() conflicts in case master is rw
and replica is ro.

Closes #2537

This patch adds two new Lua function, box.ctl.wait_ro() and
box.ctl.wait_rw(), that block the current fiber until the
server switches to read-only or read-write mode, respectively.
Both functions take the timeout as an optional argument.

Needed for #2537

  src/lua/init.c: In function ‘tarantool_panic_handler’:
  src/lua/init.c:321:2: error: implicit declaration of function ‘print_backtrace’ [-Werror=implicit-function-declaration]
    print_backtrace();
    ^~~~~~~~~~~~~~~

  src/lua/fiber.c:244:1: error: ‘lbox_fiber_statof_bt’ defined but not used [-Werror=unused-function]
   lbox_fiber_statof_bt(struct fiber *f, void *cb_ctx)
   ^~~~~~~~~~~~~~~~~~~~