[PATCH] Use MULTIKEY_NONE instead of -1

[Vladimir Davydov <vdavydov.dev@gmail.com>]

Solely to improve code readability. No functional changes.
Suggested by @kostja.
---
 src/box/field_map.h          | 21 ++++++++++++++-------
 src/box/index.cc             |  3 ++-
 src/box/lua/key_def.c        |  2 +-
 src/box/memtx_bitset.c       |  2 +-
 src/box/memtx_rtree.c        |  2 +-
 src/box/memtx_space.c        |  3 ++-
 src/box/request.c            |  7 ++++---
 src/box/space.c              |  3 ++-
 src/box/sql.c                | 20 ++++++++++----------
 src/box/tuple.c              |  8 +++++---
 src/box/tuple.h              |  2 +-
 src/box/tuple_bloom.c        |  4 ++--
 src/box/tuple_compare.cc     | 21 ++++++++++++++-------
 src/box/tuple_extract_key.cc | 13 ++++++++-----
 src/box/tuple_format.c       |  2 +-
 src/box/tuple_hash.cc        | 11 +++++++----
 src/box/vinyl.c              |  9 ++++++---
 src/box/vy_run.c             |  3 ++-
 src/box/vy_stmt.c            |  3 ++-
 src/box/vy_stmt.h            |  4 ++--
 20 files changed, 87 insertions(+), 56 deletions(-)

diff --git a/src/box/field_map.h b/src/box/field_map.h
index 0fd35c3e..b0dfeb4e 100644
--- a/src/box/field_map.h
+++ b/src/box/field_map.h
@@ -38,6 +38,12 @@ struct region;
 struct field_map_builder_slot;
 
 /**
+ * A special value of multikey index that means that the key
+ * definition is not multikey and no indirection is expected.
+ */
+enum { MULTIKEY_NONE = -1 };
+
+/**
  * A field map is a special area is reserved before tuple's
  * MessagePack data. It is a sequence of the 32-bit unsigned
  * offsets of tuple's indexed fields.
@@ -146,7 +152,7 @@ field_map_get_offset(const uint32_t *field_map, int32_t offset_slot,
 		     int multikey_idx)
 {
 	uint32_t offset;
-	if (multikey_idx >= 0 && field_map[offset_slot] > 0) {
+	if (multikey_idx != MULTIKEY_NONE && field_map[offset_slot] > 0) {
 		assert((int32_t)field_map[offset_slot] < 0);
 		/**
 		 * The field_map extent has the following
@@ -192,10 +198,10 @@ field_map_builder_slot_extent_new(struct field_map_builder *builder,
 /**
  * Set data offset for a field identified by unique offset_slot.
  *
- * When multikey_idx > 0 this routine initialize corresponding
- * field_map_builder_slot_extent is identified by multikey_idx
- * and multikey_count. Performs allocation on region when
- * required.
+ * When multikey_idx != MULTIKEY_NONE this routine initializes
+ * corresponding field_map_builder_slot_extent identified by
+ * multikey_idx and multikey_count. Performs allocation on region
+ * when required.
  *
  * The offset_slot argument must be negative and offset must be
  * positive (by definition).
@@ -209,10 +215,11 @@ field_map_builder_set_slot(struct field_map_builder *builder,
 	assert(offset_slot < 0);
 	assert((uint32_t)-offset_slot <= builder->slot_count);
 	assert(offset > 0);
-	assert(multikey_idx < (int32_t)multikey_count);
-	if (multikey_idx == -1) {
+	if (multikey_idx == MULTIKEY_NONE) {
 		builder->slots[offset_slot].offset = offset;
 	} else {
+		assert(multikey_idx >= 0);
+		assert(multikey_idx < (int32_t)multikey_count);
 		struct field_map_builder_slot_extent *extent;
 		if (builder->slots[offset_slot].has_extent) {
 			extent = builder->slots[offset_slot].extent;
diff --git a/src/box/index.cc b/src/box/index.cc
index 39b0ee46..4a444e5d 100644
--- a/src/box/index.cc
+++ b/src/box/index.cc
@@ -156,7 +156,8 @@ box_tuple_extract_key(box_tuple_t *tuple, uint32_t space_id, uint32_t index_id,
 	struct index *index = index_find(space, index_id);
 	if (index == NULL)
 		return NULL;
-	return tuple_extract_key(tuple, index->def->key_def, -1, key_size);
+	return tuple_extract_key(tuple, index->def->key_def,
+				 MULTIKEY_NONE, key_size);
 }
 
 static inline int
diff --git a/src/box/lua/key_def.c b/src/box/lua/key_def.c
index 28d40478..dfcc8944 100644
--- a/src/box/lua/key_def.c
+++ b/src/box/lua/key_def.c
@@ -265,7 +265,7 @@ lbox_key_def_extract_key(struct lua_State *L)
 	struct region *region = &fiber()->gc;
 	size_t region_svp = region_used(region);
 	uint32_t key_size;
-	char *key = tuple_extract_key(tuple, key_def, -1, &key_size);
+	char *key = tuple_extract_key(tuple, key_def, MULTIKEY_NONE, &key_size);
 	tuple_unref(tuple);
 	if (key == NULL)
 		return luaT_error(L);
diff --git a/src/box/memtx_bitset.c b/src/box/memtx_bitset.c
index 275e736d..8c626684 100644
--- a/src/box/memtx_bitset.c
+++ b/src/box/memtx_bitset.c
@@ -302,7 +302,7 @@ memtx_bitset_index_replace(struct index *base, struct tuple *old_tuple,
 
 	if (new_tuple != NULL) {
 		const char *field = tuple_field_by_part(new_tuple,
-					base->def->key_def->parts, -1);
+				base->def->key_def->parts, MULTIKEY_NONE);
 		uint32_t key_len;
 		const void *key = make_key(field, &key_len);
 #ifndef OLD_GOOD_BITSET
diff --git a/src/box/memtx_rtree.c b/src/box/memtx_rtree.c
index 19cb69a1..45e8fb8e 100644
--- a/src/box/memtx_rtree.c
+++ b/src/box/memtx_rtree.c
@@ -122,7 +122,7 @@ extract_rectangle(struct rtree_rect *rect, struct tuple *tuple,
 	assert(index_def->key_def->part_count == 1);
 	assert(!key_def_is_multikey(index_def->key_def));
 	const char *elems = tuple_field_by_part(tuple,
-				index_def->key_def->parts, -1);
+				index_def->key_def->parts, MULTIKEY_NONE);
 	unsigned dimension = index_def->opts.dimension;
 	uint32_t count = mp_decode_array(&elems);
 	return mp_decode_rect(rect, dimension, elems, count, "Field");
diff --git a/src/box/memtx_space.c b/src/box/memtx_space.c
index 265bf923..5ddb4f7e 100644
--- a/src/box/memtx_space.c
+++ b/src/box/memtx_space.c
@@ -445,7 +445,8 @@ memtx_space_execute_upsert(struct space *space, struct txn *txn,
 	/* Extract the primary key from tuple. */
 	const char *key = tuple_extract_key_raw(request->tuple,
 						request->tuple_end,
-						index->def->key_def, -1, NULL);
+						index->def->key_def,
+						MULTIKEY_NONE, NULL);
 	if (key == NULL)
 		return -1;
 	/* Cut array header */
diff --git a/src/box/request.c b/src/box/request.c
index 8b84260a..44a43ee1 100644
--- a/src/box/request.c
+++ b/src/box/request.c
@@ -92,7 +92,8 @@ request_create_from_tuple(struct request *request, struct space *space,
 		uint32_t size, key_size;
 		const char *data = tuple_data_range(old_tuple, &size);
 		request->key = tuple_extract_key_raw(data, data + size,
-				space->index[0]->def->key_def, -1, &key_size);
+				space->index[0]->def->key_def, MULTIKEY_NONE,
+				&key_size);
 		if (request->key == NULL)
 			return -1;
 		request->key_end = request->key + key_size;
@@ -125,8 +126,8 @@ request_rebind_to_primary_key(struct request *request, struct space *space,
 	struct index *pk = space_index(space, 0);
 	assert(pk != NULL);
 	uint32_t key_len;
-	char *key = tuple_extract_key(found_tuple, pk->def->key_def, -1,
-				      &key_len);
+	char *key = tuple_extract_key(found_tuple, pk->def->key_def,
+				      MULTIKEY_NONE, &key_len);
 	assert(key != NULL);
 	request->key = key;
 	request->key_end = key + key_len;
diff --git a/src/box/space.c b/src/box/space.c
index 9a266604..243e7da2 100644
--- a/src/box/space.c
+++ b/src/box/space.c
@@ -320,7 +320,8 @@ space_before_replace(struct space *space, struct txn *txn,
 			break;
 		index = pk;
 		key = tuple_extract_key_raw(request->tuple, request->tuple_end,
-					    index->def->key_def, -1, NULL);
+					    index->def->key_def, MULTIKEY_NONE,
+					    NULL);
 		if (key == NULL)
 			return -1;
 		part_count = mp_decode_array(&key);
diff --git a/src/box/sql.c b/src/box/sql.c
index c3f404ee..fbfa5999 100644
--- a/src/box/sql.c
+++ b/src/box/sql.c
@@ -480,8 +480,8 @@ int tarantoolsqlEphemeralDelete(BtCursor *pCur)
 	char *key;
 	uint32_t key_size;
 	key = tuple_extract_key(pCur->last_tuple,
-				pCur->iter->index->def->key_def, -1,
-				&key_size);
+				pCur->iter->index->def->key_def,
+				MULTIKEY_NONE, &key_size);
 	if (key == NULL)
 		return SQL_TARANTOOL_DELETE_FAIL;
 
@@ -506,8 +506,8 @@ int tarantoolsqlDelete(BtCursor *pCur, u8 flags)
 	int rc;
 
 	key = tuple_extract_key(pCur->last_tuple,
-				pCur->iter->index->def->key_def, -1,
-				&key_size);
+				pCur->iter->index->def->key_def,
+				MULTIKEY_NONE, &key_size);
 	if (key == NULL)
 		return SQL_TARANTOOL_DELETE_FAIL;
 	rc = sql_delete_by_key(pCur->space, pCur->index->def->iid, key,
@@ -561,8 +561,8 @@ int tarantoolsqlEphemeralClearTable(BtCursor *pCur)
 	uint32_t  key_size;
 
 	while (iterator_next(it, &tuple) == 0 && tuple != NULL) {
-		key = tuple_extract_key(tuple, it->index->def->key_def, -1,
-					&key_size);
+		key = tuple_extract_key(tuple, it->index->def->key_def,
+					MULTIKEY_NONE, &key_size);
 		if (space_ephemeral_delete(pCur->space, key) != 0) {
 			iterator_delete(it);
 			return SQL_TARANTOOL_DELETE_FAIL;
@@ -594,8 +594,8 @@ int tarantoolsqlClearTable(struct space *space, uint32_t *tuple_count)
 	if (iter == NULL)
 		return SQL_TARANTOOL_ITERATOR_FAIL;
 	while (iterator_next(iter, &tuple) == 0 && tuple != NULL) {
-		request.key = tuple_extract_key(tuple, pk->def->key_def, -1,
-						&key_size);
+		request.key = tuple_extract_key(tuple, pk->def->key_def,
+						MULTIKEY_NONE, &key_size);
 		request.key_end = request.key + key_size;
 		rc = box_process_rw(&request, space, &unused);
 		if (rc != 0) {
@@ -783,7 +783,7 @@ tarantoolsqlIdxKeyCompare(struct BtCursor *cursor,
 				uint32_t field_offset =
 					field_map_get_offset(field_map,
 							     field->offset_slot,
-							     -1);
+							     MULTIKEY_NONE);
 				p = base + field_offset;
 			}
 		}
@@ -801,7 +801,7 @@ out:
 #ifndef NDEBUG
 	/* Sanity check. */
 	original_size = region_used(&fiber()->gc);
-	key = tuple_extract_key(tuple, key_def, -1, &key_size);
+	key = tuple_extract_key(tuple, key_def, MULTIKEY_NONE, &key_size);
 	if (key != NULL) {
 		int new_rc = sqlVdbeRecordCompareMsgpack(key, unpacked);
 		region_truncate(&fiber()->gc, original_size);
diff --git a/src/box/tuple.c b/src/box/tuple.c
index fe815a64..45c6727a 100644
--- a/src/box/tuple.c
+++ b/src/box/tuple.c
@@ -462,7 +462,7 @@ tuple_go_to_path(const char **data, const char *path, uint32_t path_len,
 	while ((rc = json_lexer_next_token(&lexer, &token)) == 0) {
 		switch (token.type) {
 		case JSON_TOKEN_ANY:
-			if (multikey_idx < 0)
+			if (multikey_idx == MULTIKEY_NONE)
 				return -1;
 			token.num = multikey_idx;
 			FALLTHROUGH;
@@ -535,7 +535,8 @@ tuple_field_raw_by_full_path(struct tuple_format *format, const char *tuple,
 	}
 	return tuple_field_raw_by_path(format, tuple, field_map, fieldno,
 				       path + lexer.offset,
-				       path_len - lexer.offset, NULL, -1);
+				       path_len - lexer.offset,
+				       NULL, MULTIKEY_NONE);
 }
 
 uint32_t
@@ -548,7 +549,8 @@ tuple_raw_multikey_count(struct tuple_format *format, const char *data,
 		tuple_field_raw_by_path(format, data, field_map,
 					key_def->multikey_fieldno,
 					key_def->multikey_path,
-					key_def->multikey_path_len, NULL, -1);
+					key_def->multikey_path_len,
+					NULL, MULTIKEY_NONE);
 	if (array_raw == NULL)
 		return 0;
 	assert(mp_typeof(*array_raw) == MP_ARRAY);
diff --git a/src/box/tuple.h b/src/box/tuple.h
index 2a46f371..4acda789 100644
--- a/src/box/tuple.h
+++ b/src/box/tuple.h
@@ -604,7 +604,7 @@ tuple_field_raw(struct tuple_format *format, const char *tuple,
 		const uint32_t *field_map, uint32_t field_no)
 {
 	return tuple_field_raw_by_path(format, tuple, field_map, field_no,
-				       NULL, 0, NULL, -1);
+				       NULL, 0, NULL, MULTIKEY_NONE);
 }
 
 /**
diff --git a/src/box/tuple_bloom.c b/src/box/tuple_bloom.c
index 99f19a2e..8b74da22 100644
--- a/src/box/tuple_bloom.c
+++ b/src/box/tuple_bloom.c
@@ -109,7 +109,7 @@ tuple_bloom_builder_add(struct tuple_bloom_builder *builder,
 			int multikey_idx)
 {
 	assert(builder->part_count == key_def->part_count);
-	assert(!key_def_is_multikey(key_def) || multikey_idx >= 0);
+	assert(!key_def_is_multikey(key_def) || multikey_idx != MULTIKEY_NONE);
 
 	uint32_t h = HASH_SEED;
 	uint32_t carry = 0;
@@ -204,7 +204,7 @@ bool
 tuple_bloom_maybe_has(const struct tuple_bloom *bloom, struct tuple *tuple,
 		      struct key_def *key_def, int multikey_idx)
 {
-	assert(!key_def_is_multikey(key_def) || multikey_idx >= 0);
+	assert(!key_def_is_multikey(key_def) || multikey_idx != MULTIKEY_NONE);
 
 	if (bloom->is_legacy) {
 		return bloom_maybe_has(&bloom->parts[0],
diff --git a/src/box/tuple_compare.cc b/src/box/tuple_compare.cc
index 0aa032af..c1a70a08 100644
--- a/src/box/tuple_compare.cc
+++ b/src/box/tuple_compare.cc
@@ -512,9 +512,11 @@ tuple_compare_slowpath(struct tuple *tuple_a, hint_t tuple_a_hint,
 							  (int)tuple_b_hint);
 		} else if (has_json_paths) {
 			field_a = tuple_field_raw_by_part(format_a, tuple_a_raw,
-							  field_map_a, part, -1);
+							  field_map_a, part,
+							  MULTIKEY_NONE);
 			field_b = tuple_field_raw_by_part(format_b, tuple_b_raw,
-							  field_map_b, part, -1);
+							  field_map_b, part,
+							  MULTIKEY_NONE);
 		} else {
 			field_a = tuple_field_raw(format_a, tuple_a_raw,
 						  field_map_a, part->fieldno);
@@ -576,9 +578,11 @@ tuple_compare_slowpath(struct tuple *tuple_a, hint_t tuple_a_hint,
 							  (int)tuple_b_hint);
 		} else if (has_json_paths) {
 			field_a = tuple_field_raw_by_part(format_a, tuple_a_raw,
-							  field_map_a, part, -1);
+							  field_map_a, part,
+							  MULTIKEY_NONE);
 			field_b = tuple_field_raw_by_part(format_b, tuple_b_raw,
-							  field_map_b, part, -1);
+							  field_map_b, part,
+							  MULTIKEY_NONE);
 		} else {
 			field_a = tuple_field_raw(format_a, tuple_a_raw,
 						  field_map_a, part->fieldno);
@@ -630,7 +634,8 @@ tuple_compare_with_key_slowpath(struct tuple *tuple, hint_t tuple_hint,
 							(int)tuple_hint);
 		} else if (has_json_paths) {
 			field = tuple_field_raw_by_part(format, tuple_raw,
-							field_map, part, -1);
+							field_map, part,
+							MULTIKEY_NONE);
 		} else {
 			field = tuple_field_raw(format, tuple_raw, field_map,
 						part->fieldno);
@@ -664,7 +669,8 @@ tuple_compare_with_key_slowpath(struct tuple *tuple, hint_t tuple_hint,
 							(int)tuple_hint);
 		} else if (has_json_paths) {
 			field = tuple_field_raw_by_part(format, tuple_raw,
-							field_map, part, -1);
+							field_map, part,
+							MULTIKEY_NONE);
 		} else {
 			field = tuple_field_raw(format, tuple_raw, field_map,
 						part->fieldno);
@@ -1564,7 +1570,8 @@ static hint_t
 tuple_hint(struct tuple *tuple, struct key_def *key_def)
 {
 	assert(!key_def_is_multikey(key_def));
-	const char *field = tuple_field_by_part(tuple, key_def->parts, -1);
+	const char *field = tuple_field_by_part(tuple, key_def->parts,
+						MULTIKEY_NONE);
 	if (is_nullable && field == NULL)
 		return hint_nil();
 	return field_hint<type, is_nullable>(field, key_def->parts->coll);
diff --git a/src/box/tuple_extract_key.cc b/src/box/tuple_extract_key.cc
index 15e43aae..3bd3cde7 100644
--- a/src/box/tuple_extract_key.cc
+++ b/src/box/tuple_extract_key.cc
@@ -119,7 +119,7 @@ tuple_extract_key_slowpath(struct tuple *tuple, struct key_def *key_def,
 	assert(contains_sequential_parts ==
 	       key_def_contains_sequential_parts(key_def));
 	assert(is_multikey == key_def_is_multikey(key_def));
-	assert(!key_def_is_multikey(key_def) || multikey_idx >= 0);
+	assert(!key_def_is_multikey(key_def) || multikey_idx != MULTIKEY_NONE);
 	assert(mp_sizeof_nil() == 1);
 	const char *data = tuple_data(tuple);
 	uint32_t part_count = key_def->part_count;
@@ -136,7 +136,8 @@ tuple_extract_key_slowpath(struct tuple *tuple, struct key_def *key_def,
 						key_def->parts[i].fieldno);
 		} else if (!is_multikey) {
 			field = tuple_field_raw_by_part(format, data, field_map,
-							&key_def->parts[i], -1);
+							&key_def->parts[i],
+							MULTIKEY_NONE);
 		} else {
 			field = tuple_field_raw_by_part(format, data, field_map,
 							&key_def->parts[i],
@@ -187,7 +188,8 @@ tuple_extract_key_slowpath(struct tuple *tuple, struct key_def *key_def,
 						key_def->parts[i].fieldno);
 		} else if (!is_multikey) {
 			field = tuple_field_raw_by_part(format, data, field_map,
-							&key_def->parts[i], -1);
+							&key_def->parts[i],
+							MULTIKEY_NONE);
 		} else {
 			field = tuple_field_raw_by_part(format, data, field_map,
 							&key_def->parts[i],
@@ -248,7 +250,7 @@ tuple_extract_key_slowpath_raw(const char *data, const char *data_end,
 	assert(has_json_paths == key_def->has_json_paths);
 	assert(!has_optional_parts || key_def->is_nullable);
 	assert(has_optional_parts == key_def->has_optional_parts);
-	assert(!key_def_is_multikey(key_def) || multikey_idx >= 0);
+	assert(!key_def_is_multikey(key_def) || multikey_idx != MULTIKEY_NONE);
 	assert(mp_sizeof_nil() == 1);
 	/* allocate buffer with maximal possible size */
 	char *key = (char *) region_alloc(&fiber()->gc, data_end - data);
@@ -453,7 +455,8 @@ tuple_validate_key_parts(struct key_def *key_def, struct tuple *tuple)
 	assert(!key_def_is_multikey(key_def));
 	for (uint32_t idx = 0; idx < key_def->part_count; idx++) {
 		struct key_part *part = &key_def->parts[idx];
-		const char *field = tuple_field_by_part(tuple, part, -1);
+		const char *field = tuple_field_by_part(tuple, part,
+							MULTIKEY_NONE);
 		if (field == NULL) {
 			if (key_part_is_nullable(part))
 				continue;
diff --git a/src/box/tuple_format.c b/src/box/tuple_format.c
index 31f0515e..cee03f0a 100644
--- a/src/box/tuple_format.c
+++ b/src/box/tuple_format.c
@@ -1144,7 +1144,7 @@ tuple_format_iterator_next(struct tuple_format_iterator *it,
 		entry->multikey_idx = it->multikey_frame->idx;
 	} else {
 		entry->multikey_count = 0;
-		entry->multikey_idx = -1;
+		entry->multikey_idx = MULTIKEY_NONE;
 	}
 	if (field == NULL || (it->flags & TUPLE_FORMAT_ITERATOR_VALIDATE) == 0)
 		return 0;
diff --git a/src/box/tuple_hash.cc b/src/box/tuple_hash.cc
index f90e1671..223c5f6f 100644
--- a/src/box/tuple_hash.cc
+++ b/src/box/tuple_hash.cc
@@ -160,7 +160,8 @@ struct TupleHash
 		uint32_t carry = 0;
 		uint32_t total_size = 0;
 		const char *field = tuple_field_by_part(tuple,
-						key_def->parts, -1);
+						key_def->parts,
+						MULTIKEY_NONE);
 		TupleFieldHash<TYPE, MORE_TYPES...>::
 			hash(&field, &h, &carry, &total_size);
 		return PMurHash32_Result(h, carry, total_size);
@@ -173,7 +174,8 @@ struct TupleHash<FIELD_TYPE_UNSIGNED> {
 	{
 		assert(!key_def_is_multikey(key_def));
 		const char *field = tuple_field_by_part(tuple,
-						key_def->parts, -1);
+						key_def->parts,
+						MULTIKEY_NONE);
 		uint64_t val = mp_decode_uint(&field);
 		if (likely(val <= UINT32_MAX))
 			return val;
@@ -373,7 +375,7 @@ tuple_hash_slowpath(struct tuple *tuple, struct key_def *key_def)
 	const char *field;
 	if (has_json_paths) {
 		field = tuple_field_raw_by_part(format, tuple_raw, field_map,
-						key_def->parts, -1);
+						key_def->parts, MULTIKEY_NONE);
 	} else {
 		field = tuple_field_raw(format, tuple_raw, field_map,
 					prev_fieldno);
@@ -394,7 +396,8 @@ tuple_hash_slowpath(struct tuple *tuple, struct key_def *key_def)
 			struct key_part *part = &key_def->parts[part_id];
 			if (has_json_paths) {
 				field = tuple_field_raw_by_part(format, tuple_raw,
-								field_map, part, -1);
+								field_map, part,
+								MULTIKEY_NONE);
 			} else {
 				field = tuple_field_raw(format, tuple_raw, field_map,
 						    part->fieldno);
diff --git a/src/box/vinyl.c b/src/box/vinyl.c
index 5be10d59..d4929a37 100644
--- a/src/box/vinyl.c
+++ b/src/box/vinyl.c
@@ -1339,7 +1339,8 @@ vy_get_by_secondary_tuple(struct vy_lsm *lsm, struct vy_tx *tx,
 	struct vy_entry key;
 	if (vy_stmt_is_key(entry.stmt)) {
 		key.stmt = vy_stmt_extract_key(entry.stmt, lsm->pk_in_cmp_def,
-					       lsm->env->key_format, -1);
+					       lsm->env->key_format,
+					       MULTIKEY_NONE);
 		if (key.stmt == NULL)
 			return -1;
 	} else {
@@ -1644,7 +1645,8 @@ vy_check_is_unique_secondary(struct vy_tx *tx, const struct vy_read_view **rv,
 		return 0;
 	if (!key_def_is_multikey(lsm->cmp_def)) {
 		return vy_check_is_unique_secondary_one(tx, rv,
-				space_name, index_name, lsm, stmt, -1);
+				space_name, index_name, lsm, stmt,
+				MULTIKEY_NONE);
 	}
 	int count = tuple_multikey_count(stmt, lsm->cmp_def);
 	for (int i = 0; i < count; ++i) {
@@ -2167,7 +2169,8 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 	 */
 	/* Find the old tuple using the primary key. */
 	struct tuple *key = vy_stmt_extract_key_raw(tuple, tuple_end,
-					pk->key_def, pk->env->key_format, -1);
+					pk->key_def, pk->env->key_format,
+					MULTIKEY_NONE);
 	if (key == NULL)
 		return -1;
 	int rc = vy_get(pk, tx, vy_tx_read_view(tx), key, &stmt->old_tuple);
diff --git a/src/box/vy_run.c b/src/box/vy_run.c
index 0b9950f6..3b38aac6 100644
--- a/src/box/vy_run.c
+++ b/src/box/vy_run.c
@@ -2437,7 +2437,8 @@ vy_run_rebuild_index(struct vy_run *run, const char *dir,
 				}
 			}
 			key = vy_stmt_is_key(tuple) ? tuple_data(tuple) :
-			      tuple_extract_key(tuple, cmp_def, -1, NULL);
+			      tuple_extract_key(tuple, cmp_def,
+						MULTIKEY_NONE, NULL);
 			if (prev_tuple != NULL)
 				tuple_unref(prev_tuple);
 			prev_tuple = tuple;
diff --git a/src/box/vy_stmt.c b/src/box/vy_stmt.c
index 8ce785a5..9e20b6bf 100644
--- a/src/box/vy_stmt.c
+++ b/src/box/vy_stmt.c
@@ -629,7 +629,8 @@ vy_stmt_encode_primary(struct tuple *value, struct key_def *key_def,
 	case IPROTO_DELETE:
 		extracted = vy_stmt_is_key(value) ?
 			    tuple_data_range(value, &size) :
-			    tuple_extract_key(value, key_def, -1, &size);
+			    tuple_extract_key(value, key_def,
+					      MULTIKEY_NONE, &size);
 		if (extracted == NULL)
 			return -1;
 		request.key = extracted;
diff --git a/src/box/vy_stmt.h b/src/box/vy_stmt.h
index 0026d614..a80456ad 100644
--- a/src/box/vy_stmt.h
+++ b/src/box/vy_stmt.h
@@ -691,13 +691,13 @@ vy_stmt_str(struct tuple *stmt);
 
 /**
  * Extract a multikey index hint from a statement entry.
- * Returns -1 if the key definition isn't multikey.
+ * Returns MULTIKEY_NONE if the key definition isn't multikey.
  */
 static inline int
 vy_entry_multikey_idx(struct vy_entry entry, struct key_def *key_def)
 {
 	if (!key_def_is_multikey(key_def) || vy_stmt_is_key(entry.stmt))
-		return -1;
+		return MULTIKEY_NONE;
 	assert(entry.hint != HINT_NONE);
 	return (int)entry.hint;
 }
-- 
2.11.0