Tarantool development patches archive
 help / color / mirror / Atom feed
* [PATCH] vinyl: rename vy_index to vy_lsm
@ 2018-03-23 15:50 Vladimir Davydov
  0 siblings, 0 replies; only message in thread
From: Vladimir Davydov @ 2018-03-23 15:50 UTC (permalink / raw)
  To: kostja; +Cc: tarantool-patches

Vinyl assigns a unique id to each index so that it can be identified in
vylog, see vy_index->id, but outside Vinyl index id means something
completely different - it's the ordinal number of the index in a space.
This creates a lot of confusion. To resolve this, let's rename vy_index
to vy_lsm and refer to Vinyl indexes as LSM trees in comments so that
Vinyl's index_id turns into lsm_id.

Also, rename vy_log_record's index_def_id and space_def_id back to
conventional index_id and space_id as they doesn't conflict with Vinyl
index id anymore (which is now lsm_id).

Thanks to @Gerold103 for suggesting the new name.
---
 src/box/CMakeLists.txt           |   2 +-
 src/box/vinyl.c                  | 665 +++++++++++++++++++--------------------
 src/box/vy_cache.h               |   2 +-
 src/box/vy_log.c                 | 401 ++++++++++++-----------
 src/box/vy_log.h                 | 144 ++++-----
 src/box/{vy_index.c => vy_lsm.c} | 636 ++++++++++++++++++-------------------
 src/box/{vy_index.h => vy_lsm.h} | 270 ++++++++--------
 src/box/vy_mem.c                 |   2 +-
 src/box/vy_point_lookup.c        |  98 +++---
 src/box/vy_point_lookup.h        |   8 +-
 src/box/vy_range.h               |  15 +-
 src/box/vy_read_iterator.c       | 117 ++++---
 src/box/vy_read_iterator.h       |  16 +-
 src/box/vy_read_set.c            |  24 +-
 src/box/vy_read_set.h            |  46 +--
 src/box/vy_run.c                 |   5 +-
 src/box/vy_run.h                 |  14 +-
 src/box/vy_scheduler.c           | 418 ++++++++++++------------
 src/box/vy_scheduler.h           |  18 +-
 src/box/vy_stat.h                |  14 +-
 src/box/vy_tx.c                  | 152 +++++----
 src/box/vy_tx.h                  |  33 +-
 test/unit/CMakeLists.txt         |   2 +-
 test/unit/vy_log_stub.c          |   6 +-
 test/unit/vy_point_lookup.c      |  37 ++-
 test/unit/vy_point_lookup.result |   6 +-
 26 files changed, 1565 insertions(+), 1586 deletions(-)
 rename src/box/{vy_index.c => vy_lsm.c} (56%)
 rename src/box/{vy_index.h => vy_lsm.h} (59%)

diff --git a/src/box/CMakeLists.txt b/src/box/CMakeLists.txt
index fb6602b0..598b596a 100644
--- a/src/box/CMakeLists.txt
+++ b/src/box/CMakeLists.txt
@@ -75,7 +75,7 @@ add_library(box STATIC
     vy_mem.c
     vy_run.c
     vy_range.c
-    vy_index.c
+    vy_lsm.c
     vy_tx.c
     vy_write_iterator.c
     vy_read_iterator.c
diff --git a/src/box/vinyl.c b/src/box/vinyl.c
index ac12a331..f782ee64 100644
--- a/src/box/vinyl.c
+++ b/src/box/vinyl.c
@@ -33,7 +33,7 @@
 #include "vy_mem.h"
 #include "vy_run.h"
 #include "vy_range.h"
-#include "vy_index.h"
+#include "vy_lsm.h"
 #include "vy_tx.h"
 #include "vy_cache.h"
 #include "vy_log.h"
@@ -130,8 +130,8 @@ struct vy_env {
 	 * best result among 10% worst measurements.
 	 */
 	struct histogram *dump_bw;
-	/** Common index environment. */
-	struct vy_index_env index_env;
+	/** Common LSM tree environment. */
+	struct vy_lsm_env lsm_env;
 	/** Environment for cache subsystem */
 	struct vy_cache_env cache_env;
 	/** Environment for run subsystem */
@@ -204,15 +204,15 @@ vy_env(struct engine *engine)
 
 struct vinyl_index {
 	struct index base;
-	/** Vinyl index implementation. */
-	struct vy_index *db;
+	/** LSM tree that stores index data. */
+	struct vy_lsm *lsm;
 };
 
-/** Extract vy_index from an index object. */
-struct vy_index *
-vy_index(struct index *index)
+/** Extract vy_lsm from an index object. */
+struct vy_lsm *
+vy_lsm(struct index *index)
 {
-	return ((struct vinyl_index *)index)->db;
+	return ((struct vinyl_index *)index)->lsm;
 }
 
 /** Mask passed to vy_gc(). */
@@ -231,8 +231,8 @@ struct vinyl_iterator {
 	struct iterator base;
 	/** Vinyl environment. */
 	struct vy_env *env;
-	/** Vinyl index this iterator is for. */
-	struct vy_index *index;
+	/** LSM tree this iterator is for. */
+	struct vy_lsm *lsm;
 	/**
 	 * Points either to tx_autocommit for autocommit mode
 	 * or to a multi-statement transaction active when the
@@ -396,12 +396,12 @@ vy_info_append_compact_stat(struct info_handler *h, const char *name,
 }
 
 static void
-vinyl_index_info(struct index *base, struct info_handler *h)
+vinyl_index_info(struct index *index, struct info_handler *h)
 {
 	char buf[1024];
-	struct vy_index *index = vy_index(base);
-	struct vy_index_stat *stat = &index->stat;
-	struct vy_cache_stat *cache_stat = &index->cache.stat;
+	struct vy_lsm *lsm = vy_lsm(index);
+	struct vy_lsm_stat *stat = &lsm->stat;
+	struct vy_cache_stat *cache_stat = &lsm->cache.stat;
 
 	info_begin(h);
 
@@ -425,7 +425,7 @@ vinyl_index_info(struct index *base, struct info_handler *h)
 	info_append_int(h, "lookup", stat->memory.iterator.lookup);
 	vy_info_append_stmt_counter(h, "get", &stat->memory.iterator.get);
 	info_table_end(h);
-	info_append_int(h, "index_size", vy_index_mem_tree_size(index));
+	info_append_int(h, "index_size", vy_lsm_mem_tree_size(lsm));
 	info_table_end(h);
 
 	info_table_begin(h, "disk");
@@ -441,8 +441,8 @@ vinyl_index_info(struct index *base, struct info_handler *h)
 	info_table_end(h);
 	vy_info_append_compact_stat(h, "dump", &stat->disk.dump);
 	vy_info_append_compact_stat(h, "compact", &stat->disk.compact);
-	info_append_int(h, "index_size", index->page_index_size);
-	info_append_int(h, "bloom_size", index->bloom_size);
+	info_append_int(h, "index_size", lsm->page_index_size);
+	info_append_int(h, "bloom_size", lsm->bloom_size);
 	info_table_end(h);
 
 	info_table_begin(h, "cache");
@@ -453,7 +453,7 @@ vinyl_index_info(struct index *base, struct info_handler *h)
 	vy_info_append_stmt_counter(h, "invalidate", &cache_stat->invalidate);
 	vy_info_append_stmt_counter(h, "evict", &cache_stat->evict);
 	info_append_int(h, "index_size",
-			vy_cache_tree_mem_used(&index->cache.cache_tree));
+			vy_cache_tree_mem_used(&lsm->cache.cache_tree));
 	info_table_end(h);
 
 	info_table_begin(h, "txw");
@@ -464,21 +464,21 @@ vinyl_index_info(struct index *base, struct info_handler *h)
 	info_table_end(h);
 	info_table_end(h);
 
-	info_append_int(h, "range_count", index->range_count);
-	info_append_int(h, "run_count", index->run_count);
-	info_append_int(h, "run_avg", index->run_count / index->range_count);
-	histogram_snprint(buf, sizeof(buf), index->run_hist);
+	info_append_int(h, "range_count", lsm->range_count);
+	info_append_int(h, "run_count", lsm->run_count);
+	info_append_int(h, "run_avg", lsm->run_count / lsm->range_count);
+	histogram_snprint(buf, sizeof(buf), lsm->run_hist);
 	info_append_str(h, "run_histogram", buf);
 
 	info_end(h);
 }
 
 static void
-vinyl_index_reset_stat(struct index *base)
+vinyl_index_reset_stat(struct index *index)
 {
-	struct vy_index *index = vy_index(base);
-	struct vy_index_stat *stat = &index->stat;
-	struct vy_cache_stat *cache_stat = &index->cache.stat;
+	struct vy_lsm *lsm = vy_lsm(index);
+	struct vy_lsm_stat *stat = &lsm->stat;
+	struct vy_cache_stat *cache_stat = &lsm->cache.stat;
 
 	stat->lookup = 0;
 	latency_reset(&stat->latency);
@@ -507,8 +507,8 @@ vinyl_engine_memory_stat(struct engine *engine, struct engine_memory_stat *stat)
 	stat->data += lsregion_used(&env->mem_env.allocator) -
 				env->mem_env.tree_extent_size;
 	stat->index += env->mem_env.tree_extent_size;
-	stat->index += env->index_env.bloom_size;
-	stat->index += env->index_env.page_index_size;
+	stat->index += env->lsm_env.bloom_size;
+	stat->index += env->lsm_env.page_index_size;
 	stat->cache += env->cache_env.mem_used;
 	stat->tx += env->xm->write_set_size + env->xm->read_set_size;
 	mempool_stats(&env->xm->tx_mempool, &mstats);
@@ -553,31 +553,31 @@ vinyl_check_wal(struct vy_env *env, const char *what)
 }
 
 /**
- * Given a space and an index id, return vy_index.
+ * Given a space and an index id, return vy_lsm.
  * If index not found, return NULL and set diag.
  */
-static struct vy_index *
-vy_index_find(struct space *space, uint32_t iid)
+static struct vy_lsm *
+vy_lsm_find(struct space *space, uint32_t iid)
 {
 	struct index *index = index_find(space, iid);
 	if (index == NULL)
 		return NULL;
-	return vy_index(index);
+	return vy_lsm(index);
 }
 
 /**
- * Wrapper around vy_index_find() which ensures that
+ * Wrapper around vy_lsm_find() which ensures that
  * the found index is unique.
  */
-static  struct vy_index *
-vy_index_find_unique(struct space *space, uint32_t index_id)
+static  struct vy_lsm *
+vy_lsm_find_unique(struct space *space, uint32_t index_id)
 {
-	struct vy_index *index = vy_index_find(space, index_id);
-	if (index != NULL && !index->opts.is_unique) {
+	struct vy_lsm *lsm = vy_lsm_find(space, index_id);
+	if (lsm != NULL && !lsm->opts.is_unique) {
 		diag_set(ClientError, ER_MORE_THAN_ONE_TUPLE);
 		return NULL;
 	}
-	return index;
+	return lsm;
 }
 
 static int
@@ -684,39 +684,39 @@ vinyl_space_create_index(struct space *space, struct index_def *index_def)
 		return NULL;
 	}
 	struct vy_env *env = vinyl->env;
-	struct vy_index *pk = NULL;
+	struct vy_lsm *pk = NULL;
 	if (index_def->iid > 0) {
-		pk = vy_index(space_index(space, 0));
+		pk = vy_lsm(space_index(space, 0));
 		assert(pk != NULL);
 	}
-	struct vy_index *db = vy_index_new(&env->index_env, &env->cache_env,
-					   &env->mem_env, index_def,
-					   space->format, pk);
-	if (db == NULL) {
+	struct vy_lsm *lsm = vy_lsm_new(&env->lsm_env, &env->cache_env,
+					&env->mem_env, index_def,
+					space->format, pk);
+	if (lsm == NULL) {
 		free(index);
 		return NULL;
 	}
 	if (index_create(&index->base, (struct engine *)vinyl,
 			 &vinyl_index_vtab, index_def) != 0) {
-		vy_index_delete(db);
+		vy_lsm_delete(lsm);
 		free(index);
 		return NULL;
 	}
-	index->db = db;
+	index->lsm = lsm;
 	return &index->base;
 }
 
 static void
-vinyl_index_destroy(struct index *base)
+vinyl_index_destroy(struct index *index)
 {
-	struct vy_index *index = vy_index(base);
+	struct vy_lsm *lsm = vy_lsm(index);
 	/*
-	 * There still may be a task scheduled for this index
+	 * There still may be a task scheduled for this LSM tree
 	 * so postpone actual deletion until the last reference
 	 * is gone.
 	 */
-	vy_index_unref(index);
-	free(base);
+	vy_lsm_unref(lsm);
+	free(index);
 }
 
 /**
@@ -726,8 +726,11 @@ vinyl_index_destroy(struct index *base)
  * account.
  */
 static int
-vy_index_open(struct vy_env *env, struct vy_index *index)
+vinyl_index_open(struct index *index)
 {
+	struct vy_env *env = vy_env(index->engine);
+	struct vy_lsm *lsm = vy_lsm(index);
+
 	/* Ensure vinyl data directory exists. */
 	if (access(env->path, F_OK) != 0) {
 		diag_set(SystemError, "can not access vinyl data directory");
@@ -740,7 +743,7 @@ vy_index_open(struct vy_env *env, struct vy_index *index)
 		 * The recovery is complete, simply
 		 * create a new index.
 		 */
-		rc = vy_index_create(index);
+		rc = vy_lsm_create(lsm);
 		if (rc == 0) {
 			/* Make sure reader threads are up and running. */
 			vy_run_env_enable_coio(&env->run_env,
@@ -754,7 +757,7 @@ vy_index_open(struct vy_env *env, struct vy_index *index)
 		 * exist locally, and we should create the
 		 * index directory from scratch.
 		 */
-		rc = vy_index_create(index);
+		rc = vy_lsm_create(lsm);
 		break;
 	case VINYL_INITIAL_RECOVERY_LOCAL:
 	case VINYL_FINAL_RECOVERY_LOCAL:
@@ -764,10 +767,10 @@ vy_index_open(struct vy_env *env, struct vy_index *index)
 		 * have already been created, so try to load
 		 * the index files from it.
 		 */
-		rc = vy_index_recover(index, env->recovery, &env->run_env,
-				vclock_sum(env->recovery_vclock),
-				env->status == VINYL_INITIAL_RECOVERY_LOCAL,
-				env->force_recovery);
+		rc = vy_lsm_recover(lsm, env->recovery, &env->run_env,
+				    vclock_sum(env->recovery_vclock),
+				    env->status == VINYL_INITIAL_RECOVERY_LOCAL,
+				    env->force_recovery);
 		break;
 	default:
 		unreachable();
@@ -776,12 +779,12 @@ vy_index_open(struct vy_env *env, struct vy_index *index)
 }
 
 static void
-vinyl_index_commit_create(struct index *base, int64_t lsn)
+vinyl_index_commit_create(struct index *index, int64_t lsn)
 {
-	struct vy_env *env = vy_env(base->engine);
-	struct vy_index *index = vy_index(base);
+	struct vy_env *env = vy_env(index->engine);
+	struct vy_lsm *lsm = vy_lsm(index);
 
-	assert(index->id >= 0);
+	assert(lsm->id >= 0);
 
 	if (env->status == VINYL_INITIAL_RECOVERY_LOCAL ||
 	    env->status == VINYL_FINAL_RECOVERY_LOCAL) {
@@ -793,8 +796,8 @@ vinyl_index_commit_create(struct index *base, int64_t lsn)
 		 * the index isn't in the recovery context and we
 		 * need to retry to log it now.
 		 */
-		if (index->is_committed) {
-			vy_scheduler_add_index(&env->scheduler, index);
+		if (lsm->is_committed) {
+			vy_scheduler_add_lsm(&env->scheduler, lsm);
 			return;
 		}
 	}
@@ -815,14 +818,14 @@ vinyl_index_commit_create(struct index *base, int64_t lsn)
 	 * index by 1. So for legacy indexes use the LSN from
 	 * index options.
 	 */
-	if (index->opts.lsn != 0)
-		lsn = index->opts.lsn;
+	if (lsm->opts.lsn != 0)
+		lsn = lsm->opts.lsn;
 
-	assert(!index->is_committed);
-	index->is_committed = true;
+	assert(!lsm->is_committed);
+	lsm->is_committed = true;
 
-	assert(index->range_count == 1);
-	struct vy_range *range = vy_range_tree_first(index->tree);
+	assert(lsm->range_count == 1);
+	struct vy_range *range = vy_range_tree_first(lsm->tree);
 
 	/*
 	 * Since it's too late to fail now, in case of vylog write
@@ -833,27 +836,27 @@ vinyl_index_commit_create(struct index *base, int64_t lsn)
 	 * recovery.
 	 */
 	vy_log_tx_begin();
-	vy_log_create_index(index->id, index->space_id, index->index_id,
-			    index->key_def, lsn);
-	vy_log_insert_range(index->id, range->id, NULL, NULL);
+	vy_log_create_lsm(lsm->id, lsm->space_id, lsm->index_id,
+			  lsm->key_def, lsn);
+	vy_log_insert_range(lsm->id, range->id, NULL, NULL);
 	vy_log_tx_try_commit();
 	/*
 	 * After we committed the index in the log, we can schedule
 	 * a task for it.
 	 */
-	vy_scheduler_add_index(&env->scheduler, index);
+	vy_scheduler_add_lsm(&env->scheduler, lsm);
 }
 
 /*
- * Delete all runs, ranges, and slices of a given index
+ * Delete all runs, ranges, and slices of a given LSM tree
  * from the metadata log.
  */
 static void
-vy_log_index_prune(struct vy_index *index, int64_t gc_lsn)
+vy_log_lsm_prune(struct vy_lsm *lsm, int64_t gc_lsn)
 {
 	int loops = 0;
-	for (struct vy_range *range = vy_range_tree_first(index->tree);
-	     range != NULL; range = vy_range_tree_next(index->tree, range)) {
+	for (struct vy_range *range = vy_range_tree_first(lsm->tree);
+	     range != NULL; range = vy_range_tree_next(lsm->tree, range)) {
 		struct vy_slice *slice;
 		rlist_foreach_entry(slice, &range->slices, in_range)
 			vy_log_delete_slice(slice->id);
@@ -862,7 +865,7 @@ vy_log_index_prune(struct vy_index *index, int64_t gc_lsn)
 			fiber_sleep(0);
 	}
 	struct vy_run *run;
-	rlist_foreach_entry(run, &index->runs, in_index) {
+	rlist_foreach_entry(run, &lsm->runs, in_lsm) {
 		vy_log_drop_run(run->id, gc_lsn);
 		if (++loops % VY_YIELD_LOOPS == 0)
 			fiber_sleep(0);
@@ -870,12 +873,12 @@ vy_log_index_prune(struct vy_index *index, int64_t gc_lsn)
 }
 
 static void
-vinyl_index_commit_drop(struct index *base)
+vinyl_index_commit_drop(struct index *index)
 {
-	struct vy_env *env = vy_env(base->engine);
-	struct vy_index *index = vy_index(base);
+	struct vy_env *env = vy_env(index->engine);
+	struct vy_lsm *lsm = vy_lsm(index);
 
-	vy_scheduler_remove_index(&env->scheduler, index);
+	vy_scheduler_remove_lsm(&env->scheduler, lsm);
 
 	/*
 	 * We can't abort here, because the index drop request has
@@ -885,14 +888,14 @@ vinyl_index_commit_drop(struct index *base)
 	 * not flushed before the instance is shut down, we replay it
 	 * on local recovery from WAL.
 	 */
-	if (env->status == VINYL_FINAL_RECOVERY_LOCAL && index->is_dropped)
+	if (env->status == VINYL_FINAL_RECOVERY_LOCAL && lsm->is_dropped)
 		return;
 
-	index->is_dropped = true;
+	lsm->is_dropped = true;
 
 	vy_log_tx_begin();
-	vy_log_index_prune(index, checkpoint_last(NULL));
-	vy_log_drop_index(index->id);
+	vy_log_lsm_prune(lsm, checkpoint_last(NULL));
+	vy_log_drop_lsm(lsm->id);
 	vy_log_tx_try_commit();
 }
 
@@ -916,7 +919,7 @@ vinyl_space_prepare_alter(struct space *old_space, struct space *new_space)
 	 */
 	if (old_space->index_count == 0)
 		return 0;
-	struct vy_index *pk = vy_index(old_space->index[0]);
+	struct vy_lsm *pk = vy_lsm(old_space->index[0]);
 	/*
 	 * During WAL recovery, the space may be not empty. But we
 	 * open existing indexes, not creating new ones. Allow
@@ -984,7 +987,7 @@ vinyl_space_check_format(struct space *new_space, struct space *old_space)
 	/* @sa vy_prepare_alter_space for checks below. */
 	if (old_space->index_count == 0)
 		return 0;
-	struct vy_index *pk = vy_index(old_space->index[0]);
+	struct vy_lsm *pk = vy_lsm(old_space->index[0]);
 	if (env->status != VINYL_ONLINE)
 		return 0;
 	if (pk->stat.disk.count.rows == 0 && pk->stat.memory.count.rows == 0)
@@ -1002,7 +1005,7 @@ vinyl_space_commit_alter(struct space *old_space, struct space *new_space)
 		return; /* space drop */
 
 	struct tuple_format *new_format = new_space->format;
-	struct vy_index *pk = vy_index(new_space->index[0]);
+	struct vy_lsm *pk = vy_lsm(new_space->index[0]);
 	struct index_def *new_index_def = space_index_def(new_space, 0);
 
 	assert(pk->pk == NULL);
@@ -1038,33 +1041,32 @@ vinyl_space_commit_alter(struct space *old_space, struct space *new_space)
 	tuple_format_ref(format);
 	pk->mem_format = new_format;
 	tuple_format_ref(new_format);
-	vy_index_validate_formats(pk);
+	vy_lsm_validate_formats(pk);
 	key_def_update_optionality(pk->key_def, new_format->min_field_count);
 	key_def_update_optionality(pk->cmp_def, new_format->min_field_count);
 
 	for (uint32_t i = 1; i < new_space->index_count; ++i) {
-		struct vy_index *index = vy_index(new_space->index[i]);
-		vy_index_unref(index->pk);
-		vy_index_ref(pk);
-		index->pk = pk;
+		struct vy_lsm *lsm = vy_lsm(new_space->index[i]);
+		vy_lsm_unref(lsm->pk);
+		vy_lsm_ref(pk);
+		lsm->pk = pk;
 		new_index_def = space_index_def(new_space, i);
-		index->opts = new_index_def->opts;
-		index->check_is_unique = index->opts.is_unique;
-		tuple_format_unref(index->mem_format_with_colmask);
-		tuple_format_unref(index->mem_format);
-		tuple_format_unref(index->upsert_format);
-		index->mem_format_with_colmask =
-			pk->mem_format_with_colmask;
-		index->mem_format = pk->mem_format;
-		index->upsert_format = pk->upsert_format;
-		tuple_format_ref(index->mem_format_with_colmask);
-		tuple_format_ref(index->mem_format);
-		tuple_format_ref(index->upsert_format);
-		key_def_update_optionality(index->key_def,
+		lsm->opts = new_index_def->opts;
+		lsm->check_is_unique = lsm->opts.is_unique;
+		tuple_format_unref(lsm->mem_format_with_colmask);
+		tuple_format_unref(lsm->mem_format);
+		tuple_format_unref(lsm->upsert_format);
+		lsm->mem_format_with_colmask = pk->mem_format_with_colmask;
+		lsm->mem_format = pk->mem_format;
+		lsm->upsert_format = pk->upsert_format;
+		tuple_format_ref(lsm->mem_format_with_colmask);
+		tuple_format_ref(lsm->mem_format);
+		tuple_format_ref(lsm->upsert_format);
+		key_def_update_optionality(lsm->key_def,
 					   new_format->min_field_count);
-		key_def_update_optionality(index->cmp_def,
+		key_def_update_optionality(lsm->cmp_def,
 					   new_format->min_field_count);
-		vy_index_validate_formats(index);
+		vy_lsm_validate_formats(lsm);
 	}
 
 	/*
@@ -1075,14 +1077,14 @@ vinyl_space_commit_alter(struct space *old_space, struct space *new_space)
 	 * likelier to have a "colder" cache.
 	 */
 	for (int i = new_space->index_count - 1; i >= 0; i--) {
-		struct vy_index *index = vy_index(new_space->index[i]);
-		if (!index->check_is_unique)
+		struct vy_lsm *lsm = vy_lsm(new_space->index[i]);
+		if (!lsm->check_is_unique)
 			continue;
 		for (int j = 0; j < (int)new_space->index_count; j++) {
-			struct vy_index *other = vy_index(new_space->index[j]);
-			if (other != index && other->check_is_unique &&
-			    key_def_contains(index->key_def, other->key_def)) {
-				index->check_is_unique = false;
+			struct vy_lsm *other = vy_lsm(new_space->index[j]);
+			if (other != lsm && other->check_is_unique &&
+			    key_def_contains(lsm->key_def, other->key_def)) {
+				lsm->check_is_unique = false;
 				break;
 			}
 		}
@@ -1098,8 +1100,7 @@ fail:
 static int
 vinyl_space_add_primary_key(struct space *space)
 {
-	return vy_index_open(vy_env(space->engine),
-			     vy_index(space->index[0]));
+	return vinyl_index_open(space->index[0]);
 }
 
 static void
@@ -1135,8 +1136,7 @@ vinyl_space_build_secondary_key(struct space *old_space,
 	 *   Engine::buildSecondaryKey(old_space, new_space, new_index_arg);
 	 *  but aware of three cases mentioned above.
 	 */
-	return vy_index_open(vy_env(new_index->engine),
-			     vy_index(new_index));
+	return vinyl_index_open(new_index);
 }
 
 static size_t
@@ -1148,28 +1148,27 @@ vinyl_space_bsize(struct space *space)
 	 * primary indexes, it is basically the size of
 	 * binary data stored in this space's primary index.
 	 */
-	struct index *pk_base = space_index(space, 0);
-	if (pk_base == NULL)
+	struct index *pk = space_index(space, 0);
+	if (pk == NULL)
 		return 0;
-	struct vy_index *pk = vy_index(pk_base);
-	return pk->stat.memory.count.bytes + pk->stat.disk.count.bytes;
+	struct vy_lsm *lsm = vy_lsm(pk);
+	return lsm->stat.memory.count.bytes + lsm->stat.disk.count.bytes;
 }
 
 static ssize_t
-vinyl_index_size(struct index *base)
+vinyl_index_size(struct index *index)
 {
 	/*
-	 * Return the total number of statements in the index.
-	 * Note, it may be greater than the number of tuples
-	 * actually stored in the space, but it should be a
-	 * fairly good estimate.
+	 * Return the total number of statements in the LSM tree.
+	 * Note, it may be greater than the number of tuples actually
+	 * stored in the space, but it should be a fairly good estimate.
 	 */
-	struct vy_index *index = vy_index(base);
-	return index->stat.memory.count.rows + index->stat.disk.count.rows;
+	struct vy_lsm *lsm = vy_lsm(index);
+	return lsm->stat.memory.count.rows + lsm->stat.disk.count.rows;
 }
 
 static ssize_t
-vinyl_index_bsize(struct index *base)
+vinyl_index_bsize(struct index *index)
 {
 	/*
 	 * Return the cost of indexing user data. For both
@@ -1179,11 +1178,11 @@ vinyl_index_bsize(struct index *base)
 	 * total size of statements stored on disk, because
 	 * they are only needed for building the index.
 	 */
-	struct vy_index *index = vy_index(base);
-	ssize_t bsize = vy_index_mem_tree_size(index) +
-		index->page_index_size + index->bloom_size;
-	if (index->index_id > 0)
-		bsize += index->stat.disk.count.bytes;
+	struct vy_lsm *lsm = vy_lsm(index);
+	ssize_t bsize = vy_lsm_mem_tree_size(lsm) +
+		lsm->page_index_size + lsm->bloom_size;
+	if (lsm->index_id > 0)
+		bsize += lsm->stat.disk.count.bytes;
 	return bsize;
 }
 
@@ -1192,25 +1191,25 @@ vinyl_index_bsize(struct index *base)
  */
 
 /**
- * Check if a request has already been committed to an index.
+ * Check if a request has already been committed to an LSM tree.
  *
  * If we're recovering the WAL, it may happen so that this
  * particular run was dumped after the checkpoint, and we're
  * replaying records already present in the database. In this
  * case avoid overwriting a newer version with an older one.
  *
- * If the index is going to be dropped or truncated on WAL
+ * If the LSM tree is going to be dropped or truncated on WAL
  * recovery, there's no point in replaying statements for it,
  * either.
  */
 static inline bool
-vy_is_committed_one(struct vy_env *env, struct vy_index *index)
+vy_is_committed_one(struct vy_env *env, struct vy_lsm *lsm)
 {
 	if (likely(env->status != VINYL_FINAL_RECOVERY_LOCAL))
 		return false;
-	if (index->is_dropped)
+	if (lsm->is_dropped)
 		return true;
-	if (vclock_sum(env->recovery_vclock) <= index->dump_lsn)
+	if (vclock_sum(env->recovery_vclock) <= lsm->dump_lsn)
 		return true;
 	return false;
 }
@@ -1225,16 +1224,16 @@ vy_is_committed(struct vy_env *env, struct space *space)
 	if (likely(env->status != VINYL_FINAL_RECOVERY_LOCAL))
 		return false;
 	for (uint32_t iid = 0; iid < space->index_count; iid++) {
-		struct vy_index *index = vy_index(space->index[iid]);
-		if (!vy_is_committed_one(env, index))
+		struct vy_lsm *lsm = vy_lsm(space->index[iid]);
+		if (!vy_is_committed_one(env, lsm))
 			return false;
 	}
 	return true;
 }
 
 /**
- * Get a vinyl tuple from the index by the key.
- * @param index       Index in which search.
+ * Get a vinyl tuple from the LSM tree by the key.
+ * @param lsm         LSM tree in which search.
  * @param tx          Current transaction.
  * @param rv          Read view.
  * @param key         Key statement.
@@ -1245,7 +1244,7 @@ vy_is_committed(struct vy_env *env, struct space *space)
  * @param -1 Memory error or read error.
  */
 static inline int
-vy_index_get(struct vy_index *index, struct vy_tx *tx,
+vy_lsm_get(struct vy_lsm *lsm, struct vy_tx *tx,
 	     const struct vy_read_view **rv,
 	     struct tuple *key, struct tuple **result)
 {
@@ -1255,14 +1254,14 @@ vy_index_get(struct vy_index *index, struct vy_tx *tx,
 	 */
 	assert(tx == NULL || tx->state == VINYL_TX_READY);
 
-	if (tuple_field_count(key) >= index->cmp_def->part_count) {
-		if (tx != NULL && vy_tx_track_point(tx, index, key) != 0)
+	if (tuple_field_count(key) >= lsm->cmp_def->part_count) {
+		if (tx != NULL && vy_tx_track_point(tx, lsm, key) != 0)
 			return -1;
-		return vy_point_lookup(index, tx, rv, key, result);
+		return vy_point_lookup(lsm, tx, rv, key, result);
 	}
 
 	struct vy_read_iterator itr;
-	vy_read_iterator_open(&itr, index, tx, ITER_EQ, key, rv);
+	vy_read_iterator_open(&itr, lsm, tx, ITER_EQ, key, rv);
 	int rc = vy_read_iterator_next(&itr, result);
 	if (*result != NULL)
 		tuple_ref(*result);
@@ -1271,12 +1270,12 @@ vy_index_get(struct vy_index *index, struct vy_tx *tx,
 }
 
 /**
- * Check if the index contains the key. If true, then set
+ * Check if the LSM tree contains the key. If true, then set
  * a duplicate key error in the diagnostics area.
  * @param env        Vinyl environment.
  * @param tx         Current transaction.
  * @param space      Target space.
- * @param index      Index in which to search.
+ * @param lsm        LSM tree in which to search.
  * @param key        Key statement.
  *
  * @retval  0 Success, the key isn't found.
@@ -1284,7 +1283,7 @@ vy_index_get(struct vy_index *index, struct vy_tx *tx,
  */
 static inline int
 vy_check_is_unique(struct vy_env *env, struct vy_tx *tx, struct space *space,
-		   struct vy_index *index, struct tuple *key)
+		   struct vy_lsm *lsm, struct tuple *key)
 {
 	struct tuple *found;
 	/*
@@ -1293,13 +1292,13 @@ vy_check_is_unique(struct vy_env *env, struct vy_tx *tx, struct space *space,
 	 */
 	if (env->status != VINYL_ONLINE)
 		return 0;
-	if (vy_index_get(index, tx, vy_tx_read_view(tx), key, &found))
+	if (vy_lsm_get(lsm, tx, vy_tx_read_view(tx), key, &found))
 		return -1;
 
 	if (found) {
 		tuple_unref(found);
 		diag_set(ClientError, ER_TUPLE_FOUND,
-			 index_name_by_id(space, index->index_id),
+			 index_name_by_id(space, lsm->index_id),
 			 space_name(space));
 		return -1;
 	}
@@ -1307,11 +1306,11 @@ vy_check_is_unique(struct vy_env *env, struct vy_tx *tx, struct space *space,
 }
 
 /**
- * Insert a tuple in a primary index.
+ * Insert a tuple in a primary index LSM tree.
  * @param env   Vinyl environment.
  * @param tx    Current transaction.
  * @param space Target space.
- * @param pk    Primary vinyl index.
+ * @param pk    Primary index LSM tree.
  * @param stmt  Tuple to insert.
  *
  * @retval  0 Success.
@@ -1319,7 +1318,7 @@ vy_check_is_unique(struct vy_env *env, struct vy_tx *tx, struct space *space,
  */
 static inline int
 vy_insert_primary(struct vy_env *env, struct vy_tx *tx, struct space *space,
-		  struct vy_index *pk, struct tuple *stmt)
+		  struct vy_lsm *pk, struct tuple *stmt)
 {
 	assert(vy_stmt_type(stmt) == IPROTO_INSERT);
 	assert(tx != NULL && tx->state == VINYL_TX_READY);
@@ -1335,11 +1334,11 @@ vy_insert_primary(struct vy_env *env, struct vy_tx *tx, struct space *space,
 }
 
 /**
- * Insert a tuple in a secondary index.
+ * Insert a tuple in a secondary index LSM tree.
  * @param env       Vinyl environment.
  * @param tx        Current transaction.
  * @param space     Target space.
- * @param index     Secondary index.
+ * @param lsm       Secondary index LSM tree.
  * @param stmt      Tuple to replace.
  *
  * @retval  0 Success.
@@ -1347,38 +1346,38 @@ vy_insert_primary(struct vy_env *env, struct vy_tx *tx, struct space *space,
  */
 static int
 vy_insert_secondary(struct vy_env *env, struct vy_tx *tx, struct space *space,
-		    struct vy_index *index, struct tuple *stmt)
+		    struct vy_lsm *lsm, struct tuple *stmt)
 {
 	assert(vy_stmt_type(stmt) == IPROTO_INSERT ||
 	       vy_stmt_type(stmt) == IPROTO_REPLACE);
 	assert(tx != NULL && tx->state == VINYL_TX_READY);
-	assert(index->index_id > 0);
+	assert(lsm->index_id > 0);
 	/*
 	 * If the index is unique then the new tuple must not
 	 * conflict with existing tuples. If the index is not
 	 * unique a conflict is impossible.
 	 */
-	if (index->check_is_unique &&
-	    !key_update_can_be_skipped(index->key_def->column_mask,
+	if (lsm->check_is_unique &&
+	    !key_update_can_be_skipped(lsm->key_def->column_mask,
 				       vy_stmt_column_mask(stmt)) &&
-	    (!index->key_def->is_nullable ||
-	     !vy_tuple_key_contains_null(stmt, index->key_def))) {
-		struct tuple *key = vy_stmt_extract_key(stmt, index->key_def,
-							index->env->key_format);
+	    (!lsm->key_def->is_nullable ||
+	     !vy_tuple_key_contains_null(stmt, lsm->key_def))) {
+		struct tuple *key = vy_stmt_extract_key(stmt, lsm->key_def,
+							lsm->env->key_format);
 		if (key == NULL)
 			return -1;
-		int rc = vy_check_is_unique(env, tx, space, index, key);
+		int rc = vy_check_is_unique(env, tx, space, lsm, key);
 		tuple_unref(key);
 		if (rc != 0)
 			return -1;
 	}
 	/*
 	 * We must always append the statement to transaction write set
-	 * of each index, even if operation itself does not update
-	 * the index, e.g. it's an UPDATE, to ensure we read our
+	 * of each LSM tree, even if operation itself does not update
+	 * the LSM tree, e.g. it's an UPDATE, to ensure we read our
 	 * own writes.
 	 */
-	return vy_tx_set(tx, index, stmt);
+	return vy_tx_set(tx, lsm, stmt);
 }
 
 /**
@@ -1403,7 +1402,7 @@ vy_replace_one(struct vy_env *env, struct vy_tx *tx, struct space *space,
 {
 	(void)env;
 	assert(tx != NULL && tx->state == VINYL_TX_READY);
-	struct vy_index *pk = vy_index(space->index[0]);
+	struct vy_lsm *pk = vy_lsm(space->index[0]);
 	assert(pk->index_id == 0);
 	if (tuple_validate_raw(pk->mem_format, request->tuple))
 		return -1;
@@ -1417,8 +1416,8 @@ vy_replace_one(struct vy_env *env, struct vy_tx *tx, struct space *space,
 	 * old tuple to pass it to the trigger.
 	 */
 	if (stmt != NULL && !rlist_empty(&space->on_replace)) {
-		if (vy_index_get(pk, tx, vy_tx_read_view(tx),
-				 new_tuple, &stmt->old_tuple) != 0)
+		if (vy_lsm_get(pk, tx, vy_tx_read_view(tx),
+			       new_tuple, &stmt->old_tuple) != 0)
 			goto error_unref;
 	}
 	if (vy_tx_set(tx, pk, new_tuple))
@@ -1459,7 +1458,7 @@ vy_replace_impl(struct vy_env *env, struct vy_tx *tx, struct space *space,
 	struct tuple *old_stmt = NULL;
 	struct tuple *new_stmt = NULL;
 	struct tuple *delete = NULL;
-	struct vy_index *pk = vy_index_find(space, 0);
+	struct vy_lsm *pk = vy_lsm_find(space, 0);
 	if (pk == NULL) /* space has no primary key */
 		return -1;
 	/* Primary key is dumped last. */
@@ -1473,7 +1472,7 @@ vy_replace_impl(struct vy_env *env, struct vy_tx *tx, struct space *space,
 		return -1;
 
 	/* Get full tuple from the primary index. */
-	if (vy_index_get(pk, tx, vy_tx_read_view(tx),
+	if (vy_lsm_get(pk, tx, vy_tx_read_view(tx),
 			 new_stmt, &old_stmt) != 0)
 		goto error;
 
@@ -1500,9 +1499,8 @@ vy_replace_impl(struct vy_env *env, struct vy_tx *tx, struct space *space,
 
 	/* Update secondary keys, avoid duplicates. */
 	for (uint32_t iid = 1; iid < space->index_count; ++iid) {
-		struct vy_index *index;
-		index = vy_index(space->index[iid]);
-		if (vy_is_committed_one(env, index))
+		struct vy_lsm *lsm = vy_lsm(space->index[iid]);
+		if (vy_is_committed_one(env, lsm))
 			continue;
 		/*
 		 * Delete goes first, so if old and new keys
@@ -1510,10 +1508,10 @@ vy_replace_impl(struct vy_env *env, struct vy_tx *tx, struct space *space,
 		 * transaction index.
 		 */
 		if (old_stmt != NULL) {
-			if (vy_tx_set(tx, index, delete) != 0)
+			if (vy_tx_set(tx, lsm, delete) != 0)
 				goto error;
 		}
-		if (vy_insert_secondary(env, tx, space, index, new_stmt) != 0)
+		if (vy_insert_secondary(env, tx, space, lsm, new_stmt) != 0)
 			goto error;
 	}
 	if (delete != NULL)
@@ -1538,8 +1536,9 @@ error:
 }
 
 /**
- * Check that the key can be used for search in a unique index.
- * @param  index      Index for checking.
+ * Check that the key can be used for search in a unique index
+ * LSM tree.
+ * @param  lsm        LSM tree for checking.
  * @param  key        MessagePack'ed data, the array without a
  *                    header.
  * @param  part_count Part count of the key.
@@ -1549,34 +1548,34 @@ error:
  *            in the diagnostics area.
  */
 static inline int
-vy_unique_key_validate(struct vy_index *index, const char *key,
+vy_unique_key_validate(struct vy_lsm *lsm, const char *key,
 		       uint32_t part_count)
 {
-	assert(index->opts.is_unique);
+	assert(lsm->opts.is_unique);
 	assert(key != NULL || part_count == 0);
 	/*
-	 * The index contains tuples with concatenation of
+	 * The LSM tree contains tuples with concatenation of
 	 * secondary and primary key fields, while the key
 	 * supplied by the user only contains the secondary key
 	 * fields. Use the correct key def to validate the key.
-	 * The key can be used to look up in the index since the
-	 * supplied key parts uniquely identify the tuple, as long
-	 * as the index is unique.
+	 * The key can be used to look up in the LSM tree since
+	 * the supplied key parts uniquely identify the tuple,
+	 * as long as the index is unique.
 	 */
-	uint32_t original_part_count = index->key_def->part_count;
+	uint32_t original_part_count = lsm->key_def->part_count;
 	if (original_part_count != part_count) {
 		diag_set(ClientError, ER_EXACT_MATCH,
 			 original_part_count, part_count);
 		return -1;
 	}
-	return key_validate_parts(index->cmp_def, key, part_count, false);
+	return key_validate_parts(lsm->cmp_def, key, part_count, false);
 }
 
 /**
- * Find a tuple in the primary index by the key of the specified
- * index.
- * @param index       Index for which the key is specified. Can be
- *                    both primary and secondary.
+ * Find a tuple in the primary index LSM tree by the key of the
+ * specified LSM tree.
+ * @param lsm         LSM tree for which the key is specified.
+ *                    Can be both primary and secondary.
  * @param tx          Current transaction.
  * @param rv          Read view.
  * @param key_raw     MessagePack'ed data, the array without a
@@ -1589,36 +1588,36 @@ vy_unique_key_validate(struct vy_index *index, const char *key,
  * @retval -1 Memory error.
  */
 static inline int
-vy_index_full_by_key(struct vy_index *index, struct vy_tx *tx,
-		     const struct vy_read_view **rv,
-		     const char *key_raw, uint32_t part_count,
-		     struct tuple **result)
+vy_lsm_full_by_key(struct vy_lsm *lsm, struct vy_tx *tx,
+		   const struct vy_read_view **rv,
+		   const char *key_raw, uint32_t part_count,
+		   struct tuple **result)
 {
 	int rc;
-	struct tuple *key = vy_stmt_new_select(index->env->key_format,
+	struct tuple *key = vy_stmt_new_select(lsm->env->key_format,
 					       key_raw, part_count);
 	if (key == NULL)
 		return -1;
 	struct tuple *found;
-	rc = vy_index_get(index, tx, rv, key, &found);
+	rc = vy_lsm_get(lsm, tx, rv, key, &found);
 	tuple_unref(key);
 	if (rc != 0)
 		return -1;
-	if (index->index_id == 0 || found == NULL) {
+	if (lsm->index_id == 0 || found == NULL) {
 		*result = found;
 		return 0;
 	}
 	/*
 	 * No need in vy_tx_track() as the tuple is already
-	 * tracked in the secondary index.
+	 * tracked in the secondary index LSM tree.
 	 */
-	rc = vy_point_lookup(index->pk, tx, rv, found, result);
+	rc = vy_point_lookup(lsm->pk, tx, rv, found, result);
 	tuple_unref(found);
 	return rc;
 }
 
 /**
- * Delete the tuple from all indexes of the vinyl space.
+ * Delete the tuple from all LSM trees of the vinyl space.
  * @param env        Vinyl environment.
  * @param tx         Current transaction.
  * @param space      Vinyl space.
@@ -1631,7 +1630,7 @@ static inline int
 vy_delete_impl(struct vy_env *env, struct vy_tx *tx, struct space *space,
 	       const struct tuple *tuple)
 {
-	struct vy_index *pk = vy_index_find(space, 0);
+	struct vy_lsm *pk = vy_lsm_find(space, 0);
 	if (pk == NULL)
 		return -1;
 	/* Primary key is dumped last. */
@@ -1644,12 +1643,11 @@ vy_delete_impl(struct vy_env *env, struct vy_tx *tx, struct space *space,
 		goto error;
 
 	/* At second, delete from seconary indexes. */
-	struct vy_index *index;
 	for (uint32_t i = 1; i < space->index_count; ++i) {
-		index = vy_index(space->index[i]);
-		if (vy_is_committed_one(env, index))
+		struct vy_lsm *lsm = vy_lsm(space->index[i]);
+		if (vy_is_committed_one(env, lsm))
 			continue;
-		if (vy_tx_set(tx, index, delete) != 0)
+		if (vy_tx_set(tx, lsm, delete) != 0)
 			goto error;
 	}
 	tuple_unref(delete);
@@ -1678,16 +1676,16 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 {
 	if (vy_is_committed(env, space))
 		return 0;
-	struct vy_index *pk = vy_index_find(space, 0);
+	struct vy_lsm *pk = vy_lsm_find(space, 0);
 	if (pk == NULL)
 		return -1;
-	struct vy_index *index = vy_index_find_unique(space, request->index_id);
-	if (index == NULL)
+	struct vy_lsm *lsm = vy_lsm_find_unique(space, request->index_id);
+	if (lsm == NULL)
 		return -1;
 	bool has_secondary = space->index_count > 1;
 	const char *key = request->key;
 	uint32_t part_count = mp_decode_array(&key);
-	if (vy_unique_key_validate(index, key, part_count))
+	if (vy_unique_key_validate(lsm, key, part_count))
 		return -1;
 	/*
 	 * There are two cases when need to get the full tuple
@@ -1700,7 +1698,7 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 	 *   and pass them to indexes for deletion.
 	 */
 	if (has_secondary || !rlist_empty(&space->on_replace)) {
-		if (vy_index_full_by_key(index, tx, vy_tx_read_view(tx),
+		if (vy_lsm_full_by_key(lsm, tx, vy_tx_read_view(tx),
 				key, part_count, &stmt->old_tuple) != 0)
 			return -1;
 		if (stmt->old_tuple == NULL)
@@ -1710,7 +1708,7 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 		assert(stmt->old_tuple != NULL);
 		return vy_delete_impl(env, tx, space, stmt->old_tuple);
 	} else { /* Primary is the single index in the space. */
-		assert(index->index_id == 0);
+		assert(lsm->index_id == 0);
 		struct tuple *delete =
 			vy_stmt_new_surrogate_delete_from_key(request->key,
 							      pk->key_def,
@@ -1730,9 +1728,7 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
  * primary key of a tuple, which is prohibited, to avoid funny
  * effects during replication.
  *
- * @param pk         Primary index.
- * @param index_name Name of the index which was updated - it may
- *                   be not the primary index.
+ * @param pk         Primary index LSM tree.
  * @param old_tuple  The tuple before update.
  * @param new_tuple  The tuple after update.
  * @param column_mask Bitmask of the update operation.
@@ -1742,7 +1738,7 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
  * @retval -1 Attempt to modify the primary key.
  */
 static inline int
-vy_check_update(struct space *space, const struct vy_index *pk,
+vy_check_update(struct space *space, const struct vy_lsm *pk,
 		const struct tuple *old_tuple, const struct tuple *new_tuple,
 		uint64_t column_mask)
 {
@@ -1776,23 +1772,23 @@ vy_update(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 	assert(tx != NULL && tx->state == VINYL_TX_READY);
 	if (vy_is_committed(env, space))
 		return 0;
-	struct vy_index *index = vy_index_find_unique(space, request->index_id);
-	if (index == NULL)
+	struct vy_lsm *lsm = vy_lsm_find_unique(space, request->index_id);
+	if (lsm == NULL)
 		return -1;
 	const char *key = request->key;
 	uint32_t part_count = mp_decode_array(&key);
-	if (vy_unique_key_validate(index, key, part_count))
+	if (vy_unique_key_validate(lsm, key, part_count))
 		return -1;
 
-	if (vy_index_full_by_key(index, tx, vy_tx_read_view(tx),
-				 key, part_count, &stmt->old_tuple) != 0)
+	if (vy_lsm_full_by_key(lsm, tx, vy_tx_read_view(tx),
+			       key, part_count, &stmt->old_tuple) != 0)
 		return -1;
 	/* Nothing to update. */
 	if (stmt->old_tuple == NULL)
 		return 0;
 
 	/* Apply update operations. */
-	struct vy_index *pk = vy_index(space->index[0]);
+	struct vy_lsm *pk = vy_lsm(space->index[0]);
 	assert(pk != NULL);
 	assert(pk->index_id == 0);
 	/* Primary key is dumped last. */
@@ -1849,12 +1845,12 @@ vy_update(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 	vy_stmt_set_column_mask(delete, column_mask);
 
 	for (uint32_t i = 1; i < space->index_count; ++i) {
-		index = vy_index(space->index[i]);
-		if (vy_is_committed_one(env, index))
+		lsm = vy_lsm(space->index[i]);
+		if (vy_is_committed_one(env, lsm))
 			continue;
-		if (vy_tx_set(tx, index, delete) != 0)
+		if (vy_tx_set(tx, lsm, delete) != 0)
 			goto error;
-		if (vy_insert_secondary(env, tx, space, index, stmt->new_tuple))
+		if (vy_insert_secondary(env, tx, space, lsm, stmt->new_tuple))
 			goto error;
 	}
 	tuple_unref(delete);
@@ -1882,14 +1878,13 @@ vy_insert_first_upsert(struct vy_env *env, struct vy_tx *tx,
 	assert(tx != NULL && tx->state == VINYL_TX_READY);
 	assert(space->index_count > 0);
 	assert(vy_stmt_type(stmt) == IPROTO_INSERT);
-	struct vy_index *pk = vy_index(space->index[0]);
+	struct vy_lsm *pk = vy_lsm(space->index[0]);
 	assert(pk->index_id == 0);
 	if (vy_tx_set(tx, pk, stmt) != 0)
 		return -1;
-	struct vy_index *index;
 	for (uint32_t i = 1; i < space->index_count; ++i) {
-		index = vy_index(space->index[i]);
-		if (vy_insert_secondary(env, tx, space, index, stmt) != 0)
+		struct vy_lsm *lsm = vy_lsm(space->index[i]);
+		if (vy_insert_secondary(env, tx, space, lsm, stmt) != 0)
 			return -1;
 	}
 	return 0;
@@ -1898,7 +1893,7 @@ vy_insert_first_upsert(struct vy_env *env, struct vy_tx *tx,
 /**
  * Insert UPSERT into the write set of the transaction.
  * @param tx        Transaction which deletes.
- * @param index     Index in which \p tx deletes.
+ * @param lsm       LSM tree in which \p tx deletes.
  * @param tuple     MessagePack array.
  * @param tuple_end End of the tuple.
  * @param expr      MessagePack array of update operations.
@@ -1908,7 +1903,7 @@ vy_insert_first_upsert(struct vy_env *env, struct vy_tx *tx,
  * @retval -1 Memory error.
  */
 static int
-vy_index_upsert(struct vy_tx *tx, struct vy_index *index,
+vy_lsm_upsert(struct vy_tx *tx, struct vy_lsm *lsm,
 	  const char *tuple, const char *tuple_end,
 	  const char *expr, const char *expr_end)
 {
@@ -1917,12 +1912,12 @@ vy_index_upsert(struct vy_tx *tx, struct vy_index *index,
 	struct iovec operations[1];
 	operations[0].iov_base = (void *)expr;
 	operations[0].iov_len = expr_end - expr;
-	vystmt = vy_stmt_new_upsert(index->upsert_format, tuple, tuple_end,
+	vystmt = vy_stmt_new_upsert(lsm->upsert_format, tuple, tuple_end,
 				    operations, 1);
 	if (vystmt == NULL)
 		return -1;
 	assert(vy_stmt_type(vystmt) == IPROTO_UPSERT);
-	int rc = vy_tx_set(tx, index, vystmt);
+	int rc = vy_tx_set(tx, lsm, vystmt);
 	tuple_unref(vystmt);
 	return rc;
 }
@@ -2030,7 +2025,7 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 	const char *tuple_end = request->tuple_end;
 	const char *ops = request->ops;
 	const char *ops_end = request->ops_end;
-	struct vy_index *pk = vy_index_find(space, 0);
+	struct vy_lsm *pk = vy_lsm_find(space, 0);
 	if (pk == NULL)
 		return -1;
 	/* Primary key is dumped last. */
@@ -2039,7 +2034,7 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 		return -1;
 
 	if (space->index_count == 1 && rlist_empty(&space->on_replace))
-		return vy_index_upsert(tx, pk, tuple, tuple_end, ops, ops_end);
+		return vy_lsm_upsert(tx, pk, tuple, tuple_end, ops, ops_end);
 
 	const char *old_tuple, *old_tuple_end;
 	const char *new_tuple, *new_tuple_end;
@@ -2059,7 +2054,7 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 					pk->key_def, pk->env->key_format);
 	if (key == NULL)
 		return -1;
-	int rc = vy_index_get(pk, tx, vy_tx_read_view(tx),
+	int rc = vy_lsm_get(pk, tx, vy_tx_read_view(tx),
 			      key, &stmt->old_tuple);
 	tuple_unref(key);
 	if (rc != 0)
@@ -2111,7 +2106,7 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 		diag_log();
 		/*
 		 * Upsert is skipped, to match the semantics of
-		 * vy_index_upsert().
+		 * vy_lsm_upsert().
 		 */
 		return 0;
 	}
@@ -2121,7 +2116,6 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 		return 0;
 
 	/* Replace in secondary indexes works as delete insert. */
-	struct vy_index *index;
 	struct tuple *delete = vy_stmt_new_surrogate_delete(mask_format,
 							    stmt->old_tuple);
 	if (delete == NULL)
@@ -2129,12 +2123,12 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 	vy_stmt_set_column_mask(delete, column_mask);
 
 	for (uint32_t i = 1; i < space->index_count; ++i) {
-		index = vy_index(space->index[i]);
-		if (vy_is_committed_one(env, index))
+		struct vy_lsm *lsm = vy_lsm(space->index[i]);
+		if (vy_is_committed_one(env, lsm))
 			continue;
-		if (vy_tx_set(tx, index, delete) != 0)
+		if (vy_tx_set(tx, lsm, delete) != 0)
 			goto error;
-		if (vy_insert_secondary(env, tx, space, index,
+		if (vy_insert_secondary(env, tx, space, lsm,
 					stmt->new_tuple) != 0)
 			goto error;
 	}
@@ -2164,7 +2158,7 @@ vy_insert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 	  struct space *space, struct request *request)
 {
 	assert(stmt != NULL);
-	struct vy_index *pk = vy_index_find(space, 0);
+	struct vy_lsm *pk = vy_lsm_find(space, 0);
 	if (pk == NULL)
 		/* The space hasn't the primary index. */
 		return -1;
@@ -2182,10 +2176,10 @@ vy_insert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt,
 		return -1;
 
 	for (uint32_t iid = 1; iid < space->index_count; ++iid) {
-		struct vy_index *index = vy_index(space->index[iid]);
-		if (vy_is_committed_one(env, index))
+		struct vy_lsm *lsm = vy_lsm(space->index[iid]);
+		if (vy_is_committed_one(env, lsm))
 			continue;
-		if (vy_insert_secondary(env, tx, space, index,
+		if (vy_insert_secondary(env, tx, space, lsm,
 					stmt->new_tuple) != 0)
 			return -1;
 	}
@@ -2544,7 +2538,7 @@ vy_squash_queue_new(void);
 static void
 vy_squash_queue_delete(struct vy_squash_queue *q);
 static void
-vy_squash_schedule(struct vy_index *index, struct tuple *stmt,
+vy_squash_schedule(struct vy_lsm *lsm, struct tuple *stmt,
 		   void /* struct vy_env */ *arg);
 
 static struct vy_env *
@@ -2610,10 +2604,10 @@ vy_env_new(const char *path, size_t memory,
 			    vy_env_dump_complete_cb,
 			    &e->run_env, &e->xm->read_views);
 
-	if (vy_index_env_create(&e->index_env, e->path,
-				&e->scheduler.generation,
-				vy_squash_schedule, e) != 0)
-		goto error_index_env;
+	if (vy_lsm_env_create(&e->lsm_env, e->path,
+			      &e->scheduler.generation,
+			      vy_squash_schedule, e) != 0)
+		goto error_lsm_env;
 
 	struct slab_cache *slab_cache = cord_slab_cache();
 	mempool_create(&e->iterator_pool, slab_cache,
@@ -2627,7 +2621,7 @@ vy_env_new(const char *path, size_t memory,
 	vy_run_env_create(&e->run_env);
 	vy_log_init(e->path);
 	return e;
-error_index_env:
+error_lsm_env:
 	vy_mem_env_destroy(&e->mem_env);
 	vy_scheduler_destroy(&e->scheduler);
 	vy_squash_queue_delete(e->squash_queue);
@@ -2653,7 +2647,7 @@ vy_env_delete(struct vy_env *e)
 	histogram_delete(e->dump_bw);
 	mempool_destroy(&e->iterator_pool);
 	vy_run_env_destroy(&e->run_env);
-	vy_index_env_destroy(&e->index_env);
+	vy_lsm_env_destroy(&e->lsm_env);
 	vy_mem_env_destroy(&e->mem_env);
 	vy_cache_env_destroy(&e->cache_env);
 	vy_quota_destroy(&e->quota);
@@ -2719,7 +2713,7 @@ vinyl_engine_set_too_long_threshold(struct vinyl_engine *vinyl,
 				    double too_long_threshold)
 {
 	vinyl->env->quota.too_long_threshold = too_long_threshold;
-	vinyl->env->index_env.too_long_threshold = too_long_threshold;
+	vinyl->env->lsm_env.too_long_threshold = too_long_threshold;
 }
 
 /** }}} Environment */
@@ -2857,11 +2851,11 @@ vinyl_engine_end_recovery(struct engine *engine)
 		unreachable();
 	}
 	/*
-	 * Do not start reader threads if no Vinyl index was
-	 * recovered. The threads will be started lazily upon
-	 * the first index creation, see vy_index_open().
+	 * Do not start reader threads if no LSM tree was recovered.
+	 * The threads will be started lazily upon the first LSM tree
+	 * creation, see vinyl_index_open().
 	 */
-	if (e->index_env.index_count > 0)
+	if (e->lsm_env.lsm_count > 0)
 		vy_run_env_enable_coio(&e->run_env, e->read_threads);
 	return 0;
 }
@@ -2888,14 +2882,14 @@ struct vy_join_ctx {
 	/** ID of the space currently being relayed. */
 	uint32_t space_id;
 	/**
-	 * Index key definition, as defined by the user.
+	 * LSM tree key definition, as defined by the user.
 	 * We only send the primary key, so the definition
 	 * provided by the user is correct for compare.
 	 */
 	struct key_def *key_def;
-	/** Index format used for REPLACE and DELETE statements. */
+	/** LSM tree format used for REPLACE and DELETE statements. */
 	struct tuple_format *format;
-	/** Index format used for UPSERT statements. */
+	/** LSM tree format used for UPSERT statements. */
 	struct tuple_format *upsert_format;
 	/**
 	 * Write iterator for merging runs before sending
@@ -2930,13 +2924,13 @@ vy_prepare_send_slice(struct vy_join_ctx *ctx,
 		goto out;
 
 	if (slice_info->begin != NULL) {
-		begin = vy_key_from_msgpack(ctx->env->index_env.key_format,
+		begin = vy_key_from_msgpack(ctx->env->lsm_env.key_format,
 					    slice_info->begin);
 		if (begin == NULL)
 			goto out;
 	}
 	if (slice_info->end != NULL) {
-		end = vy_key_from_msgpack(ctx->env->index_env.key_format,
+		end = vy_key_from_msgpack(ctx->env->lsm_env.key_format,
 					  slice_info->end);
 		if (end == NULL)
 			goto out;
@@ -3043,28 +3037,27 @@ out:
 	return rc;
 }
 
-/** Send all tuples stored in the given index. */
+/** Send all tuples stored in the given LSM tree. */
 static int
-vy_send_index(struct vy_join_ctx *ctx,
-	      struct vy_index_recovery_info *index_info)
+vy_send_lsm(struct vy_join_ctx *ctx, struct vy_lsm_recovery_info *lsm_info)
 {
 	int rc = -1;
 
-	if (index_info->is_dropped)
+	if (lsm_info->is_dropped)
 		return 0;
 
 	/*
-	 * We are only interested in the primary index.
+	 * We are only interested in the primary index LSM tree.
 	 * Secondary keys will be rebuilt on the destination.
 	 */
-	if (index_info->index_id != 0)
+	if (lsm_info->index_id != 0)
 		return 0;
 
-	ctx->space_id = index_info->space_id;
+	ctx->space_id = lsm_info->space_id;
 
 	/* Create key definition and tuple format. */
-	ctx->key_def = key_def_new_with_parts(index_info->key_parts,
-					      index_info->key_part_count);
+	ctx->key_def = key_def_new_with_parts(lsm_info->key_parts,
+					      lsm_info->key_part_count);
 	if (ctx->key_def == NULL)
 		goto out;
 	ctx->format = tuple_format_new(&vy_tuple_format_vtab, &ctx->key_def,
@@ -3079,8 +3072,8 @@ vy_send_index(struct vy_join_ctx *ctx,
 
 	/* Send ranges. */
 	struct vy_range_recovery_info *range_info;
-	assert(!rlist_empty(&index_info->ranges));
-	rlist_foreach_entry(range_info, &index_info->ranges, in_index) {
+	assert(!rlist_empty(&lsm_info->ranges));
+	rlist_foreach_entry(range_info, &lsm_info->ranges, in_lsm) {
 		rc = vy_send_range(ctx, range_info);
 		if (rc != 0)
 			break;
@@ -3156,9 +3149,9 @@ vinyl_engine_join(struct engine *engine, struct vclock *vclock,
 		goto out_join_cord;
 	}
 	rc = 0;
-	struct vy_index_recovery_info *index_info;
-	rlist_foreach_entry(index_info, &recovery->indexes, in_recovery) {
-		rc = vy_send_index(ctx, index_info);
+	struct vy_lsm_recovery_info *lsm_info;
+	rlist_foreach_entry(lsm_info, &recovery->lsms, in_recovery) {
+		rc = vy_send_lsm(ctx, lsm_info);
 		if (rc != 0)
 			break;
 	}
@@ -3251,7 +3244,7 @@ vinyl_space_apply_initial_join_row(struct space *space, struct request *request)
  */
 static void
 vy_gc_run(struct vy_env *env,
-	  struct vy_index_recovery_info *index_info,
+	  struct vy_lsm_recovery_info *lsm_info,
 	  struct vy_run_recovery_info *run_info)
 {
 	ERROR_INJECT(ERRINJ_VY_GC,
@@ -3259,8 +3252,8 @@ vy_gc_run(struct vy_env *env,
 				(long long)run_info->id); return;});
 
 	/* Try to delete files. */
-	if (vy_run_remove_files(env->path, index_info->space_id,
-				index_info->index_id, run_info->id) != 0)
+	if (vy_run_remove_files(env->path, lsm_info->space_id,
+				lsm_info->index_id, run_info->id) != 0)
 		return;
 
 	/* Forget the run on success. */
@@ -3287,16 +3280,16 @@ vy_gc(struct vy_env *env, struct vy_recovery *recovery,
       unsigned int gc_mask, int64_t gc_lsn)
 {
 	int loops = 0;
-	struct vy_index_recovery_info *index_info;
-	rlist_foreach_entry(index_info, &recovery->indexes, in_recovery) {
+	struct vy_lsm_recovery_info *lsm_info;
+	rlist_foreach_entry(lsm_info, &recovery->lsms, in_recovery) {
 		struct vy_run_recovery_info *run_info;
-		rlist_foreach_entry(run_info, &index_info->runs, in_index) {
+		rlist_foreach_entry(run_info, &lsm_info->runs, in_lsm) {
 			if ((run_info->is_dropped &&
 			     run_info->gc_lsn < gc_lsn &&
 			     (gc_mask & VY_GC_DROPPED) != 0) ||
 			    (run_info->is_incomplete &&
 			     (gc_mask & VY_GC_INCOMPLETE) != 0)) {
-				vy_gc_run(env, index_info, run_info);
+				vy_gc_run(env, lsm_info, run_info);
 			}
 			if (loops % VY_YIELD_LOOPS == 0)
 				fiber_sleep(0);
@@ -3350,20 +3343,20 @@ vinyl_engine_backup(struct engine *engine, struct vclock *vclock,
 	}
 	int rc = 0;
 	int loops = 0;
-	struct vy_index_recovery_info *index_info;
-	rlist_foreach_entry(index_info, &recovery->indexes, in_recovery) {
-		if (index_info->is_dropped)
+	struct vy_lsm_recovery_info *lsm_info;
+	rlist_foreach_entry(lsm_info, &recovery->lsms, in_recovery) {
+		if (lsm_info->is_dropped)
 			continue;
 		struct vy_run_recovery_info *run_info;
-		rlist_foreach_entry(run_info, &index_info->runs, in_index) {
+		rlist_foreach_entry(run_info, &lsm_info->runs, in_lsm) {
 			if (run_info->is_dropped || run_info->is_incomplete)
 				continue;
 			char path[PATH_MAX];
 			for (int type = 0; type < vy_file_MAX; type++) {
 				vy_run_snprint_path(path, sizeof(path),
 						    env->path,
-						    index_info->space_id,
-						    index_info->index_id,
+						    lsm_info->space_id,
+						    lsm_info->index_id,
 						    run_info->id, type);
 				rc = cb(path, cb_arg);
 				if (rc != 0)
@@ -3390,8 +3383,8 @@ struct vy_squash {
 	struct stailq_entry next;
 	/** Vinyl environment. */
 	struct vy_env *env;
-	/** Index this request is for. */
-	struct vy_index *index;
+	/** LSM tree this request is for. */
+	struct vy_lsm *lsm;
 	/** Key to squash upserts for. */
 	struct tuple *stmt;
 };
@@ -3409,15 +3402,15 @@ struct vy_squash_queue {
 
 static struct vy_squash *
 vy_squash_new(struct mempool *pool, struct vy_env *env,
-	      struct vy_index *index, struct tuple *stmt)
+	      struct vy_lsm *lsm, struct tuple *stmt)
 {
 	struct vy_squash *squash;
 	squash = mempool_alloc(pool);
 	if (squash == NULL)
 		return NULL;
 	squash->env = env;
-	vy_index_ref(index);
-	squash->index = index;
+	vy_lsm_ref(lsm);
+	squash->lsm = lsm;
 	tuple_ref(stmt);
 	squash->stmt = stmt;
 	return squash;
@@ -3426,7 +3419,7 @@ vy_squash_new(struct mempool *pool, struct vy_env *env,
 static void
 vy_squash_delete(struct mempool *pool, struct vy_squash *squash)
 {
-	vy_index_unref(squash->index);
+	vy_lsm_unref(squash->lsm);
 	tuple_unref(squash->stmt);
 	mempool_free(pool, squash);
 }
@@ -3438,23 +3431,23 @@ vy_squash_process(struct vy_squash *squash)
 	if (inj != NULL && inj->dparam > 0)
 		fiber_sleep(inj->dparam);
 
-	struct vy_index *index = squash->index;
+	struct vy_lsm *lsm = squash->lsm;
 	struct vy_env *env = squash->env;
 	/*
 	 * vy_apply_upsert() is used for primary key only,
-	 * so this is the same as index->key_def
+	 * so this is the same as lsm->key_def
 	 */
-	struct key_def *def = index->cmp_def;
+	struct key_def *def = lsm->cmp_def;
 
-	/* Upserts enabled only in the primary index. */
-	assert(index->index_id == 0);
+	/* Upserts enabled only in the primary index LSM tree. */
+	assert(lsm->index_id == 0);
 
 	/*
 	 * Use the committed read view to avoid squashing
 	 * prepared, but not committed statements.
 	 */
 	struct tuple *result;
-	if (vy_point_lookup(index, NULL, &env->xm->p_committed_read_view,
+	if (vy_point_lookup(lsm, NULL, &env->xm->p_committed_read_view,
 			    squash->stmt, &result) != 0)
 		return -1;
 	if (result == NULL)
@@ -3465,7 +3458,7 @@ vy_squash_process(struct vy_squash *squash)
 	 * have been inserted into the in-memory tree. Apply them to
 	 * the result.
 	 */
-	struct vy_mem *mem = index->mem;
+	struct vy_mem *mem = lsm->mem;
 	struct tree_mem_key tree_key = {
 		.stmt = result,
 		.lsn = vy_stmt_lsn(result),
@@ -3501,7 +3494,7 @@ vy_squash_process(struct vy_squash *squash)
 	 * lsns = {1, 2, 3} are squashed. But now the n_upsert
 	 * values in the prepared statements are not correct.
 	 * If we will not update values, then the
-	 * vy_index_commit_upsert will not be able to squash them.
+	 * vy_lsm_commit_upsert will not be able to squash them.
 	 *
 	 * So after squashing it is necessary to update n_upsert
 	 * value in the prepared statements:
@@ -3542,11 +3535,11 @@ vy_squash_process(struct vy_squash *squash)
 			tuple_unref(result);
 			return 0;
 		}
-		assert(index->index_id == 0);
+		assert(lsm->index_id == 0);
 		struct tuple *applied =
 			vy_apply_upsert(mem_stmt, result, def, mem->format,
 					mem->upsert_format, true);
-		index->stat.upsert.applied++;
+		lsm->stat.upsert.applied++;
 		tuple_unref(result);
 		if (applied == NULL)
 			return -1;
@@ -3584,7 +3577,7 @@ vy_squash_process(struct vy_squash *squash)
 		}
 	}
 
-	index->stat.upsert.squashed++;
+	lsm->stat.upsert.squashed++;
 
 	/*
 	 * Insert the resulting REPLACE statement to the mem
@@ -3592,7 +3585,7 @@ vy_squash_process(struct vy_squash *squash)
 	 */
 	size_t mem_used_before = lsregion_used(&env->mem_env.allocator);
 	const struct tuple *region_stmt = NULL;
-	int rc = vy_index_set(index, mem, result, &region_stmt);
+	int rc = vy_lsm_set(lsm, mem, result, &region_stmt);
 	tuple_unref(result);
 	size_t mem_used_after = lsregion_used(&env->mem_env.allocator);
 	assert(mem_used_after >= mem_used_before);
@@ -3661,13 +3654,13 @@ vy_squash_queue_f(va_list va)
  * statement after it. Done in a background fiber.
  */
 static void
-vy_squash_schedule(struct vy_index *index, struct tuple *stmt, void *arg)
+vy_squash_schedule(struct vy_lsm *lsm, struct tuple *stmt, void *arg)
 {
 	struct vy_env *env = arg;
 	struct vy_squash_queue *sq = env->squash_queue;
 
 	say_verbose("%s: schedule upsert optimization for %s",
-		    vy_index_name(index), vy_stmt_str(stmt));
+		    vy_lsm_name(lsm), vy_stmt_str(stmt));
 
 	/* Start the upsert squashing fiber on demand. */
 	if (sq->fiber == NULL) {
@@ -3677,7 +3670,7 @@ vy_squash_schedule(struct vy_index *index, struct tuple *stmt, void *arg)
 		fiber_start(sq->fiber, sq);
 	}
 
-	struct vy_squash *squash = vy_squash_new(&sq->pool, env, index, stmt);
+	struct vy_squash *squash = vy_squash_new(&sq->pool, env, lsm, stmt);
 	if (squash == NULL)
 		goto fail;
 
@@ -3712,8 +3705,8 @@ static void
 vinyl_iterator_close(struct vinyl_iterator *it)
 {
 	vy_read_iterator_close(&it->iterator);
-	vy_index_unref(it->index);
-	it->index = NULL;
+	vy_lsm_unref(it->lsm);
+	it->lsm = NULL;
 	tuple_unref(it->key);
 	it->key = NULL;
 	if (it->tx == &it->tx_autocommit) {
@@ -3736,7 +3729,7 @@ vinyl_iterator_primary_next(struct iterator *base, struct tuple **ret)
 {
 	assert(base->next = vinyl_iterator_primary_next);
 	struct vinyl_iterator *it = (struct vinyl_iterator *)base;
-	assert(it->index->index_id == 0);
+	assert(it->lsm->index_id == 0);
 	struct tuple *tuple;
 
 	if (it->tx == NULL) {
@@ -3770,7 +3763,7 @@ vinyl_iterator_secondary_next(struct iterator *base, struct tuple **ret)
 {
 	assert(base->next = vinyl_iterator_secondary_next);
 	struct vinyl_iterator *it = (struct vinyl_iterator *)base;
-	assert(it->index->index_id > 0);
+	assert(it->lsm->index_id > 0);
 	struct tuple *tuple;
 
 	if (it->tx == NULL) {
@@ -3805,7 +3798,7 @@ vinyl_iterator_secondary_next(struct iterator *base, struct tuple **ret)
 	 * Note, there's no need in vy_tx_track() as the
 	 * tuple is already tracked in the secondary index.
 	 */
-	if (vy_point_lookup(it->index->pk, it->tx, vy_tx_read_view(it->tx),
+	if (vy_point_lookup(it->lsm->pk, it->tx, vy_tx_read_view(it->tx),
 			    tuple, &tuple) != 0)
 		goto fail;
 	*ret = tuple_bless(tuple);
@@ -3831,7 +3824,7 @@ static struct iterator *
 vinyl_index_create_iterator(struct index *base, enum iterator_type type,
 			    const char *key, uint32_t part_count)
 {
-	struct vy_index *index = vy_index(base);
+	struct vy_lsm *lsm = vy_lsm(base);
 	struct vy_env *env = vy_env(base->engine);
 
 	if (type > ITER_GT) {
@@ -3846,22 +3839,22 @@ vinyl_index_create_iterator(struct index *base, enum iterator_type type,
 			 "mempool", "struct vinyl_iterator");
 		return NULL;
 	}
-	it->key = vy_stmt_new_select(index->env->key_format, key, part_count);
+	it->key = vy_stmt_new_select(lsm->env->key_format, key, part_count);
 	if (it->key == NULL) {
 		mempool_free(&env->iterator_pool, it);
 		return NULL;
 	}
 
 	iterator_create(&it->base, base);
-	if (index->index_id == 0)
+	if (lsm->index_id == 0)
 		it->base.next = vinyl_iterator_primary_next;
 	else
 		it->base.next = vinyl_iterator_secondary_next;
 	it->base.free = vinyl_iterator_free;
 
 	it->env = env;
-	it->index = index;
-	vy_index_ref(index);
+	it->lsm = lsm;
+	vy_lsm_ref(lsm);
 
 	struct vy_tx *tx = in_txn() ? in_txn()->engine_tx : NULL;
 	assert(tx == NULL || tx->state == VINYL_TX_READY);
@@ -3879,26 +3872,26 @@ vinyl_index_create_iterator(struct index *base, enum iterator_type type,
 	}
 	it->tx = tx;
 
-	vy_read_iterator_open(&it->iterator, index, tx, type, it->key,
+	vy_read_iterator_open(&it->iterator, lsm, tx, type, it->key,
 			      (const struct vy_read_view **)&tx->read_view);
 	return (struct iterator *)it;
 }
 
 static int
-vinyl_index_get(struct index *base, const char *key,
+vinyl_index_get(struct index *index, const char *key,
 		uint32_t part_count, struct tuple **ret)
 {
-	assert(base->def->opts.is_unique);
-	assert(base->def->key_def->part_count == part_count);
+	assert(index->def->opts.is_unique);
+	assert(index->def->key_def->part_count == part_count);
 
-	struct vy_index *index = vy_index(base);
-	struct vy_env *env = vy_env(base->engine);
+	struct vy_lsm *lsm = vy_lsm(index);
+	struct vy_env *env = vy_env(index->engine);
 	struct vy_tx *tx = in_txn() ? in_txn()->engine_tx : NULL;
 	const struct vy_read_view **rv = (tx != NULL ? vy_tx_read_view(tx) :
 					  &env->xm->p_global_read_view);
 
 	struct tuple *tuple;
-	if (vy_index_full_by_key(index, tx, rv, key, part_count, &tuple) != 0)
+	if (vy_lsm_full_by_key(lsm, tx, rv, key, part_count, &tuple) != 0)
 		return -1;
 
 	if (tuple != NULL) {
diff --git a/src/box/vy_cache.h b/src/box/vy_cache.h
index fceda5a2..54fd2892 100644
--- a/src/box/vy_cache.h
+++ b/src/box/vy_cache.h
@@ -150,7 +150,7 @@ void
 vy_cache_env_set_quota(struct vy_cache_env *e, size_t quota);
 
 /**
- * Tuple cache (of one particular index)
+ * Tuple cache (of one particular LSM tree)
  */
 struct vy_cache {
 	/**
diff --git a/src/box/vy_log.c b/src/box/vy_log.c
index 0a5dd26e..a9fe68cc 100644
--- a/src/box/vy_log.c
+++ b/src/box/vy_log.c
@@ -68,13 +68,13 @@
  * Used for packing a record in MsgPack.
  */
 enum vy_log_key {
-	VY_LOG_KEY_INDEX_ID		= 0,
+	VY_LOG_KEY_LSM_ID		= 0,
 	VY_LOG_KEY_RANGE_ID		= 1,
 	VY_LOG_KEY_RUN_ID		= 2,
 	VY_LOG_KEY_BEGIN		= 3,
 	VY_LOG_KEY_END			= 4,
-	VY_LOG_KEY_INDEX_DEF_ID		= 5,
-	VY_LOG_KEY_SPACE_DEF_ID		= 6,
+	VY_LOG_KEY_INDEX_ID		= 5,
+	VY_LOG_KEY_SPACE_ID		= 6,
 	VY_LOG_KEY_DEF			= 7,
 	VY_LOG_KEY_SLICE_ID		= 8,
 	VY_LOG_KEY_DUMP_LSN		= 9,
@@ -85,13 +85,13 @@ enum vy_log_key {
 
 /** vy_log_key -> human readable name. */
 static const char *vy_log_key_name[] = {
-	[VY_LOG_KEY_INDEX_ID]		= "index_id",
+	[VY_LOG_KEY_LSM_ID]		= "lsm_id",
 	[VY_LOG_KEY_RANGE_ID]		= "range_id",
 	[VY_LOG_KEY_RUN_ID]		= "run_id",
 	[VY_LOG_KEY_BEGIN]		= "begin",
 	[VY_LOG_KEY_END]		= "end",
-	[VY_LOG_KEY_INDEX_DEF_ID]	= "index_def_id",
-	[VY_LOG_KEY_SPACE_DEF_ID]	= "space_def_id",
+	[VY_LOG_KEY_INDEX_ID]		= "index_id",
+	[VY_LOG_KEY_SPACE_ID]		= "space_id",
 	[VY_LOG_KEY_DEF]		= "key_def",
 	[VY_LOG_KEY_SLICE_ID]		= "slice_id",
 	[VY_LOG_KEY_DUMP_LSN]		= "dump_lsn",
@@ -102,8 +102,8 @@ static const char *vy_log_key_name[] = {
 
 /** vy_log_type -> human readable name. */
 static const char *vy_log_type_name[] = {
-	[VY_LOG_CREATE_INDEX]		= "create_index",
-	[VY_LOG_DROP_INDEX]		= "drop_index",
+	[VY_LOG_CREATE_LSM]		= "create_lsm",
+	[VY_LOG_DROP_LSM]		= "drop_lsm",
 	[VY_LOG_INSERT_RANGE]		= "insert_range",
 	[VY_LOG_DELETE_RANGE]		= "delete_range",
 	[VY_LOG_PREPARE_RUN]		= "prepare_run",
@@ -112,9 +112,9 @@ static const char *vy_log_type_name[] = {
 	[VY_LOG_FORGET_RUN]		= "forget_run",
 	[VY_LOG_INSERT_SLICE]		= "insert_slice",
 	[VY_LOG_DELETE_SLICE]		= "delete_slice",
-	[VY_LOG_DUMP_INDEX]		= "dump_index",
+	[VY_LOG_DUMP_LSM]		= "dump_lsm",
 	[VY_LOG_SNAPSHOT]		= "snapshot",
-	[VY_LOG_TRUNCATE_INDEX]		= "truncate_index",
+	[VY_LOG_TRUNCATE_LSM]		= "truncate_lsm",
 };
 
 /** Metadata log object. */
@@ -209,10 +209,9 @@ vy_log_record_snprint(char *buf, int size, const struct vy_log_record *record)
 	assert(record->type < vy_log_record_type_MAX);
 	SNPRINT(total, snprintf, buf, size, "%s{",
 		vy_log_type_name[record->type]);
-	if (record->index_id > 0)
+	if (record->lsm_id > 0)
 		SNPRINT(total, snprintf, buf, size, "%s=%"PRIi64", ",
-			vy_log_key_name[VY_LOG_KEY_INDEX_ID],
-			record->index_id);
+			vy_log_key_name[VY_LOG_KEY_LSM_ID], record->lsm_id);
 	if (record->range_id > 0)
 		SNPRINT(total, snprintf, buf, size, "%s=%"PRIi64", ",
 			vy_log_key_name[VY_LOG_KEY_RANGE_ID],
@@ -233,14 +232,12 @@ vy_log_record_snprint(char *buf, int size, const struct vy_log_record *record)
 		SNPRINT(total, mp_snprint, buf, size, record->end);
 		SNPRINT(total, snprintf, buf, size, ", ");
 	}
-	if (record->index_def_id > 0)
+	if (record->index_id > 0)
 		SNPRINT(total, snprintf, buf, size, "%s=%"PRIu32", ",
-			vy_log_key_name[VY_LOG_KEY_INDEX_DEF_ID],
-			record->index_def_id);
-	if (record->space_def_id > 0)
+			vy_log_key_name[VY_LOG_KEY_INDEX_ID], record->index_id);
+	if (record->space_id > 0)
 		SNPRINT(total, snprintf, buf, size, "%s=%"PRIu32", ",
-			vy_log_key_name[VY_LOG_KEY_SPACE_DEF_ID],
-			record->space_def_id);
+			vy_log_key_name[VY_LOG_KEY_SPACE_ID], record->space_id);
 	if (record->key_parts != NULL) {
 		SNPRINT(total, snprintf, buf, size, "%s=",
 			vy_log_key_name[VY_LOG_KEY_DEF]);
@@ -307,9 +304,9 @@ vy_log_record_encode(const struct vy_log_record *record,
 	size += mp_sizeof_array(2);
 	size += mp_sizeof_uint(record->type);
 	size_t n_keys = 0;
-	if (record->index_id > 0) {
-		size += mp_sizeof_uint(VY_LOG_KEY_INDEX_ID);
-		size += mp_sizeof_uint(record->index_id);
+	if (record->lsm_id > 0) {
+		size += mp_sizeof_uint(VY_LOG_KEY_LSM_ID);
+		size += mp_sizeof_uint(record->lsm_id);
 		n_keys++;
 	}
 	if (record->range_id > 0) {
@@ -338,14 +335,14 @@ vy_log_record_encode(const struct vy_log_record *record,
 		size += p - record->end;
 		n_keys++;
 	}
-	if (record->index_def_id > 0) {
-		size += mp_sizeof_uint(VY_LOG_KEY_INDEX_DEF_ID);
-		size += mp_sizeof_uint(record->index_def_id);
+	if (record->index_id > 0) {
+		size += mp_sizeof_uint(VY_LOG_KEY_INDEX_ID);
+		size += mp_sizeof_uint(record->index_id);
 		n_keys++;
 	}
-	if (record->space_def_id > 0) {
-		size += mp_sizeof_uint(VY_LOG_KEY_SPACE_DEF_ID);
-		size += mp_sizeof_uint(record->space_def_id);
+	if (record->space_id > 0) {
+		size += mp_sizeof_uint(VY_LOG_KEY_SPACE_ID);
+		size += mp_sizeof_uint(record->space_id);
 		n_keys++;
 	}
 	if (record->key_parts != NULL) {
@@ -389,9 +386,9 @@ vy_log_record_encode(const struct vy_log_record *record,
 	pos = mp_encode_array(pos, 2);
 	pos = mp_encode_uint(pos, record->type);
 	pos = mp_encode_map(pos, n_keys);
-	if (record->index_id > 0) {
-		pos = mp_encode_uint(pos, VY_LOG_KEY_INDEX_ID);
-		pos = mp_encode_uint(pos, record->index_id);
+	if (record->lsm_id > 0) {
+		pos = mp_encode_uint(pos, VY_LOG_KEY_LSM_ID);
+		pos = mp_encode_uint(pos, record->lsm_id);
 	}
 	if (record->range_id > 0) {
 		pos = mp_encode_uint(pos, VY_LOG_KEY_RANGE_ID);
@@ -415,13 +412,13 @@ vy_log_record_encode(const struct vy_log_record *record,
 		memcpy(pos, record->end, p - record->end);
 		pos += p - record->end;
 	}
-	if (record->index_def_id > 0) {
-		pos = mp_encode_uint(pos, VY_LOG_KEY_INDEX_DEF_ID);
-		pos = mp_encode_uint(pos, record->index_def_id);
+	if (record->index_id > 0) {
+		pos = mp_encode_uint(pos, VY_LOG_KEY_INDEX_ID);
+		pos = mp_encode_uint(pos, record->index_id);
 	}
-	if (record->space_def_id > 0) {
-		pos = mp_encode_uint(pos, VY_LOG_KEY_SPACE_DEF_ID);
-		pos = mp_encode_uint(pos, record->space_def_id);
+	if (record->space_id > 0) {
+		pos = mp_encode_uint(pos, VY_LOG_KEY_SPACE_ID);
+		pos = mp_encode_uint(pos, record->space_id);
 	}
 	if (record->key_parts != NULL) {
 		pos = mp_encode_uint(pos, VY_LOG_KEY_DEF);
@@ -504,8 +501,8 @@ vy_log_record_decode(struct vy_log_record *record,
 	for (uint32_t i = 0; i < n_keys; i++) {
 		uint32_t key = mp_decode_uint(&pos);
 		switch (key) {
-		case VY_LOG_KEY_INDEX_ID:
-			record->index_id = mp_decode_uint(&pos);
+		case VY_LOG_KEY_LSM_ID:
+			record->lsm_id = mp_decode_uint(&pos);
 			break;
 		case VY_LOG_KEY_RANGE_ID:
 			record->range_id = mp_decode_uint(&pos);
@@ -523,11 +520,11 @@ vy_log_record_decode(struct vy_log_record *record,
 			record->end = mp_decode_array(&tmp) > 0 ? pos : NULL;
 			mp_next(&pos);
 			break;
-		case VY_LOG_KEY_INDEX_DEF_ID:
-			record->index_def_id = mp_decode_uint(&pos);
+		case VY_LOG_KEY_INDEX_ID:
+			record->index_id = mp_decode_uint(&pos);
 			break;
-		case VY_LOG_KEY_SPACE_DEF_ID:
-			record->space_def_id = mp_decode_uint(&pos);
+		case VY_LOG_KEY_SPACE_ID:
+			record->space_id = mp_decode_uint(&pos);
 			break;
 		case VY_LOG_KEY_DEF: {
 			uint32_t part_count = mp_decode_array(&pos);
@@ -573,16 +570,16 @@ vy_log_record_decode(struct vy_log_record *record,
 			goto fail;
 		}
 	}
-	if (record->type == VY_LOG_CREATE_INDEX && record->commit_lsn == 0) {
+	if (record->type == VY_LOG_CREATE_LSM && record->commit_lsn == 0) {
 		/*
-		 * We used to use LSN as unique index identifier
+		 * We used to use LSN as unique LSM tree identifier
 		 * and didn't store LSN separately so if there's
 		 * no 'commit_lsn' field in the record, we are
 		 * recovering from an old vylog and 'id' is in
 		 * fact the LSN of the WAL record that committed
-		 * the index.
+		 * the LSM tree.
 		 */
-		record->commit_lsn = record->index_id;
+		record->commit_lsn = record->lsm_id;
 	}
 	return 0;
 fail:
@@ -1034,7 +1031,7 @@ vy_log_tx_do_commit(bool no_discard)
 
 	/*
 	 * During recovery, we may replay records we failed to commit
-	 * before restart (e.g. drop index). Since the log isn't open
+	 * before restart (e.g. drop LSM tree). Since the log isn't open
 	 * yet, simply leave them in the tx buffer to be flushed upon
 	 * recovery completion.
 	 */
@@ -1109,10 +1106,10 @@ vy_recovery_index_id_hash(uint32_t space_id, uint32_t index_id)
 	return ((uint64_t)space_id << 32) + index_id;
 }
 
-/** Lookup a vinyl index in vy_recovery::index_id_hash map. */
-struct vy_index_recovery_info *
-vy_recovery_index_by_id(struct vy_recovery *recovery,
-			uint32_t space_id, uint32_t index_id)
+/** Lookup an LSM tree in vy_recovery::index_id_hash map. */
+struct vy_lsm_recovery_info *
+vy_recovery_lsm_by_index_id(struct vy_recovery *recovery,
+			    uint32_t space_id, uint32_t index_id)
 {
 	int64_t key = vy_recovery_index_id_hash(space_id, index_id);
 	struct mh_i64ptr_t *h = recovery->index_id_hash;
@@ -1122,11 +1119,11 @@ vy_recovery_index_by_id(struct vy_recovery *recovery,
 	return mh_i64ptr_node(h, k)->val;
 }
 
-/** Lookup a vinyl index in vy_recovery::index_hash map. */
-static struct vy_index_recovery_info *
-vy_recovery_lookup_index(struct vy_recovery *recovery, int64_t id)
+/** Lookup an LSM tree in vy_recovery::index_hash map. */
+static struct vy_lsm_recovery_info *
+vy_recovery_lookup_lsm(struct vy_recovery *recovery, int64_t id)
 {
-	struct mh_i64ptr_t *h = recovery->index_hash;
+	struct mh_i64ptr_t *h = recovery->lsm_hash;
 	mh_int_t k = mh_i64ptr_find(h, id, NULL);
 	if (k == mh_end(h))
 		return NULL;
@@ -1167,18 +1164,18 @@ vy_recovery_lookup_slice(struct vy_recovery *recovery, int64_t slice_id)
 }
 
 /**
- * Handle a VY_LOG_CREATE_INDEX log record.
- * This function allocates a new vinyl index with ID @id
+ * Handle a VY_LOG_CREATE_LSM log record.
+ * This function allocates a new vinyl LSM tree with ID @id
  * and inserts it to the hash.
  * Return 0 on success, -1 on failure (ID collision or OOM).
  */
 static int
-vy_recovery_create_index(struct vy_recovery *recovery, int64_t id,
-			 uint32_t space_id, uint32_t index_id,
-			 const struct key_part_def *key_parts,
-			 uint32_t key_part_count, int64_t commit_lsn)
+vy_recovery_create_lsm(struct vy_recovery *recovery, int64_t id,
+		       uint32_t space_id, uint32_t index_id,
+		       const struct key_part_def *key_parts,
+		       uint32_t key_part_count, int64_t commit_lsn)
 {
-	struct vy_index_recovery_info *index;
+	struct vy_lsm_recovery_info *lsm;
 	struct key_part_def *key_parts_copy;
 	struct mh_i64ptr_node_t node;
 	struct mh_i64ptr_t *h;
@@ -1186,11 +1183,11 @@ vy_recovery_create_index(struct vy_recovery *recovery, int64_t id,
 
 	/*
 	 * Make a copy of the key definition to be used for
-	 * the new index incarnation.
+	 * the new LSM tree incarnation.
 	 */
 	if (key_parts == NULL) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-			 tt_sprintf("Missing key definition for index %lld",
+			 tt_sprintf("Missing key definition for LSM tree %lld",
 				    (long long)id));
 		return -1;
 	}
@@ -1203,77 +1200,77 @@ vy_recovery_create_index(struct vy_recovery *recovery, int64_t id,
 	memcpy(key_parts_copy, key_parts, sizeof(*key_parts) * key_part_count);
 
 	/*
-	 * Look up the index in the hash.
+	 * Look up the LSM tree in the hash.
 	 */
 	h = recovery->index_id_hash;
 	node.key = vy_recovery_index_id_hash(space_id, index_id);
 	k = mh_i64ptr_find(h, node.key, NULL);
-	index = (k != mh_end(h)) ? mh_i64ptr_node(h, k)->val : NULL;
+	lsm = (k != mh_end(h)) ? mh_i64ptr_node(h, k)->val : NULL;
 
-	if (index == NULL) {
+	if (lsm == NULL) {
 		/*
-		 * This is the first time the index is created
+		 * This is the first time the LSM tree is created
 		 * (there's no previous incarnation in the context).
-		 * Allocate a node for the index and add it to
+		 * Allocate a node for the LSM tree and add it to
 		 * the hash.
 		 */
-		index = malloc(sizeof(*index));
-		if (index == NULL) {
-			diag_set(OutOfMemory, sizeof(*index),
-				 "malloc", "struct vy_index_recovery_info");
+		lsm = malloc(sizeof(*lsm));
+		if (lsm == NULL) {
+			diag_set(OutOfMemory, sizeof(*lsm),
+				 "malloc", "struct vy_lsm_recovery_info");
 			free(key_parts_copy);
 			return -1;
 		}
-		index->index_id = index_id;
-		index->space_id = space_id;
-		rlist_create(&index->ranges);
-		rlist_create(&index->runs);
+		lsm->index_id = index_id;
+		lsm->space_id = space_id;
+		rlist_create(&lsm->ranges);
+		rlist_create(&lsm->runs);
 
-		node.val = index;
+		node.val = lsm;
 		if (mh_i64ptr_put(h, &node, NULL, NULL) == mh_end(h)) {
 			diag_set(OutOfMemory, 0, "mh_i64ptr_put",
 				 "mh_i64ptr_node_t");
 			free(key_parts_copy);
-			free(index);
+			free(lsm);
 			return -1;
 		}
-		rlist_add_entry(&recovery->indexes, index, in_recovery);
+		rlist_add_entry(&recovery->lsms, lsm, in_recovery);
 	} else {
 		/*
-		 * The index was dropped and recreated with the
+		 * The LSM tree was dropped and recreated with the
 		 * same ID. Update its key definition (because it
 		 * could have changed since the last time it was
 		 * used) and reset its state.
 		 */
-		if (!index->is_dropped) {
+		if (!lsm->is_dropped) {
 			diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-				 tt_sprintf("Index %u/%u created twice",
+				 tt_sprintf("LSM tree %u/%u created twice",
 					    (unsigned)space_id,
 					    (unsigned)index_id));
 			free(key_parts_copy);
 			return -1;
 		}
-		assert(index->index_id == index_id);
-		assert(index->space_id == space_id);
-		free(index->key_parts);
+		assert(lsm->index_id == index_id);
+		assert(lsm->space_id == space_id);
+		free(lsm->key_parts);
 	}
 
-	index->id = id;
-	index->key_parts = key_parts_copy;
-	index->key_part_count = key_part_count;
-	index->is_dropped = false;
-	index->commit_lsn = commit_lsn;
-	index->dump_lsn = -1;
+	lsm->id = id;
+	lsm->key_parts = key_parts_copy;
+	lsm->key_part_count = key_part_count;
+	lsm->is_dropped = false;
+	lsm->commit_lsn = commit_lsn;
+	lsm->dump_lsn = -1;
 
 	/*
-	 * Add the index to the hash.
+	 * Add the LSM tree to the hash.
 	 */
-	h = recovery->index_hash;
+	h = recovery->lsm_hash;
 	node.key = id;
-	node.val = index;
+	node.val = lsm;
 	if (mh_i64ptr_find(h, id, NULL) != mh_end(h)) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-			 tt_sprintf("Duplicate index id %lld",
+			 tt_sprintf("Duplicate LSM tree id %lld",
 				    (long long)id));
 		return -1;
 	}
@@ -1290,72 +1287,72 @@ vy_recovery_create_index(struct vy_recovery *recovery, int64_t id,
 }
 
 /**
- * Handle a VY_LOG_DROP_INDEX log record.
- * This function marks the vinyl index with ID @id as dropped.
- * All ranges and runs of the index must have been deleted by now.
- * Returns 0 on success, -1 if ID not found or index is already marked.
+ * Handle a VY_LOG_DROP_LSM log record.
+ * This function marks the LSM tree with ID @id as dropped.
+ * All ranges and runs of the LSM tree must have been deleted by now.
+ * Returns 0 on success, -1 if ID not found or LSM tree is already marked.
  */
 static int
-vy_recovery_drop_index(struct vy_recovery *recovery, int64_t id)
+vy_recovery_drop_lsm(struct vy_recovery *recovery, int64_t id)
 {
-	struct vy_index_recovery_info *index;
-	index = vy_recovery_lookup_index(recovery, id);
-	if (index == NULL) {
+	struct vy_lsm_recovery_info *lsm;
+	lsm = vy_recovery_lookup_lsm(recovery, id);
+	if (lsm == NULL) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-			 tt_sprintf("Index %lld deleted but not registered",
+			 tt_sprintf("LSM tree %lld deleted but not registered",
 				    (long long)id));
 		return -1;
 	}
-	if (index->is_dropped) {
+	if (lsm->is_dropped) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-			 tt_sprintf("Index %lld deleted twice",
+			 tt_sprintf("LSM tree %lld deleted twice",
 				    (long long)id));
 		return -1;
 	}
-	if (!rlist_empty(&index->ranges)) {
+	if (!rlist_empty(&lsm->ranges)) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-			 tt_sprintf("Dropped index %lld has ranges",
+			 tt_sprintf("Dropped LSM tree %lld has ranges",
 				    (long long)id));
 		return -1;
 	}
 	struct vy_run_recovery_info *run;
-	rlist_foreach_entry(run, &index->runs, in_index) {
+	rlist_foreach_entry(run, &lsm->runs, in_lsm) {
 		if (!run->is_dropped && !run->is_incomplete) {
 			diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-				 tt_sprintf("Dropped index %lld has active "
+				 tt_sprintf("Dropped LSM tree %lld has active "
 					    "runs", (long long)id));
 			return -1;
 		}
 	}
-	index->is_dropped = true;
+	lsm->is_dropped = true;
 	return 0;
 }
 
 /**
- * Handle a VY_LOG_DUMP_INDEX log record.
- * This function updates LSN of the last dump of the vinyl index
+ * Handle a VY_LOG_DUMP_LSM log record.
+ * This function updates LSN of the last dump of the LSM tree
  * with ID @id.
- * Returns 0 on success, -1 if ID not found or index is dropped.
+ * Returns 0 on success, -1 if ID not found or LSM tree is dropped.
  */
 static int
-vy_recovery_dump_index(struct vy_recovery *recovery,
-		       int64_t id, int64_t dump_lsn)
+vy_recovery_dump_lsm(struct vy_recovery *recovery,
+		     int64_t id, int64_t dump_lsn)
 {
-	struct vy_index_recovery_info *index;
-	index = vy_recovery_lookup_index(recovery, id);
-	if (index == NULL) {
+	struct vy_lsm_recovery_info *lsm;
+	lsm = vy_recovery_lookup_lsm(recovery, id);
+	if (lsm == NULL) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-			 tt_sprintf("Dump of unregistered index %lld",
+			 tt_sprintf("Dump of unregistered LSM tree %lld",
 				    (long long)id));
 		return -1;
 	}
-	if (index->is_dropped) {
+	if (lsm->is_dropped) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-			 tt_sprintf("Dump of deleted index %lld",
+			 tt_sprintf("Dump of deleted LSM tree %lld",
 				    (long long)id));
 		return -1;
 	}
-	index->dump_lsn = dump_lsn;
+	lsm->dump_lsn = dump_lsn;
 	return 0;
 }
 
@@ -1387,7 +1384,7 @@ vy_recovery_do_create_run(struct vy_recovery *recovery, int64_t run_id)
 	run->is_incomplete = false;
 	run->is_dropped = false;
 	run->data = NULL;
-	rlist_create(&run->in_index);
+	rlist_create(&run->in_lsm);
 	if (recovery->max_id < run_id)
 		recovery->max_id = run_id;
 	return run;
@@ -1396,21 +1393,21 @@ vy_recovery_do_create_run(struct vy_recovery *recovery, int64_t run_id)
 /**
  * Handle a VY_LOG_PREPARE_RUN log record.
  * This function creates a new incomplete vinyl run with ID @run_id
- * and adds it to the list of runs of the index with ID @index_id.
- * Return 0 on success, -1 if run already exists, index not found,
+ * and adds it to the list of runs of the LSM tree with ID @lsm_id.
+ * Return 0 on success, -1 if run already exists, LSM tree not found,
  * or OOM.
  */
 static int
-vy_recovery_prepare_run(struct vy_recovery *recovery, int64_t index_id,
+vy_recovery_prepare_run(struct vy_recovery *recovery, int64_t lsm_id,
 			int64_t run_id)
 {
-	struct vy_index_recovery_info *index;
-	index = vy_recovery_lookup_index(recovery, index_id);
-	if (index == NULL) {
+	struct vy_lsm_recovery_info *lsm;
+	lsm = vy_recovery_lookup_lsm(recovery, lsm_id);
+	if (lsm == NULL) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
 			 tt_sprintf("Run %lld created for unregistered "
-				    "index %lld", (long long)run_id,
-				    (long long)index_id));
+				    "LSM tree %lld", (long long)run_id,
+				    (long long)lsm_id));
 		return -1;
 	}
 	if (vy_recovery_lookup_run(recovery, run_id) != NULL) {
@@ -1424,36 +1421,36 @@ vy_recovery_prepare_run(struct vy_recovery *recovery, int64_t index_id,
 	if (run == NULL)
 		return -1;
 	run->is_incomplete = true;
-	rlist_add_entry(&index->runs, run, in_index);
+	rlist_add_entry(&lsm->runs, run, in_lsm);
 	return 0;
 }
 
 /**
  * Handle a VY_LOG_CREATE_RUN log record.
  * This function adds the vinyl run with ID @run_id to the list
- * of runs of the index with ID @index_id and marks it committed.
+ * of runs of the LSM tree with ID @\fsm_id and marks it committed.
  * If the run does not exist, it will be created.
- * Return 0 on success, -1 if index not found, run or index
+ * Return 0 on success, -1 if LSM tree not found, run or LSM tree
  * is dropped, or OOM.
  */
 static int
-vy_recovery_create_run(struct vy_recovery *recovery, int64_t index_id,
+vy_recovery_create_run(struct vy_recovery *recovery, int64_t lsm_id,
 		       int64_t run_id, int64_t dump_lsn)
 {
-	struct vy_index_recovery_info *index;
-	index = vy_recovery_lookup_index(recovery, index_id);
-	if (index == NULL) {
+	struct vy_lsm_recovery_info *lsm;
+	lsm = vy_recovery_lookup_lsm(recovery, lsm_id);
+	if (lsm == NULL) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
 			 tt_sprintf("Run %lld created for unregistered "
-				    "index %lld", (long long)run_id,
-				    (long long)index_id));
+				    "LSM tree %lld", (long long)run_id,
+				    (long long)lsm_id));
 		return -1;
 	}
-	if (index->is_dropped) {
+	if (lsm->is_dropped) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
 			 tt_sprintf("Run %lld created for deleted "
-				    "index %lld", (long long)run_id,
-				    (long long)index_id));
+				    "LSM tree %lld", (long long)run_id,
+				    (long long)lsm_id));
 		return -1;
 	}
 	struct vy_run_recovery_info *run;
@@ -1471,7 +1468,7 @@ vy_recovery_create_run(struct vy_recovery *recovery, int64_t index_id,
 	}
 	run->dump_lsn = dump_lsn;
 	run->is_incomplete = false;
-	rlist_move_entry(&index->runs, run, in_index);
+	rlist_move_entry(&lsm->runs, run, in_lsm);
 	return 0;
 }
 
@@ -1523,7 +1520,7 @@ vy_recovery_forget_run(struct vy_recovery *recovery, int64_t run_id)
 	}
 	struct vy_run_recovery_info *run = mh_i64ptr_node(h, k)->val;
 	mh_i64ptr_del(h, k, NULL);
-	rlist_del_entry(run, in_index);
+	rlist_del_entry(run, in_lsm);
 	free(run);
 	return 0;
 }
@@ -1532,11 +1529,11 @@ vy_recovery_forget_run(struct vy_recovery *recovery, int64_t run_id)
  * Handle a VY_LOG_INSERT_RANGE log record.
  * This function allocates a new vinyl range with ID @range_id,
  * inserts it to the hash, and adds it to the list of ranges of the
- * index with ID @index_id.
+ * LSM tree with ID @lsm_id.
  * Return 0 on success, -1 on failure (ID collision or OOM).
  */
 static int
-vy_recovery_insert_range(struct vy_recovery *recovery, int64_t index_id,
+vy_recovery_insert_range(struct vy_recovery *recovery, int64_t lsm_id,
 			 int64_t range_id, const char *begin, const char *end)
 {
 	if (vy_recovery_lookup_range(recovery, range_id) != NULL) {
@@ -1545,13 +1542,13 @@ vy_recovery_insert_range(struct vy_recovery *recovery, int64_t index_id,
 				    (long long)range_id));
 		return -1;
 	}
-	struct vy_index_recovery_info *index;
-	index = vy_recovery_lookup_index(recovery, index_id);
-	if (index == NULL) {
+	struct vy_lsm_recovery_info *lsm;
+	lsm = vy_recovery_lookup_lsm(recovery, lsm_id);
+	if (lsm == NULL) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
 			 tt_sprintf("Range %lld created for unregistered "
-				    "index %lld", (long long)range_id,
-				    (long long)index_id));
+				    "LSM tree %lld", (long long)range_id,
+				    (long long)lsm_id));
 		return -1;
 	}
 
@@ -1593,7 +1590,7 @@ vy_recovery_insert_range(struct vy_recovery *recovery, int64_t index_id,
 	} else
 		range->end = NULL;
 	rlist_create(&range->slices);
-	rlist_add_entry(&index->ranges, range, in_index);
+	rlist_add_entry(&lsm->ranges, range, in_lsm);
 	if (recovery->max_id < range_id)
 		recovery->max_id = range_id;
 	return 0;
@@ -1624,7 +1621,7 @@ vy_recovery_delete_range(struct vy_recovery *recovery, int64_t range_id)
 		return -1;
 	}
 	mh_i64ptr_del(h, k, NULL);
-	rlist_del_entry(range, in_index);
+	rlist_del_entry(range, in_lsm);
 	free(range);
 	return 0;
 }
@@ -1757,28 +1754,28 @@ vy_recovery_process_record(struct vy_recovery *recovery,
 {
 	int rc;
 	switch (record->type) {
-	case VY_LOG_CREATE_INDEX:
-		rc = vy_recovery_create_index(recovery, record->index_id,
-				record->space_def_id, record->index_def_id,
+	case VY_LOG_CREATE_LSM:
+		rc = vy_recovery_create_lsm(recovery, record->lsm_id,
+				record->space_id, record->index_id,
 				record->key_parts, record->key_part_count,
 				record->commit_lsn);
 		break;
-	case VY_LOG_DROP_INDEX:
-		rc = vy_recovery_drop_index(recovery, record->index_id);
+	case VY_LOG_DROP_LSM:
+		rc = vy_recovery_drop_lsm(recovery, record->lsm_id);
 		break;
 	case VY_LOG_INSERT_RANGE:
-		rc = vy_recovery_insert_range(recovery, record->index_id,
+		rc = vy_recovery_insert_range(recovery, record->lsm_id,
 				record->range_id, record->begin, record->end);
 		break;
 	case VY_LOG_DELETE_RANGE:
 		rc = vy_recovery_delete_range(recovery, record->range_id);
 		break;
 	case VY_LOG_PREPARE_RUN:
-		rc = vy_recovery_prepare_run(recovery, record->index_id,
+		rc = vy_recovery_prepare_run(recovery, record->lsm_id,
 					     record->run_id);
 		break;
 	case VY_LOG_CREATE_RUN:
-		rc = vy_recovery_create_run(recovery, record->index_id,
+		rc = vy_recovery_create_run(recovery, record->lsm_id,
 					    record->run_id, record->dump_lsn);
 		break;
 	case VY_LOG_DROP_RUN:
@@ -1796,11 +1793,11 @@ vy_recovery_process_record(struct vy_recovery *recovery,
 	case VY_LOG_DELETE_SLICE:
 		rc = vy_recovery_delete_slice(recovery, record->slice_id);
 		break;
-	case VY_LOG_DUMP_INDEX:
-		rc = vy_recovery_dump_index(recovery, record->index_id,
+	case VY_LOG_DUMP_LSM:
+		rc = vy_recovery_dump_lsm(recovery, record->lsm_id,
 					    record->dump_lsn);
 		break;
-	case VY_LOG_TRUNCATE_INDEX:
+	case VY_LOG_TRUNCATE_LSM:
 		/* Not used anymore, ignore. */
 		rc = 0;
 		break;
@@ -1829,21 +1826,21 @@ vy_recovery_new_f(va_list ap)
 		goto fail;
 	}
 
-	rlist_create(&recovery->indexes);
+	rlist_create(&recovery->lsms);
 	recovery->index_id_hash = NULL;
-	recovery->index_hash = NULL;
+	recovery->lsm_hash = NULL;
 	recovery->range_hash = NULL;
 	recovery->run_hash = NULL;
 	recovery->slice_hash = NULL;
 	recovery->max_id = -1;
 
 	recovery->index_id_hash = mh_i64ptr_new();
-	recovery->index_hash = mh_i64ptr_new();
+	recovery->lsm_hash = mh_i64ptr_new();
 	recovery->range_hash = mh_i64ptr_new();
 	recovery->run_hash = mh_i64ptr_new();
 	recovery->slice_hash = mh_i64ptr_new();
 	if (recovery->index_id_hash == NULL ||
-	    recovery->index_hash == NULL ||
+	    recovery->lsm_hash == NULL ||
 	    recovery->range_hash == NULL ||
 	    recovery->run_hash == NULL ||
 	    recovery->slice_hash == NULL) {
@@ -1961,16 +1958,16 @@ vy_recovery_delete(struct vy_recovery *recovery)
 	if (recovery->index_id_hash != NULL) {
 		mh_int_t i;
 		mh_foreach(recovery->index_id_hash, i) {
-			struct vy_index_recovery_info *index;
-			index = mh_i64ptr_node(recovery->index_id_hash, i)->val;
-			free(index->key_parts);
-			free(index);
+			struct vy_lsm_recovery_info *lsm;
+			lsm = mh_i64ptr_node(recovery->index_id_hash, i)->val;
+			free(lsm->key_parts);
+			free(lsm);
 		}
 		mh_i64ptr_delete(recovery->index_id_hash);
 	}
-	if (recovery->index_hash != NULL) {
+	if (recovery->lsm_hash != NULL) {
 		/* Hash entries were deleted along with index_id_hash. */
-		mh_i64ptr_delete(recovery->index_hash);
+		mh_i64ptr_delete(recovery->lsm_hash);
 	}
 	if (recovery->range_hash != NULL)
 		vy_recovery_delete_hash(recovery->range_hash);
@@ -1996,9 +1993,9 @@ vy_log_append_record(struct xlog *xlog, struct vy_log_record *record)
 	return 0;
 }
 
-/** Write all records corresponding to an index to vylog. */
+/** Write all records corresponding to an LSM tree to vylog. */
 static int
-vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index)
+vy_log_append_lsm(struct xlog *xlog, struct vy_lsm_recovery_info *lsm)
 {
 	struct vy_range_recovery_info *range;
 	struct vy_slice_recovery_info *slice;
@@ -2006,25 +2003,25 @@ vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index)
 	struct vy_log_record record;
 
 	vy_log_record_init(&record);
-	record.type = VY_LOG_CREATE_INDEX;
-	record.index_id = index->id;
-	record.index_def_id = index->index_id;
-	record.space_def_id = index->space_id;
-	record.key_parts = index->key_parts;
-	record.key_part_count = index->key_part_count;
+	record.type = VY_LOG_CREATE_LSM;
+	record.lsm_id = lsm->id;
+	record.index_id = lsm->index_id;
+	record.space_id = lsm->space_id;
+	record.key_parts = lsm->key_parts;
+	record.key_part_count = lsm->key_part_count;
 	if (vy_log_append_record(xlog, &record) != 0)
 		return -1;
 
-	if (index->dump_lsn >= 0) {
+	if (lsm->dump_lsn >= 0) {
 		vy_log_record_init(&record);
-		record.type = VY_LOG_DUMP_INDEX;
-		record.index_id = index->id;
-		record.dump_lsn = index->dump_lsn;
+		record.type = VY_LOG_DUMP_LSM;
+		record.lsm_id = lsm->id;
+		record.dump_lsn = lsm->dump_lsn;
 		if (vy_log_append_record(xlog, &record) != 0)
 			return -1;
 	}
 
-	rlist_foreach_entry(run, &index->runs, in_index) {
+	rlist_foreach_entry(run, &lsm->runs, in_lsm) {
 		vy_log_record_init(&record);
 		if (run->is_incomplete) {
 			record.type = VY_LOG_PREPARE_RUN;
@@ -2032,7 +2029,7 @@ vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index)
 			record.type = VY_LOG_CREATE_RUN;
 			record.dump_lsn = run->dump_lsn;
 		}
-		record.index_id = index->id;
+		record.lsm_id = lsm->id;
 		record.run_id = run->id;
 		if (vy_log_append_record(xlog, &record) != 0)
 			return -1;
@@ -2048,10 +2045,10 @@ vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index)
 			return -1;
 	}
 
-	rlist_foreach_entry(range, &index->ranges, in_index) {
+	rlist_foreach_entry(range, &lsm->ranges, in_lsm) {
 		vy_log_record_init(&record);
 		record.type = VY_LOG_INSERT_RANGE;
-		record.index_id = index->id;
+		record.lsm_id = lsm->id;
 		record.range_id = range->id;
 		record.begin = range->begin;
 		record.end = range->end;
@@ -2075,10 +2072,10 @@ vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index)
 		}
 	}
 
-	if (index->is_dropped) {
+	if (lsm->is_dropped) {
 		vy_log_record_init(&record);
-		record.type = VY_LOG_DROP_INDEX;
-		record.index_id = index->id;
+		record.type = VY_LOG_DROP_LSM;
+		record.lsm_id = lsm->id;
 		if (vy_log_append_record(xlog, &record) != 0)
 			return -1;
 	}
@@ -2100,14 +2097,14 @@ vy_log_create(const struct vclock *vclock, struct vy_recovery *recovery)
 
 	mh_int_t i;
 	mh_foreach(recovery->index_id_hash, i) {
-		struct vy_index_recovery_info *index;
-		index = mh_i64ptr_node(recovery->index_id_hash, i)->val;
+		struct vy_lsm_recovery_info *lsm;
+		lsm = mh_i64ptr_node(recovery->index_id_hash, i)->val;
 		/*
-		 * Purge dropped indexes that are not referenced by runs
+		 * Purge dropped LSM trees that are not referenced by runs
 		 * (and thus not needed for garbage collection) from the
 		 * log on rotation.
 		 */
-		if (index->is_dropped && rlist_empty(&index->runs))
+		if (lsm->is_dropped && rlist_empty(&lsm->runs))
 			continue;
 
 		/* Create the log file on the first write. */
@@ -2115,7 +2112,7 @@ vy_log_create(const struct vclock *vclock, struct vy_recovery *recovery)
 		    xdir_create_xlog(&vy_log.dir, &xlog, vclock) != 0)
 			goto err_create_xlog;
 
-		if (vy_log_append_index(&xlog, index) != 0)
+		if (vy_log_append_lsm(&xlog, lsm) != 0)
 			goto err_write_xlog;
 	}
 	if (!xlog_is_open(&xlog))
diff --git a/src/box/vy_log.h b/src/box/vy_log.h
index 8e1a2a1d..2dad4ee9 100644
--- a/src/box/vy_log.h
+++ b/src/box/vy_log.h
@@ -64,19 +64,19 @@ struct mh_i64ptr_t;
 /** Type of a metadata log record. */
 enum vy_log_record_type {
 	/**
-	 * Create a new vinyl index.
-	 * Requires vy_log_record::index_id, index_def_id, space_def_id,
+	 * Create a new LSM tree.
+	 * Requires vy_log_record::lsm_id, index_id, space_id,
 	 * key_def (with primary key parts), commit_lsn.
 	 */
-	VY_LOG_CREATE_INDEX		= 0,
+	VY_LOG_CREATE_LSM		= 0,
 	/**
-	 * Drop an index.
-	 * Requires vy_log_record::index_id.
+	 * Drop an LSM tree.
+	 * Requires vy_log_record::lsm_id.
 	 */
-	VY_LOG_DROP_INDEX		= 1,
+	VY_LOG_DROP_LSM			= 1,
 	/**
-	 * Insert a new range into a vinyl index.
-	 * Requires vy_log_record::index_id, range_id, begin, end.
+	 * Insert a new range into an LSM tree.
+	 * Requires vy_log_record::lsm_id, range_id, begin, end.
 	 */
 	VY_LOG_INSERT_RANGE		= 2,
 	/**
@@ -86,7 +86,7 @@ enum vy_log_record_type {
 	VY_LOG_DELETE_RANGE		= 3,
 	/**
 	 * Prepare a vinyl run file.
-	 * Requires vy_log_record::index_id, run_id.
+	 * Requires vy_log_record::lsm_id, run_id.
 	 *
 	 * Record of this type is written before creating a run file.
 	 * It is needed to keep track of unfinished due to errors run
@@ -95,7 +95,7 @@ enum vy_log_record_type {
 	VY_LOG_PREPARE_RUN		= 4,
 	/**
 	 * Commit a vinyl run file creation.
-	 * Requires vy_log_record::index_id, run_id, dump_lsn.
+	 * Requires vy_log_record::lsm_id, run_id, dump_lsn.
 	 *
 	 * Written after a run file was successfully created.
 	 */
@@ -135,10 +135,10 @@ enum vy_log_record_type {
 	 */
 	VY_LOG_DELETE_SLICE		= 9,
 	/**
-	 * Update LSN of the last index dump.
-	 * Requires vy_log_record::index_id, dump_lsn.
+	 * Update LSN of the last LSM tree dump.
+	 * Requires vy_log_record::lsm_id, dump_lsn.
 	 */
-	VY_LOG_DUMP_INDEX		= 10,
+	VY_LOG_DUMP_LSM			= 10,
 	/**
 	 * We don't split vylog into snapshot and log - all records
 	 * are written to the same file. Since we need to load a
@@ -151,19 +151,19 @@ enum vy_log_record_type {
 	 */
 	VY_LOG_SNAPSHOT			= 11,
 	/**
-	 * When we used LSN for identifying indexes in vylog, we
-	 * couldn't simply recreate an index on space truncation,
-	 * because in case the space had more than one index, we
+	 * When we used LSN for identifying LSM trees in vylog, we
+	 * couldn't simply recreate an LSM tree on space truncation,
+	 * because in case the space had more than one LSM tree, we
 	 * wouldn't be able to distinguish them after truncation.
 	 * So we wrote special 'truncate' record.
 	 *
-	 * Now, we assign a unique id to each index and so we don't
+	 * Now, we assign a unique id to each LSM tree and so we don't
 	 * need a special record type for space truncation. If we
 	 * are recovering from an old vylog, we simply ignore all
 	 * 'truncate' records - this will result in replay of all
 	 * WAL records written after truncation.
 	 */
-	VY_LOG_TRUNCATE_INDEX		= 12,
+	VY_LOG_TRUNCATE_LSM		= 12,
 
 	vy_log_record_type_MAX
 };
@@ -172,8 +172,8 @@ enum vy_log_record_type {
 struct vy_log_record {
 	/** Type of the record. */
 	enum vy_log_record_type type;
-	/** Unique ID of the vinyl index. */
-	int64_t index_id;
+	/** Unique ID of the vinyl LSM tree. */
+	int64_t lsm_id;
 	/** Unique ID of the vinyl range. */
 	int64_t range_id;
 	/** Unique ID of the vinyl run. */
@@ -191,9 +191,9 @@ struct vy_log_record {
 	 */
 	const char *end;
 	/** Ordinal index number in the space. */
-	uint32_t index_def_id;
+	uint32_t index_id;
 	/** Space ID. */
-	uint32_t space_def_id;
+	uint32_t space_id;
 	/** Index key definition, as defined by the user. */
 	const struct key_def *key_def;
 	/** Array of key part definitions. */
@@ -216,14 +216,14 @@ struct vy_log_record {
 /** Recovery context. */
 struct vy_recovery {
 	/**
-	 * List of all indexes stored in the recovery context,
-	 * linked by vy_index_recovery_info::in_recovery.
+	 * List of all LSM trees stored in the recovery context,
+	 * linked by vy_lsm_recovery_info::in_recovery.
 	 */
-	struct rlist indexes;
-	/** space_id, index_id -> vy_index_recovery_info. */
+	struct rlist lsms;
+	/** space_id, index_id -> vy_lsm_recovery_info. */
 	struct mh_i64ptr_t *index_id_hash;
-	/** ID -> vy_index_recovery_info. */
-	struct mh_i64ptr_t *index_hash;
+	/** ID -> vy_lsm_recovery_info. */
+	struct mh_i64ptr_t *lsm_hash;
 	/** ID -> vy_range_recovery_info. */
 	struct mh_i64ptr_t *range_hash;
 	/** ID -> vy_run_recovery_info. */
@@ -237,11 +237,11 @@ struct vy_recovery {
 	int64_t max_id;
 };
 
-/** Vinyl index info stored in a recovery context. */
-struct vy_index_recovery_info {
-	/** Link in vy_recovery::indexes. */
+/** LSM tree info stored in a recovery context. */
+struct vy_lsm_recovery_info {
+	/** Link in vy_recovery::lsms. */
 	struct rlist in_recovery;
-	/** ID of the index. */
+	/** ID of the LSM tree. */
 	int64_t id;
 	/** Ordinal index number in the space. */
 	uint32_t index_id;
@@ -251,29 +251,29 @@ struct vy_index_recovery_info {
 	struct key_part_def *key_parts;
 	/** Number of key parts. */
 	uint32_t key_part_count;
-	/** True if the index was dropped. */
+	/** True if the LSM tree was dropped. */
 	bool is_dropped;
-	/** LSN of the WAL row that committed the index. */
+	/** LSN of the WAL row that committed the LSM tree. */
 	int64_t commit_lsn;
-	/** LSN of the last index dump. */
+	/** LSN of the last LSM tree dump. */
 	int64_t dump_lsn;
 	/**
-	 * List of all ranges in the index, linked by
-	 * vy_range_recovery_info::in_index.
+	 * List of all ranges in the LSM tree, linked by
+	 * vy_range_recovery_info::in_lsm.
 	 */
 	struct rlist ranges;
 	/**
-	 * List of all runs created for the index
+	 * List of all runs created for the LSM tree
 	 * (both committed and not), linked by
-	 * vy_run_recovery_info::in_index.
+	 * vy_run_recovery_info::in_lsm.
 	 */
 	struct rlist runs;
 };
 
 /** Vinyl range info stored in a recovery context. */
 struct vy_range_recovery_info {
-	/** Link in vy_index_recovery_info::ranges. */
-	struct rlist in_index;
+	/** Link in vy_lsm_recovery_info::ranges. */
+	struct rlist in_lsm;
 	/** ID of the range. */
 	int64_t id;
 	/** Start of the range, stored in MsgPack array. */
@@ -291,8 +291,8 @@ struct vy_range_recovery_info {
 
 /** Run info stored in a recovery context. */
 struct vy_run_recovery_info {
-	/** Link in vy_index_recovery_info::runs. */
-	struct rlist in_index;
+	/** Link in vy_lsm_recovery_info::runs. */
+	struct rlist in_lsm;
 	/** ID of the run. */
 	int64_t id;
 	/** Max LSN stored on disk. */
@@ -356,10 +356,10 @@ vy_log_open(struct xlog *xlog);
 /**
  * Rotate the metadata log. This function creates a new
  * xlog file in the log directory having vclock @vclock
- * and writes records required to recover active indexes.
+ * and writes records required to recover active LSM trees.
  * The goal of log rotation is to compact the log file by
  * discarding records cancelling each other and records left
- * from dropped indexes.
+ * from dropped LSM trees.
  *
  * Returns 0 on success, -1 on failure.
  */
@@ -439,7 +439,7 @@ vy_log_bootstrap(void);
  * Prepare the metadata log for recovery from the file having
  * vclock @vclock and return the recovery context.
  *
- * After this function is called, vinyl indexes may be recovered from
+ * After this function is called, LSM trees may be recovered from
  * the log using vy_recovery methods. When recovery is complete,
  * one must call vy_log_end_recovery(). After that the recovery context
  * may be deleted with vy_recovery_delete().
@@ -481,13 +481,13 @@ void
 vy_recovery_delete(struct vy_recovery *recovery);
 
 /**
- * Look up the last incarnation of an index stored in a recovery context.
+ * Look up the last incarnation of an LSM tree stored in a recovery context.
  *
- * Returns NULL if the index was not found.
+ * Returns NULL if the LSM tree was not found.
  */
-struct vy_index_recovery_info *
-vy_recovery_index_by_id(struct vy_recovery *recovery,
-			uint32_t space_id, uint32_t index_id);
+struct vy_lsm_recovery_info *
+vy_recovery_lsm_by_index_id(struct vy_recovery *recovery,
+			    uint32_t space_id, uint32_t index_id);
 
 /**
  * Initialize a log record with default values.
@@ -500,42 +500,42 @@ vy_log_record_init(struct vy_log_record *record)
 	memset(record, 0, sizeof(*record));
 }
 
-/** Helper to log a vinyl index creation. */
+/** Helper to log a vinyl LSM tree creation. */
 static inline void
-vy_log_create_index(int64_t id, uint32_t space_id, uint32_t index_id,
-		    const struct key_def *key_def, int64_t commit_lsn)
+vy_log_create_lsm(int64_t id, uint32_t space_id, uint32_t index_id,
+		  const struct key_def *key_def, int64_t commit_lsn)
 {
 	struct vy_log_record record;
 	vy_log_record_init(&record);
-	record.type = VY_LOG_CREATE_INDEX;
-	record.index_id = id;
-	record.space_def_id = space_id;
-	record.index_def_id = index_id;
+	record.type = VY_LOG_CREATE_LSM;
+	record.lsm_id = id;
+	record.space_id = space_id;
+	record.index_id = index_id;
 	record.key_def = key_def;
 	record.commit_lsn = commit_lsn;
 	vy_log_write(&record);
 }
 
-/** Helper to log a vinyl index drop. */
+/** Helper to log a vinyl LSM tree drop. */
 static inline void
-vy_log_drop_index(int64_t id)
+vy_log_drop_lsm(int64_t id)
 {
 	struct vy_log_record record;
 	vy_log_record_init(&record);
-	record.type = VY_LOG_DROP_INDEX;
-	record.index_id = id;
+	record.type = VY_LOG_DROP_LSM;
+	record.lsm_id = id;
 	vy_log_write(&record);
 }
 
 /** Helper to log a vinyl range insertion. */
 static inline void
-vy_log_insert_range(int64_t index_id, int64_t range_id,
+vy_log_insert_range(int64_t lsm_id, int64_t range_id,
 		    const char *begin, const char *end)
 {
 	struct vy_log_record record;
 	vy_log_record_init(&record);
 	record.type = VY_LOG_INSERT_RANGE;
-	record.index_id = index_id;
+	record.lsm_id = lsm_id;
 	record.range_id = range_id;
 	record.begin = begin;
 	record.end = end;
@@ -555,24 +555,24 @@ vy_log_delete_range(int64_t range_id)
 
 /** Helper to log a vinyl run file creation. */
 static inline void
-vy_log_prepare_run(int64_t index_id, int64_t run_id)
+vy_log_prepare_run(int64_t lsm_id, int64_t run_id)
 {
 	struct vy_log_record record;
 	vy_log_record_init(&record);
 	record.type = VY_LOG_PREPARE_RUN;
-	record.index_id = index_id;
+	record.lsm_id = lsm_id;
 	record.run_id = run_id;
 	vy_log_write(&record);
 }
 
 /** Helper to log a vinyl run creation. */
 static inline void
-vy_log_create_run(int64_t index_id, int64_t run_id, int64_t dump_lsn)
+vy_log_create_run(int64_t lsm_id, int64_t run_id, int64_t dump_lsn)
 {
 	struct vy_log_record record;
 	vy_log_record_init(&record);
 	record.type = VY_LOG_CREATE_RUN;
-	record.index_id = index_id;
+	record.lsm_id = lsm_id;
 	record.run_id = run_id;
 	record.dump_lsn = dump_lsn;
 	vy_log_write(&record);
@@ -628,14 +628,14 @@ vy_log_delete_slice(int64_t slice_id)
 	vy_log_write(&record);
 }
 
-/** Helper to log index dump. */
+/** Helper to log LSM tree dump. */
 static inline void
-vy_log_dump_index(int64_t id, int64_t dump_lsn)
+vy_log_dump_lsm(int64_t id, int64_t dump_lsn)
 {
 	struct vy_log_record record;
 	vy_log_record_init(&record);
-	record.type = VY_LOG_DUMP_INDEX;
-	record.index_id = id;
+	record.type = VY_LOG_DUMP_LSM;
+	record.lsm_id = id;
 	record.dump_lsn = dump_lsn;
 	vy_log_write(&record);
 }
diff --git a/src/box/vy_index.c b/src/box/vy_lsm.c
similarity index 56%
rename from src/box/vy_index.c
rename to src/box/vy_lsm.c
index 09894982..88a75e32 100644
--- a/src/box/vy_index.c
+++ b/src/box/vy_lsm.c
@@ -28,7 +28,7 @@
  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
-#include "vy_index.h"
+#include "vy_lsm.h"
 
 #include "trivia/util.h"
 #include <stdbool.h>
@@ -53,36 +53,36 @@
 #include "vy_read_set.h"
 
 void
-vy_index_validate_formats(const struct vy_index *index)
+vy_lsm_validate_formats(const struct vy_lsm *lsm)
 {
-	(void) index;
-	assert(index->disk_format != NULL);
-	assert(index->mem_format != NULL);
-	assert(index->mem_format_with_colmask != NULL);
-	assert(index->upsert_format != NULL);
-	uint32_t index_field_count = index->mem_format->index_field_count;
+	(void) lsm;
+	assert(lsm->disk_format != NULL);
+	assert(lsm->mem_format != NULL);
+	assert(lsm->mem_format_with_colmask != NULL);
+	assert(lsm->upsert_format != NULL);
+	uint32_t index_field_count = lsm->mem_format->index_field_count;
 	(void) index_field_count;
-	if (index->index_id == 0) {
-		assert(index->disk_format == index->mem_format);
-		assert(index->disk_format->index_field_count ==
+	if (lsm->index_id == 0) {
+		assert(lsm->disk_format == lsm->mem_format);
+		assert(lsm->disk_format->index_field_count ==
 		       index_field_count);
-		assert(index->mem_format_with_colmask->index_field_count ==
+		assert(lsm->mem_format_with_colmask->index_field_count ==
 		       index_field_count);
 	} else {
-		assert(index->disk_format != index->mem_format);
-		assert(index->disk_format->index_field_count <=
+		assert(lsm->disk_format != lsm->mem_format);
+		assert(lsm->disk_format->index_field_count <=
 		       index_field_count);
 	}
-	assert(index->upsert_format->index_field_count == index_field_count);
-	assert(index->mem_format_with_colmask->index_field_count ==
+	assert(lsm->upsert_format->index_field_count == index_field_count);
+	assert(lsm->mem_format_with_colmask->index_field_count ==
 	       index_field_count);
 }
 
 int
-vy_index_env_create(struct vy_index_env *env, const char *path,
-		    int64_t *p_generation,
-		    vy_upsert_thresh_cb upsert_thresh_cb,
-		    void *upsert_thresh_arg)
+vy_lsm_env_create(struct vy_lsm_env *env, const char *path,
+		  int64_t *p_generation,
+		  vy_upsert_thresh_cb upsert_thresh_cb,
+		  void *upsert_thresh_arg)
 {
 	env->key_format = tuple_format_new(&vy_tuple_format_vtab,
 					   NULL, 0, 0, NULL, 0, NULL);
@@ -99,40 +99,40 @@ vy_index_env_create(struct vy_index_env *env, const char *path,
 	env->upsert_thresh_cb = upsert_thresh_cb;
 	env->upsert_thresh_arg = upsert_thresh_arg;
 	env->too_long_threshold = TIMEOUT_INFINITY;
-	env->index_count = 0;
+	env->lsm_count = 0;
 	return 0;
 }
 
 void
-vy_index_env_destroy(struct vy_index_env *env)
+vy_lsm_env_destroy(struct vy_lsm_env *env)
 {
 	tuple_unref(env->empty_key);
 	tuple_format_unref(env->key_format);
 }
 
 const char *
-vy_index_name(struct vy_index *index)
+vy_lsm_name(struct vy_lsm *lsm)
 {
 	char *buf = tt_static_buf();
 	snprintf(buf, TT_STATIC_BUF_LEN, "%u/%u",
-		 (unsigned)index->space_id, (unsigned)index->index_id);
+		 (unsigned)lsm->space_id, (unsigned)lsm->index_id);
 	return buf;
 }
 
 size_t
-vy_index_mem_tree_size(struct vy_index *index)
+vy_lsm_mem_tree_size(struct vy_lsm *lsm)
 {
 	struct vy_mem *mem;
-	size_t size = index->mem->tree_extent_size;
-	rlist_foreach_entry(mem, &index->sealed, in_sealed)
+	size_t size = lsm->mem->tree_extent_size;
+	rlist_foreach_entry(mem, &lsm->sealed, in_sealed)
 		size += mem->tree_extent_size;
 	return size;
 }
 
-struct vy_index *
-vy_index_new(struct vy_index_env *index_env, struct vy_cache_env *cache_env,
+struct vy_lsm *
+vy_lsm_new(struct vy_lsm_env *lsm_env, struct vy_cache_env *cache_env,
 	     struct vy_mem_env *mem_env, struct index_def *index_def,
-	     struct tuple_format *format, struct vy_index *pk)
+	     struct tuple_format *format, struct vy_lsm *pk)
 {
 	static int64_t run_buckets[] = {
 		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 50, 100,
@@ -141,17 +141,17 @@ vy_index_new(struct vy_index_env *index_env, struct vy_cache_env *cache_env,
 	assert(index_def->key_def->part_count > 0);
 	assert(index_def->iid == 0 || pk != NULL);
 
-	struct vy_index *index = calloc(1, sizeof(struct vy_index));
-	if (index == NULL) {
-		diag_set(OutOfMemory, sizeof(struct vy_index),
-			 "calloc", "struct vy_index");
+	struct vy_lsm *lsm = calloc(1, sizeof(struct vy_lsm));
+	if (lsm == NULL) {
+		diag_set(OutOfMemory, sizeof(struct vy_lsm),
+			 "calloc", "struct vy_lsm");
 		goto fail;
 	}
-	index->env = index_env;
+	lsm->env = lsm_env;
 
-	index->tree = malloc(sizeof(*index->tree));
-	if (index->tree == NULL) {
-		diag_set(OutOfMemory, sizeof(*index->tree),
+	lsm->tree = malloc(sizeof(*lsm->tree));
+	if (lsm->tree == NULL) {
+		diag_set(OutOfMemory, sizeof(*lsm->tree),
 			 "malloc", "vy_range_tree_t");
 		goto fail_tree;
 	}
@@ -164,105 +164,105 @@ vy_index_new(struct vy_index_env *index_env, struct vy_cache_env *cache_env,
 	if (cmp_def == NULL)
 		goto fail_cmp_def;
 
-	index->cmp_def = cmp_def;
-	index->key_def = key_def;
+	lsm->cmp_def = cmp_def;
+	lsm->key_def = key_def;
 	if (index_def->iid == 0) {
 		/*
 		 * Disk tuples can be returned to an user from a
 		 * primary key. And they must have field
 		 * definitions as well as space->format tuples.
 		 */
-		index->disk_format = format;
+		lsm->disk_format = format;
 		tuple_format_ref(format);
 	} else {
-		index->disk_format = tuple_format_new(&vy_tuple_format_vtab,
-						      &cmp_def, 1, 0, NULL, 0,
-						      NULL);
-		if (index->disk_format == NULL)
+		lsm->disk_format = tuple_format_new(&vy_tuple_format_vtab,
+						    &cmp_def, 1, 0, NULL, 0,
+						    NULL);
+		if (lsm->disk_format == NULL)
 			goto fail_format;
 		for (uint32_t i = 0; i < cmp_def->part_count; ++i) {
 			uint32_t fieldno = cmp_def->parts[i].fieldno;
-			index->disk_format->fields[fieldno].is_nullable =
+			lsm->disk_format->fields[fieldno].is_nullable =
 				format->fields[fieldno].is_nullable;
 		}
 	}
-	tuple_format_ref(index->disk_format);
+	tuple_format_ref(lsm->disk_format);
 
 	if (index_def->iid == 0) {
-		index->upsert_format =
+		lsm->upsert_format =
 			vy_tuple_format_new_upsert(format);
-		if (index->upsert_format == NULL)
+		if (lsm->upsert_format == NULL)
 			goto fail_upsert_format;
-		tuple_format_ref(index->upsert_format);
+		tuple_format_ref(lsm->upsert_format);
 
-		index->mem_format_with_colmask =
+		lsm->mem_format_with_colmask =
 			vy_tuple_format_new_with_colmask(format);
-		if (index->mem_format_with_colmask == NULL)
+		if (lsm->mem_format_with_colmask == NULL)
 			goto fail_mem_format_with_colmask;
-		tuple_format_ref(index->mem_format_with_colmask);
+		tuple_format_ref(lsm->mem_format_with_colmask);
 	} else {
-		index->mem_format_with_colmask = pk->mem_format_with_colmask;
-		index->upsert_format = pk->upsert_format;
-		tuple_format_ref(index->mem_format_with_colmask);
-		tuple_format_ref(index->upsert_format);
+		lsm->mem_format_with_colmask = pk->mem_format_with_colmask;
+		lsm->upsert_format = pk->upsert_format;
+		tuple_format_ref(lsm->mem_format_with_colmask);
+		tuple_format_ref(lsm->upsert_format);
 	}
 
-	if (vy_index_stat_create(&index->stat) != 0)
+	if (vy_lsm_stat_create(&lsm->stat) != 0)
 		goto fail_stat;
 
-	index->run_hist = histogram_new(run_buckets, lengthof(run_buckets));
-	if (index->run_hist == NULL)
+	lsm->run_hist = histogram_new(run_buckets, lengthof(run_buckets));
+	if (lsm->run_hist == NULL)
 		goto fail_run_hist;
 
-	index->mem = vy_mem_new(mem_env, *index->env->p_generation,
-				cmp_def, format, index->mem_format_with_colmask,
-				index->upsert_format, schema_version);
-	if (index->mem == NULL)
+	lsm->mem = vy_mem_new(mem_env, *lsm->env->p_generation,
+			      cmp_def, format, lsm->mem_format_with_colmask,
+			      lsm->upsert_format, schema_version);
+	if (lsm->mem == NULL)
 		goto fail_mem;
 
-	index->id = -1;
-	index->refs = 1;
-	index->dump_lsn = -1;
-	vy_cache_create(&index->cache, cache_env, cmp_def);
-	rlist_create(&index->sealed);
-	vy_range_tree_new(index->tree);
-	vy_range_heap_create(&index->range_heap);
-	rlist_create(&index->runs);
-	index->pk = pk;
+	lsm->id = -1;
+	lsm->refs = 1;
+	lsm->dump_lsn = -1;
+	vy_cache_create(&lsm->cache, cache_env, cmp_def);
+	rlist_create(&lsm->sealed);
+	vy_range_tree_new(lsm->tree);
+	vy_range_heap_create(&lsm->range_heap);
+	rlist_create(&lsm->runs);
+	lsm->pk = pk;
 	if (pk != NULL)
-		vy_index_ref(pk);
-	index->mem_format = format;
-	tuple_format_ref(index->mem_format);
-	index->in_dump.pos = UINT32_MAX;
-	index->in_compact.pos = UINT32_MAX;
-	index->space_id = index_def->space_id;
-	index->index_id = index_def->iid;
-	index->opts = index_def->opts;
-	index->check_is_unique = index->opts.is_unique;
-	vy_index_read_set_new(&index->read_set);
-
-	index_env->index_count++;
-	vy_index_validate_formats(index);
-	return index;
+		vy_lsm_ref(pk);
+	lsm->mem_format = format;
+	tuple_format_ref(lsm->mem_format);
+	lsm->in_dump.pos = UINT32_MAX;
+	lsm->in_compact.pos = UINT32_MAX;
+	lsm->space_id = index_def->space_id;
+	lsm->index_id = index_def->iid;
+	lsm->opts = index_def->opts;
+	lsm->check_is_unique = lsm->opts.is_unique;
+	vy_lsm_read_set_new(&lsm->read_set);
+
+	lsm_env->lsm_count++;
+	vy_lsm_validate_formats(lsm);
+	return lsm;
 
 fail_mem:
-	histogram_delete(index->run_hist);
+	histogram_delete(lsm->run_hist);
 fail_run_hist:
-	vy_index_stat_destroy(&index->stat);
+	vy_lsm_stat_destroy(&lsm->stat);
 fail_stat:
-	tuple_format_unref(index->mem_format_with_colmask);
+	tuple_format_unref(lsm->mem_format_with_colmask);
 fail_mem_format_with_colmask:
-	tuple_format_unref(index->upsert_format);
+	tuple_format_unref(lsm->upsert_format);
 fail_upsert_format:
-	tuple_format_unref(index->disk_format);
+	tuple_format_unref(lsm->disk_format);
 fail_format:
 	key_def_delete(cmp_def);
 fail_cmp_def:
 	key_def_delete(key_def);
 fail_key_def:
-	free(index->tree);
+	free(lsm->tree);
 fail_tree:
-	free(index);
+	free(lsm);
 fail:
 	return NULL;
 }
@@ -280,67 +280,67 @@ vy_range_tree_free_cb(vy_range_tree_t *t, struct vy_range *range, void *arg)
 }
 
 void
-vy_index_delete(struct vy_index *index)
+vy_lsm_delete(struct vy_lsm *lsm)
 {
-	assert(index->refs == 0);
-	assert(index->in_dump.pos == UINT32_MAX);
-	assert(index->in_compact.pos == UINT32_MAX);
-	assert(vy_index_read_set_empty(&index->read_set));
-	assert(index->env->index_count > 0);
+	assert(lsm->refs == 0);
+	assert(lsm->in_dump.pos == UINT32_MAX);
+	assert(lsm->in_compact.pos == UINT32_MAX);
+	assert(vy_lsm_read_set_empty(&lsm->read_set));
+	assert(lsm->env->lsm_count > 0);
 
-	index->env->index_count--;
+	lsm->env->lsm_count--;
 
-	if (index->pk != NULL)
-		vy_index_unref(index->pk);
+	if (lsm->pk != NULL)
+		vy_lsm_unref(lsm->pk);
 
 	struct vy_mem *mem, *next_mem;
-	rlist_foreach_entry_safe(mem, &index->sealed, in_sealed, next_mem)
+	rlist_foreach_entry_safe(mem, &lsm->sealed, in_sealed, next_mem)
 		vy_mem_delete(mem);
-	vy_mem_delete(index->mem);
+	vy_mem_delete(lsm->mem);
 
 	struct vy_run *run, *next_run;
-	rlist_foreach_entry_safe(run, &index->runs, in_index, next_run)
-		vy_index_remove_run(index, run);
-
-	vy_range_tree_iter(index->tree, NULL, vy_range_tree_free_cb, NULL);
-	vy_range_heap_destroy(&index->range_heap);
-	tuple_format_unref(index->disk_format);
-	tuple_format_unref(index->mem_format_with_colmask);
-	tuple_format_unref(index->upsert_format);
-	key_def_delete(index->cmp_def);
-	key_def_delete(index->key_def);
-	histogram_delete(index->run_hist);
-	vy_index_stat_destroy(&index->stat);
-	vy_cache_destroy(&index->cache);
-	tuple_format_unref(index->mem_format);
-	free(index->tree);
-	TRASH(index);
-	free(index);
+	rlist_foreach_entry_safe(run, &lsm->runs, in_lsm, next_run)
+		vy_lsm_remove_run(lsm, run);
+
+	vy_range_tree_iter(lsm->tree, NULL, vy_range_tree_free_cb, NULL);
+	vy_range_heap_destroy(&lsm->range_heap);
+	tuple_format_unref(lsm->disk_format);
+	tuple_format_unref(lsm->mem_format_with_colmask);
+	tuple_format_unref(lsm->upsert_format);
+	key_def_delete(lsm->cmp_def);
+	key_def_delete(lsm->key_def);
+	histogram_delete(lsm->run_hist);
+	vy_lsm_stat_destroy(&lsm->stat);
+	vy_cache_destroy(&lsm->cache);
+	tuple_format_unref(lsm->mem_format);
+	free(lsm->tree);
+	TRASH(lsm);
+	free(lsm);
 }
 
-/** Initialize the range tree of a new index. */
+/** Initialize the range tree of a new LSM tree. */
 static int
-vy_index_init_range_tree(struct vy_index *index)
+vy_lsm_init_range_tree(struct vy_lsm *lsm)
 {
 	struct vy_range *range = vy_range_new(vy_log_next_id(), NULL, NULL,
-					      index->cmp_def);
+					      lsm->cmp_def);
 	if (range == NULL)
 		return -1;
 
-	assert(index->range_count == 0);
-	vy_index_add_range(index, range);
-	vy_index_acct_range(index, range);
+	assert(lsm->range_count == 0);
+	vy_lsm_add_range(lsm, range);
+	vy_lsm_acct_range(lsm, range);
 	return 0;
 }
 
 int
-vy_index_create(struct vy_index *index)
+vy_lsm_create(struct vy_lsm *lsm)
 {
-	/* Make index directory. */
+	/* Make LSM tree directory. */
 	int rc;
 	char path[PATH_MAX];
-	vy_index_snprint_path(path, sizeof(path), index->env->path,
-			      index->space_id, index->index_id);
+	vy_lsm_snprint_path(path, sizeof(path), lsm->env->path,
+			    lsm->space_id, lsm->index_id);
 	char *path_sep = path;
 	while (*path_sep == '/') {
 		/* Don't create root */
@@ -367,17 +367,16 @@ vy_index_create(struct vy_index *index)
 	}
 
 	/* Assign unique id. */
-	assert(index->id < 0);
-	index->id = vy_log_next_id();
+	assert(lsm->id < 0);
+	lsm->id = vy_log_next_id();
 
 	/* Allocate initial range. */
-	return vy_index_init_range_tree(index);
+	return vy_lsm_init_range_tree(lsm);
 }
 
 static struct vy_run *
-vy_index_recover_run(struct vy_index *index,
-		     struct vy_run_recovery_info *run_info,
-		     struct vy_run_env *run_env, bool force_recovery)
+vy_lsm_recover_run(struct vy_lsm *lsm, struct vy_run_recovery_info *run_info,
+		   struct vy_run_env *run_env, bool force_recovery)
 {
 	assert(!run_info->is_dropped);
 	assert(!run_info->is_incomplete);
@@ -392,18 +391,18 @@ vy_index_recover_run(struct vy_index *index,
 		return NULL;
 
 	run->dump_lsn = run_info->dump_lsn;
-	if (vy_run_recover(run, index->env->path,
-			   index->space_id, index->index_id) != 0 &&
+	if (vy_run_recover(run, lsm->env->path,
+			   lsm->space_id, lsm->index_id) != 0 &&
 	    (!force_recovery ||
-	     vy_run_rebuild_index(run, index->env->path,
-				  index->space_id, index->index_id,
-				  index->cmp_def, index->key_def,
-				  index->mem_format, index->upsert_format,
-				  &index->opts) != 0)) {
+	     vy_run_rebuild_index(run, lsm->env->path,
+				  lsm->space_id, lsm->index_id,
+				  lsm->cmp_def, lsm->key_def,
+				  lsm->mem_format, lsm->upsert_format,
+				  &lsm->opts) != 0)) {
 		vy_run_unref(run);
 		return NULL;
 	}
-	vy_index_add_run(index, run);
+	vy_lsm_add_run(lsm, run);
 
 	/*
 	 * The same run can be referenced by more than one slice
@@ -411,48 +410,48 @@ vy_index_recover_run(struct vy_index *index,
 	 * the same run multiple times.
 	 *
 	 * Runs are stored with their reference counters elevated.
-	 * We drop the extra references as soon as index recovery
-	 * is complete (see vy_index_recover()).
+	 * We drop the extra references as soon as LSM tree recovery
+	 * is complete (see vy_lsm_recover()).
 	 */
 	run_info->data = run;
 	return run;
 }
 
 static struct vy_slice *
-vy_index_recover_slice(struct vy_index *index, struct vy_range *range,
-		       struct vy_slice_recovery_info *slice_info,
-		       struct vy_run_env *run_env, bool force_recovery)
+vy_lsm_recover_slice(struct vy_lsm *lsm, struct vy_range *range,
+		     struct vy_slice_recovery_info *slice_info,
+		     struct vy_run_env *run_env, bool force_recovery)
 {
 	struct tuple *begin = NULL, *end = NULL;
 	struct vy_slice *slice = NULL;
 	struct vy_run *run;
 
 	if (slice_info->begin != NULL) {
-		begin = vy_key_from_msgpack(index->env->key_format,
+		begin = vy_key_from_msgpack(lsm->env->key_format,
 					    slice_info->begin);
 		if (begin == NULL)
 			goto out;
 	}
 	if (slice_info->end != NULL) {
-		end = vy_key_from_msgpack(index->env->key_format,
+		end = vy_key_from_msgpack(lsm->env->key_format,
 					  slice_info->end);
 		if (end == NULL)
 			goto out;
 	}
 	if (begin != NULL && end != NULL &&
-	    vy_key_compare(begin, end, index->cmp_def) >= 0) {
+	    vy_key_compare(begin, end, lsm->cmp_def) >= 0) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
 			 tt_sprintf("begin >= end for slice %lld",
 				    (long long)slice_info->id));
 		goto out;
 	}
 
-	run = vy_index_recover_run(index, slice_info->run,
-				   run_env, force_recovery);
+	run = vy_lsm_recover_run(lsm, slice_info->run,
+				 run_env, force_recovery);
 	if (run == NULL)
 		goto out;
 
-	slice = vy_slice_new(slice_info->id, run, begin, end, index->cmp_def);
+	slice = vy_slice_new(slice_info->id, run, begin, end, lsm->cmp_def);
 	if (slice == NULL)
 		goto out;
 
@@ -466,34 +465,34 @@ out:
 }
 
 static struct vy_range *
-vy_index_recover_range(struct vy_index *index,
-		       struct vy_range_recovery_info *range_info,
-		       struct vy_run_env *run_env, bool force_recovery)
+vy_lsm_recover_range(struct vy_lsm *lsm,
+		     struct vy_range_recovery_info *range_info,
+		     struct vy_run_env *run_env, bool force_recovery)
 {
 	struct tuple *begin = NULL, *end = NULL;
 	struct vy_range *range = NULL;
 
 	if (range_info->begin != NULL) {
-		begin = vy_key_from_msgpack(index->env->key_format,
+		begin = vy_key_from_msgpack(lsm->env->key_format,
 					    range_info->begin);
 		if (begin == NULL)
 			goto out;
 	}
 	if (range_info->end != NULL) {
-		end = vy_key_from_msgpack(index->env->key_format,
+		end = vy_key_from_msgpack(lsm->env->key_format,
 					  range_info->end);
 		if (end == NULL)
 			goto out;
 	}
 	if (begin != NULL && end != NULL &&
-	    vy_key_compare(begin, end, index->cmp_def) >= 0) {
+	    vy_key_compare(begin, end, lsm->cmp_def) >= 0) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
 			 tt_sprintf("begin >= end for range %lld",
 				    (long long)range_info->id));
 		goto out;
 	}
 
-	range = vy_range_new(range_info->id, begin, end, index->cmp_def);
+	range = vy_range_new(range_info->id, begin, end, lsm->cmp_def);
 	if (range == NULL)
 		goto out;
 
@@ -504,14 +503,14 @@ vy_index_recover_range(struct vy_index *index,
 	 */
 	struct vy_slice_recovery_info *slice_info;
 	rlist_foreach_entry_reverse(slice_info, &range_info->slices, in_range) {
-		if (vy_index_recover_slice(index, range, slice_info,
-					   run_env, force_recovery) == NULL) {
+		if (vy_lsm_recover_slice(lsm, range, slice_info,
+					 run_env, force_recovery) == NULL) {
 			vy_range_delete(range);
 			range = NULL;
 			goto out;
 		}
 	}
-	vy_index_add_range(index, range);
+	vy_lsm_add_range(lsm, range);
 out:
 	if (begin != NULL)
 		tuple_unref(begin);
@@ -521,13 +520,13 @@ out:
 }
 
 int
-vy_index_recover(struct vy_index *index, struct vy_recovery *recovery,
+vy_lsm_recover(struct vy_lsm *lsm, struct vy_recovery *recovery,
 		 struct vy_run_env *run_env, int64_t lsn,
 		 bool is_checkpoint_recovery, bool force_recovery)
 {
-	assert(index->id < 0);
-	assert(!index->is_committed);
-	assert(index->range_count == 0);
+	assert(lsm->id < 0);
+	assert(!lsm->is_committed);
+	assert(lsm->range_count == 0);
 
 	/*
 	 * Backward compatibility fixup: historically, we used
@@ -536,89 +535,90 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery,
 	 * index by 1. So for legacy indexes use the LSN from
 	 * index options.
 	 */
-	if (index->opts.lsn != 0)
-		lsn = index->opts.lsn;
+	if (lsm->opts.lsn != 0)
+		lsn = lsm->opts.lsn;
 
 	/*
-	 * Look up the last incarnation of the index in vylog.
+	 * Look up the last incarnation of the LSM tree in vylog.
 	 */
-	struct vy_index_recovery_info *index_info;
-	index_info = vy_recovery_index_by_id(recovery,
-			index->space_id, index->index_id);
+	struct vy_lsm_recovery_info *lsm_info;
+	lsm_info = vy_recovery_lsm_by_index_id(recovery,
+			lsm->space_id, lsm->index_id);
 	if (is_checkpoint_recovery) {
-		if (index_info == NULL) {
+		if (lsm_info == NULL) {
 			/*
-			 * All indexes created from snapshot rows must
+			 * All LSM trees created from snapshot rows must
 			 * be present in vylog, because snapshot can
 			 * only succeed if vylog has been successfully
 			 * flushed.
 			 */
 			diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-				 tt_sprintf("Index %u/%u not found",
-					    (unsigned)index->space_id,
-					    (unsigned)index->index_id));
+				 tt_sprintf("LSM tree %u/%u not found",
+					    (unsigned)lsm->space_id,
+					    (unsigned)lsm->index_id));
 			return -1;
 		}
-		if (lsn > index_info->commit_lsn) {
+		if (lsn > lsm_info->commit_lsn) {
 			/*
-			 * The last incarnation of the index was created
-			 * before the last checkpoint, load it now.
+			 * The last incarnation of the LSM tree was
+			 * created before the last checkpoint, load
+			 * it now.
 			 */
-			lsn = index_info->commit_lsn;
+			lsn = lsm_info->commit_lsn;
 		}
 	}
 
-	if (index_info == NULL || lsn > index_info->commit_lsn) {
+	if (lsm_info == NULL || lsn > lsm_info->commit_lsn) {
 		/*
-		 * If we failed to log index creation before restart,
-		 * we won't find it in the log on recovery. This is
-		 * OK as the index doesn't have any runs in this case.
-		 * We will retry to log index in vy_index_commit_create().
+		 * If we failed to log LSM tree creation before restart,
+		 * we won't find it in the log on recovery. This is OK as
+		 * the LSM tree doesn't have any runs in this case. We will
+		 * retry to log LSM tree in vinyl_index_commit_create().
 		 * For now, just create the initial range and assign id.
 		 */
-		index->id = vy_log_next_id();
-		return vy_index_init_range_tree(index);
+		lsm->id = vy_log_next_id();
+		return vy_lsm_init_range_tree(lsm);
 	}
 
-	index->id = index_info->id;
-	index->is_committed = true;
+	lsm->id = lsm_info->id;
+	lsm->is_committed = true;
 
-	if (lsn < index_info->commit_lsn || index_info->is_dropped) {
+	if (lsn < lsm_info->commit_lsn || lsm_info->is_dropped) {
 		/*
-		 * Loading a past incarnation of the index, i.e.
-		 * the index is going to dropped during final
+		 * Loading a past incarnation of the LSM tree, i.e.
+		 * the LSM tree is going to dropped during final
 		 * recovery. Mark it as such.
 		 */
-		index->is_dropped = true;
+		lsm->is_dropped = true;
 		/*
-		 * We need range tree initialized for all indexes,
+		 * We need range tree initialized for all LSM trees,
 		 * even for dropped ones.
 		 */
-		return vy_index_init_range_tree(index);
+		return vy_lsm_init_range_tree(lsm);
 	}
 
 	/*
-	 * Loading the last incarnation of the index from vylog.
+	 * Loading the last incarnation of the LSM tree from vylog.
 	 */
-	index->dump_lsn = index_info->dump_lsn;
+	lsm->dump_lsn = lsm_info->dump_lsn;
 
 	int rc = 0;
 	struct vy_range_recovery_info *range_info;
-	rlist_foreach_entry(range_info, &index_info->ranges, in_index) {
-		if (vy_index_recover_range(index, range_info,
-					   run_env, force_recovery) == NULL) {
+	rlist_foreach_entry(range_info, &lsm_info->ranges, in_lsm) {
+		if (vy_lsm_recover_range(lsm, range_info, run_env,
+					 force_recovery) == NULL) {
 			rc = -1;
 			break;
 		}
 	}
 
 	/*
-	 * vy_index_recover_run() elevates reference counter
+	 * vy_lsm_recover_run() elevates reference counter
 	 * of each recovered run. We need to drop the extra
 	 * references once we are done.
 	 */
 	struct vy_run *run;
-	rlist_foreach_entry(run, &index->runs, in_index) {
+	rlist_foreach_entry(run, &lsm->runs, in_lsm) {
 		assert(run->refs > 1);
 		vy_run_unref(run);
 	}
@@ -627,12 +627,12 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery,
 		return -1;
 
 	/*
-	 * Account ranges to the index and check that the range tree
+	 * Account ranges to the LSM tree and check that the range tree
 	 * does not have holes or overlaps.
 	 */
 	struct vy_range *range, *prev = NULL;
-	for (range = vy_range_tree_first(index->tree); range != NULL;
-	     prev = range, range = vy_range_tree_next(index->tree, range)) {
+	for (range = vy_range_tree_first(lsm->tree); range != NULL;
+	     prev = range, range = vy_range_tree_next(lsm->tree, range)) {
 		if (prev == NULL && range->begin != NULL) {
 			diag_set(ClientError, ER_INVALID_VYLOG_FILE,
 				 tt_sprintf("Range %lld is leftmost but "
@@ -644,7 +644,7 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery,
 		if (prev != NULL &&
 		    (prev->end == NULL || range->begin == NULL ||
 		     (cmp = vy_key_compare(prev->end, range->begin,
-					   index->cmp_def)) != 0)) {
+					   lsm->cmp_def)) != 0)) {
 			const char *errmsg = cmp > 0 ?
 				"Nearby ranges %lld and %lld overlap" :
 				"Keys between ranges %lld and %lld not spanned";
@@ -654,12 +654,12 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery,
 					    (long long)range->id));
 			return -1;
 		}
-		vy_index_acct_range(index, range);
+		vy_lsm_acct_range(lsm, range);
 	}
 	if (prev == NULL) {
 		diag_set(ClientError, ER_INVALID_VYLOG_FILE,
-			 tt_sprintf("Index %lld has empty range tree",
-				    (long long)index->id));
+			 tt_sprintf("LSM tree %lld has empty range tree",
+				    (long long)lsm->id));
 		return -1;
 	}
 	if (prev->end != NULL) {
@@ -673,17 +673,17 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery,
 }
 
 int64_t
-vy_index_generation(struct vy_index *index)
+vy_lsm_generation(struct vy_lsm *lsm)
 {
-	struct vy_mem *oldest = rlist_empty(&index->sealed) ? index->mem :
-		rlist_last_entry(&index->sealed, struct vy_mem, in_sealed);
+	struct vy_mem *oldest = rlist_empty(&lsm->sealed) ? lsm->mem :
+		rlist_last_entry(&lsm->sealed, struct vy_mem, in_sealed);
 	return oldest->generation;
 }
 
 int
-vy_index_compact_priority(struct vy_index *index)
+vy_lsm_compact_priority(struct vy_lsm *lsm)
 {
-	struct heap_node *n = vy_range_heap_top(&index->range_heap);
+	struct heap_node *n = vy_range_heap_top(&lsm->range_heap);
 	if (n == NULL)
 		return 0;
 	struct vy_range *range = container_of(n, struct vy_range, heap_node);
@@ -691,98 +691,98 @@ vy_index_compact_priority(struct vy_index *index)
 }
 
 void
-vy_index_add_run(struct vy_index *index, struct vy_run *run)
+vy_lsm_add_run(struct vy_lsm *lsm, struct vy_run *run)
 {
-	assert(rlist_empty(&run->in_index));
-	rlist_add_entry(&index->runs, run, in_index);
-	index->run_count++;
-	vy_disk_stmt_counter_add(&index->stat.disk.count, &run->count);
+	assert(rlist_empty(&run->in_lsm));
+	rlist_add_entry(&lsm->runs, run, in_lsm);
+	lsm->run_count++;
+	vy_disk_stmt_counter_add(&lsm->stat.disk.count, &run->count);
 
-	index->bloom_size += vy_run_bloom_size(run);
-	index->page_index_size += run->page_index_size;
+	lsm->bloom_size += vy_run_bloom_size(run);
+	lsm->page_index_size += run->page_index_size;
 
-	index->env->bloom_size += vy_run_bloom_size(run);
-	index->env->page_index_size += run->page_index_size;
+	lsm->env->bloom_size += vy_run_bloom_size(run);
+	lsm->env->page_index_size += run->page_index_size;
 }
 
 void
-vy_index_remove_run(struct vy_index *index, struct vy_run *run)
+vy_lsm_remove_run(struct vy_lsm *lsm, struct vy_run *run)
 {
-	assert(index->run_count > 0);
-	assert(!rlist_empty(&run->in_index));
-	rlist_del_entry(run, in_index);
-	index->run_count--;
-	vy_disk_stmt_counter_sub(&index->stat.disk.count, &run->count);
+	assert(lsm->run_count > 0);
+	assert(!rlist_empty(&run->in_lsm));
+	rlist_del_entry(run, in_lsm);
+	lsm->run_count--;
+	vy_disk_stmt_counter_sub(&lsm->stat.disk.count, &run->count);
 
-	index->bloom_size -= vy_run_bloom_size(run);
-	index->page_index_size -= run->page_index_size;
+	lsm->bloom_size -= vy_run_bloom_size(run);
+	lsm->page_index_size -= run->page_index_size;
 
-	index->env->bloom_size -= vy_run_bloom_size(run);
-	index->env->page_index_size -= run->page_index_size;
+	lsm->env->bloom_size -= vy_run_bloom_size(run);
+	lsm->env->page_index_size -= run->page_index_size;
 }
 
 void
-vy_index_add_range(struct vy_index *index, struct vy_range *range)
+vy_lsm_add_range(struct vy_lsm *lsm, struct vy_range *range)
 {
 	assert(range->heap_node.pos == UINT32_MAX);
-	vy_range_heap_insert(&index->range_heap, &range->heap_node);
-	vy_range_tree_insert(index->tree, range);
-	index->range_count++;
+	vy_range_heap_insert(&lsm->range_heap, &range->heap_node);
+	vy_range_tree_insert(lsm->tree, range);
+	lsm->range_count++;
 }
 
 void
-vy_index_remove_range(struct vy_index *index, struct vy_range *range)
+vy_lsm_remove_range(struct vy_lsm *lsm, struct vy_range *range)
 {
 	assert(range->heap_node.pos != UINT32_MAX);
-	vy_range_heap_delete(&index->range_heap, &range->heap_node);
-	vy_range_tree_remove(index->tree, range);
-	index->range_count--;
+	vy_range_heap_delete(&lsm->range_heap, &range->heap_node);
+	vy_range_tree_remove(lsm->tree, range);
+	lsm->range_count--;
 }
 
 void
-vy_index_acct_range(struct vy_index *index, struct vy_range *range)
+vy_lsm_acct_range(struct vy_lsm *lsm, struct vy_range *range)
 {
-	histogram_collect(index->run_hist, range->slice_count);
+	histogram_collect(lsm->run_hist, range->slice_count);
 }
 
 void
-vy_index_unacct_range(struct vy_index *index, struct vy_range *range)
+vy_lsm_unacct_range(struct vy_lsm *lsm, struct vy_range *range)
 {
-	histogram_discard(index->run_hist, range->slice_count);
+	histogram_discard(lsm->run_hist, range->slice_count);
 }
 
 int
-vy_index_rotate_mem(struct vy_index *index)
+vy_lsm_rotate_mem(struct vy_lsm *lsm)
 {
 	struct vy_mem *mem;
 
-	assert(index->mem != NULL);
-	mem = vy_mem_new(index->mem->env, *index->env->p_generation,
-			 index->cmp_def, index->mem_format,
-			 index->mem_format_with_colmask,
-			 index->upsert_format, schema_version);
+	assert(lsm->mem != NULL);
+	mem = vy_mem_new(lsm->mem->env, *lsm->env->p_generation,
+			 lsm->cmp_def, lsm->mem_format,
+			 lsm->mem_format_with_colmask,
+			 lsm->upsert_format, schema_version);
 	if (mem == NULL)
 		return -1;
 
-	rlist_add_entry(&index->sealed, index->mem, in_sealed);
-	index->mem = mem;
-	index->mem_list_version++;
+	rlist_add_entry(&lsm->sealed, lsm->mem, in_sealed);
+	lsm->mem = mem;
+	lsm->mem_list_version++;
 	return 0;
 }
 
 void
-vy_index_delete_mem(struct vy_index *index, struct vy_mem *mem)
+vy_lsm_delete_mem(struct vy_lsm *lsm, struct vy_mem *mem)
 {
 	assert(!rlist_empty(&mem->in_sealed));
 	rlist_del_entry(mem, in_sealed);
-	vy_stmt_counter_sub(&index->stat.memory.count, &mem->count);
+	vy_stmt_counter_sub(&lsm->stat.memory.count, &mem->count);
 	vy_mem_delete(mem);
-	index->mem_list_version++;
+	lsm->mem_list_version++;
 }
 
 int
-vy_index_set(struct vy_index *index, struct vy_mem *mem,
-	     const struct tuple *stmt, const struct tuple **region_stmt)
+vy_lsm_set(struct vy_lsm *lsm, struct vy_mem *mem,
+	   const struct tuple *stmt, const struct tuple **region_stmt)
 {
 	assert(vy_stmt_is_refable(stmt));
 	assert(*region_stmt == NULL || !vy_stmt_is_refable(*region_stmt));
@@ -796,7 +796,7 @@ vy_index_set(struct vy_index *index, struct vy_mem *mem,
 	}
 
 	/* We can't free region_stmt below, so let's add it to the stats */
-	index->stat.memory.count.bytes += tuple_size(stmt);
+	lsm->stat.memory.count.bytes += tuple_size(stmt);
 
 	uint32_t format_id = stmt->format_id;
 	if (vy_stmt_type(*region_stmt) != IPROTO_UPSERT) {
@@ -820,15 +820,15 @@ vy_index_set(struct vy_index *index, struct vy_mem *mem,
 /**
  * Calculate and record the number of sequential upserts, squash
  * immediately or schedule upsert process if needed.
- * Additional handler used in vy_index_commit_stmt() for UPSERT
+ * Additional handler used in vy_lsm_commit_stmt() for UPSERT
  * statements.
  *
- * @param index Index the statement was committed to.
+ * @param lsm   LSM tree the statement was committed to.
  * @param mem   In-memory tree where the statement was saved.
  * @param stmt  UPSERT statement to squash.
  */
 static void
-vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem,
+vy_lsm_commit_upsert(struct vy_lsm *lsm, struct vy_mem *mem,
 		       const struct tuple *stmt)
 {
 	assert(vy_stmt_type(stmt) == IPROTO_UPSERT);
@@ -837,7 +837,7 @@ vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem,
 	 * UPSERT is enabled only for the spaces with the single
 	 * index.
 	 */
-	assert(index->index_id == 0);
+	assert(lsm->index_id == 0);
 
 	const struct tuple *older;
 	int64_t lsn = vy_stmt_lsn(stmt);
@@ -870,15 +870,15 @@ vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem,
 		assert(older != NULL && vy_stmt_type(older) == IPROTO_UPSERT &&
 		       vy_stmt_n_upserts(older) == VY_UPSERT_THRESHOLD - 1);
 #endif
-		if (index->env->upsert_thresh_cb == NULL) {
+		if (lsm->env->upsert_thresh_cb == NULL) {
 			/* Squash callback is not installed. */
 			return;
 		}
 
-		struct tuple *dup = vy_stmt_dup(stmt, index->upsert_format);
+		struct tuple *dup = vy_stmt_dup(stmt, lsm->upsert_format);
 		if (dup != NULL) {
-			index->env->upsert_thresh_cb(index, dup,
-					index->env->upsert_thresh_arg);
+			lsm->env->upsert_thresh_cb(lsm, dup,
+					lsm->env->upsert_thresh_arg);
 			tuple_unref(dup);
 		}
 		/*
@@ -893,15 +893,15 @@ vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem,
 	 * then we can turn the UPSERT into the REPLACE.
 	 */
 	if (n_upserts == 0 &&
-	    index->stat.memory.count.rows == index->mem->count.rows &&
-	    index->run_count == 0) {
+	    lsm->stat.memory.count.rows == lsm->mem->count.rows &&
+	    lsm->run_count == 0) {
 		older = vy_mem_older_lsn(mem, stmt);
 		assert(older == NULL || vy_stmt_type(older) != IPROTO_UPSERT);
 		struct tuple *upserted =
-			vy_apply_upsert(stmt, older, index->cmp_def,
-					index->mem_format,
-					index->upsert_format, false);
-		index->stat.upsert.applied++;
+			vy_apply_upsert(stmt, older, lsm->cmp_def,
+					lsm->mem_format,
+					lsm->upsert_format, false);
+		lsm->stat.upsert.applied++;
 
 		if (upserted == NULL) {
 			/* OOM */
@@ -934,53 +934,53 @@ vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem,
 			return;
 		}
 
-		int rc = vy_index_set(index, mem, upserted, &region_stmt);
+		int rc = vy_lsm_set(lsm, mem, upserted, &region_stmt);
 		/**
 		 * Since we have already allocated mem statement and
 		 * now we replacing one statement with another, the
-		 * vy_index_set() cannot fail.
+		 * vy_lsm_set() cannot fail.
 		 */
 		assert(rc == 0); (void)rc;
 		tuple_unref(upserted);
 		vy_mem_commit_stmt(mem, region_stmt);
-		index->stat.upsert.squashed++;
+		lsm->stat.upsert.squashed++;
 	}
 }
 
 void
-vy_index_commit_stmt(struct vy_index *index, struct vy_mem *mem,
+vy_lsm_commit_stmt(struct vy_lsm *lsm, struct vy_mem *mem,
 		     const struct tuple *stmt)
 {
 	vy_mem_commit_stmt(mem, stmt);
 
-	index->stat.memory.count.rows++;
+	lsm->stat.memory.count.rows++;
 
 	if (vy_stmt_type(stmt) == IPROTO_UPSERT)
-		vy_index_commit_upsert(index, mem, stmt);
+		vy_lsm_commit_upsert(lsm, mem, stmt);
 
-	vy_stmt_counter_acct_tuple(&index->stat.put, stmt);
+	vy_stmt_counter_acct_tuple(&lsm->stat.put, stmt);
 
 	/* Invalidate cache element. */
-	vy_cache_on_write(&index->cache, stmt, NULL);
+	vy_cache_on_write(&lsm->cache, stmt, NULL);
 }
 
 void
-vy_index_rollback_stmt(struct vy_index *index, struct vy_mem *mem,
+vy_lsm_rollback_stmt(struct vy_lsm *lsm, struct vy_mem *mem,
 		       const struct tuple *stmt)
 {
 	vy_mem_rollback_stmt(mem, stmt);
 
 	/* Invalidate cache element. */
-	vy_cache_on_write(&index->cache, stmt, NULL);
+	vy_cache_on_write(&lsm->cache, stmt, NULL);
 }
 
 bool
-vy_index_split_range(struct vy_index *index, struct vy_range *range)
+vy_lsm_split_range(struct vy_lsm *lsm, struct vy_range *range)
 {
-	struct tuple_format *key_format = index->env->key_format;
+	struct tuple_format *key_format = lsm->env->key_format;
 
 	const char *split_key_raw;
-	if (!vy_range_needs_split(range, &index->opts, &split_key_raw))
+	if (!vy_range_needs_split(range, &lsm->opts, &split_key_raw))
 		return false;
 
 	/* Split a range in two parts. */
@@ -1007,7 +1007,7 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range)
 	struct vy_range *part, *parts[2] = {NULL, };
 	for (int i = 0; i < n_parts; i++) {
 		part = vy_range_new(vy_log_next_id(), keys[i], keys[i + 1],
-				    index->cmp_def);
+				    lsm->cmp_def);
 		if (part == NULL)
 			goto fail;
 		parts[i] = part;
@@ -1018,7 +1018,7 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range)
 		 */
 		rlist_foreach_entry_reverse(slice, &range->slices, in_range) {
 			if (vy_slice_cut(slice, vy_log_next_id(), part->begin,
-					 part->end, index->cmp_def,
+					 part->end, lsm->cmp_def,
 					 &new_slice) != 0)
 				goto fail;
 			if (new_slice != NULL)
@@ -1036,7 +1036,7 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range)
 	vy_log_delete_range(range->id);
 	for (int i = 0; i < n_parts; i++) {
 		part = parts[i];
-		vy_log_insert_range(index->id, part->id,
+		vy_log_insert_range(lsm->id, part->id,
 				    tuple_data_or_null(part->begin),
 				    tuple_data_or_null(part->end));
 		rlist_foreach_entry(slice, &part->slices, in_range)
@@ -1048,19 +1048,19 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range)
 		goto fail;
 
 	/*
-	 * Replace the old range in the index.
+	 * Replace the old range in the LSM tree.
 	 */
-	vy_index_unacct_range(index, range);
-	vy_index_remove_range(index, range);
+	vy_lsm_unacct_range(lsm, range);
+	vy_lsm_remove_range(lsm, range);
 
 	for (int i = 0; i < n_parts; i++) {
 		part = parts[i];
-		vy_index_add_range(index, part);
-		vy_index_acct_range(index, part);
+		vy_lsm_add_range(lsm, part);
+		vy_lsm_acct_range(lsm, part);
 	}
-	index->range_tree_version++;
+	lsm->range_tree_version++;
 
-	say_info("%s: split range %s by key %s", vy_index_name(index),
+	say_info("%s: split range %s by key %s", vy_lsm_name(lsm),
 		 vy_range_str(range), tuple_str(split_key));
 
 	rlist_foreach_entry(slice, &range->slices, in_range)
@@ -1078,34 +1078,34 @@ fail:
 
 	diag_log();
 	say_error("%s: failed to split range %s",
-		  vy_index_name(index), vy_range_str(range));
+		  vy_lsm_name(lsm), vy_range_str(range));
 	return false;
 }
 
 bool
-vy_index_coalesce_range(struct vy_index *index, struct vy_range *range)
+vy_lsm_coalesce_range(struct vy_lsm *lsm, struct vy_range *range)
 {
 	struct vy_range *first, *last;
-	if (!vy_range_needs_coalesce(range, index->tree, &index->opts,
+	if (!vy_range_needs_coalesce(range, lsm->tree, &lsm->opts,
 				     &first, &last))
 		return false;
 
 	struct vy_range *result = vy_range_new(vy_log_next_id(),
-			first->begin, last->end, index->cmp_def);
+			first->begin, last->end, lsm->cmp_def);
 	if (result == NULL)
 		goto fail_range;
 
 	struct vy_range *it;
-	struct vy_range *end = vy_range_tree_next(index->tree, last);
+	struct vy_range *end = vy_range_tree_next(lsm->tree, last);
 
 	/*
 	 * Log change in metadata.
 	 */
 	vy_log_tx_begin();
-	vy_log_insert_range(index->id, result->id,
+	vy_log_insert_range(lsm->id, result->id,
 			    tuple_data_or_null(result->begin),
 			    tuple_data_or_null(result->end));
-	for (it = first; it != end; it = vy_range_tree_next(index->tree, it)) {
+	for (it = first; it != end; it = vy_range_tree_next(lsm->tree, it)) {
 		struct vy_slice *slice;
 		rlist_foreach_entry(slice, &it->slices, in_range)
 			vy_log_delete_slice(slice->id);
@@ -1125,9 +1125,9 @@ vy_index_coalesce_range(struct vy_index *index, struct vy_range *range)
 	 */
 	it = first;
 	while (it != end) {
-		struct vy_range *next = vy_range_tree_next(index->tree, it);
-		vy_index_unacct_range(index, it);
-		vy_index_remove_range(index, it);
+		struct vy_range *next = vy_range_tree_next(lsm->tree, it);
+		vy_lsm_unacct_range(lsm, it);
+		vy_lsm_remove_range(lsm, it);
 		rlist_splice(&result->slices, &it->slices);
 		result->slice_count += it->slice_count;
 		vy_disk_stmt_counter_add(&result->count, &it->count);
@@ -1141,12 +1141,12 @@ vy_index_coalesce_range(struct vy_index *index, struct vy_range *range)
 	 * as soon as we can.
 	 */
 	result->compact_priority = result->slice_count;
-	vy_index_acct_range(index, result);
-	vy_index_add_range(index, result);
-	index->range_tree_version++;
+	vy_lsm_acct_range(lsm, result);
+	vy_lsm_add_range(lsm, result);
+	lsm->range_tree_version++;
 
 	say_info("%s: coalesced ranges %s",
-		 vy_index_name(index), vy_range_str(result));
+		 vy_lsm_name(lsm), vy_range_str(result));
 	return true;
 
 fail_commit:
@@ -1154,6 +1154,6 @@ fail_commit:
 fail_range:
 	diag_log();
 	say_error("%s: failed to coalesce range %s",
-		  vy_index_name(index), vy_range_str(range));
+		  vy_lsm_name(lsm), vy_range_str(range));
 	return false;
 }
diff --git a/src/box/vy_index.h b/src/box/vy_lsm.h
similarity index 59%
rename from src/box/vy_index.h
rename to src/box/vy_lsm.h
index 33d1da4a..dcfbcb7b 100644
--- a/src/box/vy_index.h
+++ b/src/box/vy_lsm.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDES_TARANTOOL_BOX_VY_INDEX_H
-#define INCLUDES_TARANTOOL_BOX_VY_INDEX_H
+#ifndef INCLUDES_TARANTOOL_BOX_VY_LSM_H
+#define INCLUDES_TARANTOOL_BOX_VY_LSM_H
 /*
  * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
  *
@@ -52,7 +52,7 @@ extern "C" {
 struct histogram;
 struct tuple;
 struct tuple_format;
-struct vy_index;
+struct vy_lsm;
 struct vy_mem;
 struct vy_mem_env;
 struct vy_recovery;
@@ -60,10 +60,10 @@ struct vy_run;
 struct vy_run_env;
 
 typedef void
-(*vy_upsert_thresh_cb)(struct vy_index *index, struct tuple *stmt, void *arg);
+(*vy_upsert_thresh_cb)(struct vy_lsm *lsm, struct tuple *stmt, void *arg);
 
-/** Common index environment. */
-struct vy_index_env {
+/** Common LSM tree environment. */
+struct vy_lsm_env {
 	/** Path to the data directory. */
 	const char *path;
 	/** Memory generation counter. */
@@ -84,27 +84,29 @@ struct vy_index_env {
 	vy_upsert_thresh_cb upsert_thresh_cb;
 	/** Argument passed to upsert_thresh_cb. */
 	void *upsert_thresh_arg;
-	/** Number of indexes in this environment. */
-	int index_count;
+	/** Number of LSM trees in this environment. */
+	int lsm_count;
 	/** Size of memory used for bloom filters. */
 	size_t bloom_size;
 	/** Size of memory used for page index. */
 	size_t page_index_size;
 };
 
-/** Create a common index environment. */
+/** Create a common LSM tree environment. */
 int
-vy_index_env_create(struct vy_index_env *env, const char *path,
-		    int64_t *p_generation,
-		    vy_upsert_thresh_cb upsert_thresh_cb,
-		    void *upsert_thresh_arg);
+vy_lsm_env_create(struct vy_lsm_env *env, const char *path,
+		  int64_t *p_generation,
+		  vy_upsert_thresh_cb upsert_thresh_cb,
+		  void *upsert_thresh_arg);
 
-/** Destroy a common index environment. */
+/** Destroy a common LSM tree environment. */
 void
-vy_index_env_destroy(struct vy_index_env *env);
+vy_lsm_env_destroy(struct vy_lsm_env *env);
 
 /**
  * A struct for primary and secondary Vinyl indexes.
+ * Named after the data structure used for organizing
+ * data on disk - log-structured merge-tree (LSM tree).
  *
  * Vinyl primary and secondary indexes work differently:
  *
@@ -125,7 +127,7 @@ vy_index_env_destroy(struct vy_index_env *env);
  * When a search in a secondary index is made, we first look up
  * the secondary index tuple, containing the primary key, and then
  * use this key to find the original tuple in the primary index.
-
+ *
  * While the primary index has only one key_def that is
  * used for validating and comparing tuples, secondary index needs
  * two:
@@ -140,19 +142,19 @@ vy_index_env_destroy(struct vy_index_env *env);
  *   parts concatenated together construe the tuple of the
  *   secondary key, i.e. the tuple stored. This is key_def.
  */
-struct vy_index {
-	/** Common index environment. */
-	struct vy_index_env *env;
+struct vy_lsm {
+	/** Common LSM tree environment. */
+	struct vy_lsm_env *env;
 	/**
-	 * Reference counter. Used to postpone index deletion
+	 * Reference counter. Used to postpone LSM tree deletion
 	 * until all pending operations have completed.
 	 */
 	int refs;
-	/** Unique ID of this index. */
+	/** Unique ID of this LSM tree. */
 	int64_t id;
-	/** Ordinal index number in the index array. */
+	/** ID of the index this LSM tree is for. */
 	uint32_t index_id;
-	/** ID of the space this index belongs to. */
+	/** ID of the space this LSM tree is for. */
 	uint32_t space_id;
 	/** Index options. */
 	struct index_opts opts;
@@ -161,14 +163,15 @@ struct vy_index {
 	/** Key definition passed by the user. */
 	struct key_def *key_def;
 	/**
-	 * If the following flag is set the index is unique and
-	 * it must be checked for duplicates on INSERT. Otherwise,
-	 * the check can be skipped, either because this index
-	 * is not unique or it is a part of another unique index.
+	 * If the following flag is set, the index this LSM tree
+	 * is created for is unique and it must be checked for
+	 * duplicates on INSERT. Otherwise, the check can be skipped,
+	 * either because the index is not unique or it is a part
+	 * of another unique index.
 	 */
 	bool check_is_unique;
 	/**
-	 * Tuple format for tuples of this index created when
+	 * Tuple format for tuples of this LSM tree created when
 	 * reading pages from disk.
 	 * Is distinct from mem_format only for secondary keys,
 	 * whose tuples have MP_NIL in all "gap" positions between
@@ -180,7 +183,7 @@ struct vy_index {
 	 * tuples.
 	 */
 	struct tuple_format *disk_format;
-	/** Tuple format of the space this index belongs to. */
+	/** Tuple format of the space this LSM tree belongs to. */
 	struct tuple_format *mem_format;
 	/**
 	 * Format for tuples of type REPLACE or DELETE which
@@ -196,14 +199,16 @@ struct vy_index {
 	 */
 	struct tuple_format *upsert_format;
 	/**
-	 * Primary index of the same space or NULL if this index
-	 * is primary. Referenced by each secondary index.
+	 * If this LSM tree is for a secondary index, the following
+	 * variable points to the LSM tree of the primary index of
+	 * the same space, otherwise it is set to NULL. Referenced
+	 * by each secondary index.
 	 */
-	struct vy_index *pk;
-	/** Index statistics. */
-	struct vy_index_stat stat;
+	struct vy_lsm *pk;
+	/** LSM tree statistics. */
+	struct vy_lsm_stat stat;
 	/**
-	 * Merge cache of this index. Contains hottest tuples
+	 * Merge cache of this LSM tree. Contains hottest tuples
 	 * with continuation markers.
 	 */
 	struct vy_cache cache;
@@ -216,23 +221,23 @@ struct vy_index {
 	 */
 	struct rlist sealed;
 	/**
-	 * Tree of all ranges of this index, linked by
+	 * Tree of all ranges of this LSM tree, linked by
 	 * vy_range->tree_node, ordered by vy_range->begin.
 	 */
 	vy_range_tree_t *tree;
-	/** Number of ranges in this index. */
+	/** Number of ranges in this LSM tree. */
 	int range_count;
 	/** Heap of ranges, prioritized by compact_priority. */
 	heap_t range_heap;
 	/**
-	 * List of all runs created for this index,
-	 * linked by vy_run->in_index.
+	 * List of all runs created for this LSM tree,
+	 * linked by vy_run->in_lsm.
 	 */
 	struct rlist runs;
 	/** Number of entries in all ranges. */
 	int run_count;
 	/**
-	 * Histogram accounting how many ranges of the index
+	 * Histogram accounting how many ranges of the LSM tree
 	 * have a particular number of runs.
 	 */
 	struct histogram *run_hist;
@@ -251,182 +256,182 @@ struct vy_index {
 	 */
 	uint32_t range_tree_version;
 	/**
-	 * LSN of the last dump or -1 if the index has not
+	 * LSN of the last dump or -1 if the LSM tree has not
 	 * been dumped yet.
 	 */
 	int64_t dump_lsn;
 	/*
-	 * This flag is set if the index creation was
+	 * This flag is set if the LSM tree creation was
 	 * committed to the metadata log.
 	 */
 	bool is_committed;
 	/**
-	 * This flag is set if the index was dropped.
-	 * It is also set on local recovery if the index
+	 * This flag is set if the LSM tree was dropped.
+	 * It is also set on local recovery if the LSM tree
 	 * will be dropped when WAL is replayed.
 	 */
 	bool is_dropped;
 	/**
-	 * If pin_count > 0 the index can't be scheduled for dump.
+	 * If pin_count > 0 the LSM tree can't be scheduled for dump.
 	 * Used to make sure that the primary index is dumped last.
 	 */
 	int pin_count;
-	/** Set if the index is currently being dumped. */
+	/** Set if the LSM tree is currently being dumped. */
 	bool is_dumping;
 	/** Link in vy_scheduler->dump_heap. */
 	struct heap_node in_dump;
 	/** Link in vy_scheduler->compact_heap. */
 	struct heap_node in_compact;
 	/**
-	 * Interval tree containing reads from this index done by all
-	 * active transactions. Linked by vy_tx_interval->in_index.
+	 * Interval tree containing reads from this LSM tree done by
+	 * all active transactions. Linked by vy_tx_interval->in_lsm.
 	 * Used to abort transactions that conflict with a write to
-	 * the index.
+	 * this LSM tree.
 	 */
-	vy_index_read_set_t read_set;
+	vy_lsm_read_set_t read_set;
 };
 
 /**
- * Assert if an index formats are inconsistent.
- * @param index Index to validate.
+ * Assert if an LSM tree formats are inconsistent.
+ * @param lsm LSM tree to validate.
  */
 void
-vy_index_validate_formats(const struct vy_index *index);
+vy_lsm_validate_formats(const struct vy_lsm *lsm);
 
-/** Return index name. Used for logging. */
+/** Return LSM tree name. Used for logging. */
 const char *
-vy_index_name(struct vy_index *index);
+vy_lsm_name(struct vy_lsm *lsm);
 
 /** Return sum size of memory tree extents. */
 size_t
-vy_index_mem_tree_size(struct vy_index *index);
+vy_lsm_mem_tree_size(struct vy_lsm *lsm);
 
-/** Allocate a new index object. */
-struct vy_index *
-vy_index_new(struct vy_index_env *index_env, struct vy_cache_env *cache_env,
+/** Allocate a new LSM tree object. */
+struct vy_lsm *
+vy_lsm_new(struct vy_lsm_env *lsm_env, struct vy_cache_env *cache_env,
 	     struct vy_mem_env *mem_env, struct index_def *index_def,
-	     struct tuple_format *format, struct vy_index *pk);
+	     struct tuple_format *format, struct vy_lsm *pk);
 
-/** Free an index object. */
+/** Free an LSM tree object. */
 void
-vy_index_delete(struct vy_index *index);
+vy_lsm_delete(struct vy_lsm *lsm);
 
 /**
- * Increment the reference counter of a vinyl index.
- * An index cannot be deleted if its reference counter
- * is elevated.
+ * Increment the reference counter of an LSM tree.
+ * An LSM tree cannot be deleted if its reference
+ * counter is elevated.
  */
 static inline void
-vy_index_ref(struct vy_index *index)
+vy_lsm_ref(struct vy_lsm *lsm)
 {
-	assert(index->refs >= 0);
-	index->refs++;
+	assert(lsm->refs >= 0);
+	lsm->refs++;
 }
 
 /**
- * Decrement the reference counter of a vinyl index.
- * If the reference counter reaches 0, the index is
- * deleted with vy_index_delete().
+ * Decrement the reference counter of an LSM tree.
+ * If the reference counter reaches 0, the LSM tree
+ * is deleted with vy_lsm_delete().
  */
 static inline void
-vy_index_unref(struct vy_index *index)
+vy_lsm_unref(struct vy_lsm *lsm)
 {
-	assert(index->refs > 0);
-	if (--index->refs == 0)
-		vy_index_delete(index);
+	assert(lsm->refs > 0);
+	if (--lsm->refs == 0)
+		vy_lsm_delete(lsm);
 }
 
 /**
- * Create a new vinyl index.
+ * Create a new LSM tree.
  *
- * This function is called when an index is created after recovery
- * is complete or during remote recovery. It initializes the range
- * tree and makes the index directory.
+ * This function is called when an LSM tree is created
+ * after recovery is complete or during remote recovery.
+ * It initializes the range tree and makes the LSM tree
+ * directory.
  */
 int
-vy_index_create(struct vy_index *index);
+vy_lsm_create(struct vy_lsm *lsm);
 
 /**
- * Load a vinyl index from disk. Called on local recovery.
+ * Load an LSM tree from disk. Called on local recovery.
  *
- * This function retrieves the index structure from the
- * metadata log, rebuilds the range tree, and opens run
- * files.
+ * This function retrieves the LSM tree structure from the
+ * metadata log, rebuilds the range tree, and opens run files.
  *
- * If @is_checkpoint_recovery is set, the index is recovered from
- * the last snapshot. In particular, this means that the index
- * must have been logged in the metadata log and so if the
+ * If @is_checkpoint_recovery is set, the LSM tree is recovered
+ * from the last snapshot. In particular, this means that the LSM
+ * tree must have been logged in the metadata log and so if the
  * function does not find it in the recovery context, it will
- * fail. If the flag is unset, the index is recovered from a
- * WAL, in which case a missing index is OK - it just means we
+ * fail. If the flag is unset, the LSM tree is recovered from a
+ * WAL, in which case a missing LSM tree is OK - it just means we
  * failed to log it before restart and have to retry during
  * WAL replay.
  *
- * @lsn is the LSN of the row that created the index.
- * If the index is recovered from a snapshot, it is set
+ * @lsn is the LSN of the WAL row that created the LSM tree.
+ * If the LSM tree is recovered from a snapshot, it is set
  * to the snapshot signature.
  */
 int
-vy_index_recover(struct vy_index *index, struct vy_recovery *recovery,
+vy_lsm_recover(struct vy_lsm *lsm, struct vy_recovery *recovery,
 		 struct vy_run_env *run_env, int64_t lsn,
 		 bool is_checkpoint_recovery, bool force_recovery);
 
 /**
- * Return generation of in-memory data stored in an index
+ * Return generation of in-memory data stored in an LSM tree
  * (min over vy_mem->generation).
  */
 int64_t
-vy_index_generation(struct vy_index *index);
+vy_lsm_generation(struct vy_lsm *lsm);
 
-/** Return max compact_priority among ranges of an index. */
+/** Return max compact_priority among ranges of an LSM tree. */
 int
-vy_index_compact_priority(struct vy_index *index);
+vy_lsm_compact_priority(struct vy_lsm *lsm);
 
-/** Add a run to the list of runs of an index. */
+/** Add a run to the list of runs of an LSM tree. */
 void
-vy_index_add_run(struct vy_index *index, struct vy_run *run);
+vy_lsm_add_run(struct vy_lsm *lsm, struct vy_run *run);
 
-/** Remove a run from the list of runs of an index. */
+/** Remove a run from the list of runs of an LSM tree. */
 void
-vy_index_remove_run(struct vy_index *index, struct vy_run *run);
+vy_lsm_remove_run(struct vy_lsm *lsm, struct vy_run *run);
 
 /**
  * Add a range to both the range tree and the range heap
- * of an index.
+ * of an LSM tree.
  */
 void
-vy_index_add_range(struct vy_index *index, struct vy_range *range);
+vy_lsm_add_range(struct vy_lsm *lsm, struct vy_range *range);
 
 /**
  * Remove a range from both the range tree and the range
- * heap of an index.
+ * heap of an LSM tree.
  */
 void
-vy_index_remove_range(struct vy_index *index, struct vy_range *range);
+vy_lsm_remove_range(struct vy_lsm *lsm, struct vy_range *range);
 
-/** Account a range to the run histogram of an index. */
+/** Account a range to the run histogram of an LSM tree. */
 void
-vy_index_acct_range(struct vy_index *index, struct vy_range *range);
+vy_lsm_acct_range(struct vy_lsm *lsm, struct vy_range *range);
 
-/** Unaccount a range from the run histogram of an index. */
+/** Unaccount a range from the run histogram of an LSM tree. */
 void
-vy_index_unacct_range(struct vy_index *index, struct vy_range *range);
+vy_lsm_unacct_range(struct vy_lsm *lsm, struct vy_range *range);
 
 /**
- * Allocate a new active in-memory index for an index while moving
- * the old one to the sealed list. Used by the dump task in order
- * not to bother about synchronization with concurrent insertions
- * while an index is being dumped.
+ * Allocate a new active in-memory index for an LSM tree while
+ * moving the old one to the sealed list. Used by the dump task
+ * in order not to bother about synchronization with concurrent
+ * insertions while an LSM tree is being dumped.
  */
 int
-vy_index_rotate_mem(struct vy_index *index);
+vy_lsm_rotate_mem(struct vy_lsm *lsm);
 
 /**
- * Remove an in-memory tree from the sealed list of a vinyl index,
+ * Remove an in-memory tree from the sealed list of an LSM tree,
  * unaccount and delete it.
  */
 void
-vy_index_delete_mem(struct vy_index *index, struct vy_mem *mem);
+vy_lsm_delete_mem(struct vy_lsm *lsm, struct vy_mem *mem);
 
 /**
  * Split a range if it has grown too big, return true if the range
@@ -436,7 +441,7 @@ vy_index_delete_mem(struct vy_index *index, struct vy_mem *mem);
  * operations, like writing a run file, and is done immediately.
  */
 bool
-vy_index_split_range(struct vy_index *index, struct vy_range *range);
+vy_lsm_split_range(struct vy_lsm *lsm, struct vy_range *range);
 
 /**
  * Coalesce a range with one or more its neighbors if it is too small,
@@ -449,16 +454,16 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range);
  * case of merging key ranges.
  */
 bool
-vy_index_coalesce_range(struct vy_index *index, struct vy_range *range);
+vy_lsm_coalesce_range(struct vy_lsm *lsm, struct vy_range *range);
 
 /**
- * Insert a statement into the index's in-memory tree. If the
- * region_stmt is NULL and the statement is successfully inserted
+ * Insert a statement into the in-memory index of an LSM tree. If
+ * the region_stmt is NULL and the statement is successfully inserted
  * then the new lsregion statement is returned via @a region_stmt.
- * Either vy_index_commit_stmt() or vy_index_rollback_stmt() must
+ * Either vy_lsm_commit_stmt() or vy_lsm_rollback_stmt() must
  * be called on success.
  *
- * @param index       Index the statement is for.
+ * @param lsm         LSM tree the statement is for.
  * @param mem         In-memory tree to insert the statement into.
  * @param stmt        Statement, allocated on malloc().
  * @param region_stmt NULL or the same statement, allocated on
@@ -468,33 +473,34 @@ vy_index_coalesce_range(struct vy_index *index, struct vy_range *range);
  * @retval -1 Memory error.
  */
 int
-vy_index_set(struct vy_index *index, struct vy_mem *mem,
-	     const struct tuple *stmt, const struct tuple **region_stmt);
+vy_lsm_set(struct vy_lsm *lsm, struct vy_mem *mem,
+	   const struct tuple *stmt, const struct tuple **region_stmt);
 
 /**
- * Confirm that the statement stays in the index's in-memory tree.
+ * Confirm that the statement stays in the in-memory index of
+ * an LSM tree.
  *
- * @param index Index the statement is for.
+ * @param lsm   LSM tree the statement is for.
  * @param mem   In-memory tree where the statement was saved.
  * @param stmt  Statement allocated from lsregion.
  */
 void
-vy_index_commit_stmt(struct vy_index *index, struct vy_mem *mem,
-		     const struct tuple *stmt);
+vy_lsm_commit_stmt(struct vy_lsm *lsm, struct vy_mem *mem,
+		   const struct tuple *stmt);
 
 /**
- * Erase a statement from the index's in-memory tree.
+ * Erase a statement from the in-memory index of an LSM tree.
  *
- * @param index Index to erase from.
+ * @param lsm   LSM tree to erase from.
  * @param mem   In-memory tree where the statement was saved.
  * @param stmt  Statement allocated from lsregion.
  */
 void
-vy_index_rollback_stmt(struct vy_index *index, struct vy_mem *mem,
-		       const struct tuple *stmt);
+vy_lsm_rollback_stmt(struct vy_lsm *lsm, struct vy_mem *mem,
+		     const struct tuple *stmt);
 
 #if defined(__cplusplus)
 } /* extern "C" */
 #endif /* defined(__cplusplus) */
 
-#endif /* INCLUDES_TARANTOOL_BOX_VY_INDEX_H */
+#endif /* INCLUDES_TARANTOOL_BOX_VY_LSM_H */
diff --git a/src/box/vy_mem.c b/src/box/vy_mem.c
index 629634bb..1105340c 100644
--- a/src/box/vy_mem.c
+++ b/src/box/vy_mem.c
@@ -212,7 +212,7 @@ vy_mem_insert_upsert(struct vy_mem *mem, const struct tuple *stmt)
 	 * UPSERT, n = threshold + 1,
 	 * UPSERT, n = threshold + 1, all following ones have
 	 *         ...                threshold + 1.
-	 * These values are used by vy_index_commit to squash
+	 * These values are used by vy_lsm_commit_upsert to squash
 	 * UPSERTs subsequence.
 	 */
 	vy_mem_tree_iterator_next(&mem->tree, &inserted);
diff --git a/src/box/vy_point_lookup.c b/src/box/vy_point_lookup.c
index d92cb94f..c5aa9719 100644
--- a/src/box/vy_point_lookup.c
+++ b/src/box/vy_point_lookup.c
@@ -39,7 +39,7 @@
 
 #include "fiber.h"
 
-#include "vy_index.h"
+#include "vy_lsm.h"
 #include "vy_stmt.h"
 #include "vy_tx.h"
 #include "vy_mem.h"
@@ -123,18 +123,18 @@ vy_stmt_history_is_terminal(struct rlist *history)
  * Add one or no statement to the history list.
  */
 static int
-vy_point_lookup_scan_txw(struct vy_index *index, struct vy_tx *tx,
+vy_point_lookup_scan_txw(struct vy_lsm *lsm, struct vy_tx *tx,
 			 struct tuple *key, struct rlist *history)
 {
 	if (tx == NULL)
 		return 0;
-	index->stat.txw.iterator.lookup++;
+	lsm->stat.txw.iterator.lookup++;
 	struct txv *txv =
-		write_set_search_key(&tx->write_set, index, key);
-	assert(txv == NULL || txv->index == index);
+		write_set_search_key(&tx->write_set, lsm, key);
+	assert(txv == NULL || txv->lsm == lsm);
 	if (txv == NULL)
 		return 0;
-	vy_stmt_counter_acct_tuple(&index->stat.txw.iterator.get,
+	vy_stmt_counter_acct_tuple(&lsm->stat.txw.iterator.get,
 				   txv->stmt);
 	struct vy_stmt_history_node *node = vy_stmt_history_node_new();
 	if (node == NULL)
@@ -146,21 +146,21 @@ vy_point_lookup_scan_txw(struct vy_index *index, struct vy_tx *tx,
 }
 
 /**
- * Scan index cache for given key.
+ * Scan LSM tree cache for given key.
  * Add one or no statement to the history list.
  */
 static int
-vy_point_lookup_scan_cache(struct vy_index *index,
+vy_point_lookup_scan_cache(struct vy_lsm *lsm,
 			   const struct vy_read_view **rv,
 			   struct tuple *key, struct rlist *history)
 {
-	index->cache.stat.lookup++;
-	struct tuple *stmt = vy_cache_get(&index->cache, key);
+	lsm->cache.stat.lookup++;
+	struct tuple *stmt = vy_cache_get(&lsm->cache, key);
 
 	if (stmt == NULL || vy_stmt_lsn(stmt) > (*rv)->vlsn)
 		return 0;
 
-	vy_stmt_counter_acct_tuple(&index->cache.stat.get, stmt);
+	vy_stmt_counter_acct_tuple(&lsm->cache.stat.get, stmt);
 	struct vy_stmt_history_node *node = vy_stmt_history_node_new();
 	if (node == NULL)
 		return -1;
@@ -176,7 +176,7 @@ vy_point_lookup_scan_cache(struct vy_index *index,
  * Add found statements to the history list up to terminal statement.
  */
 static int
-vy_point_lookup_scan_mem(struct vy_index *index, struct vy_mem *mem,
+vy_point_lookup_scan_mem(struct vy_lsm *lsm, struct vy_mem *mem,
 			 const struct vy_read_view **rv,
 			 struct tuple *key, struct rlist *history)
 {
@@ -186,7 +186,7 @@ vy_point_lookup_scan_mem(struct vy_index *index, struct vy_mem *mem,
 	bool exact;
 	struct vy_mem_tree_iterator mem_itr =
 		vy_mem_tree_lower_bound(&mem->tree, &tree_key, &exact);
-	index->stat.memory.iterator.lookup++;
+	lsm->stat.memory.iterator.lookup++;
 	const struct tuple *stmt = NULL;
 	if (!vy_mem_tree_iterator_is_invalid(&mem_itr)) {
 		stmt = *vy_mem_tree_iterator_get_elem(&mem->tree, &mem_itr);
@@ -202,7 +202,7 @@ vy_point_lookup_scan_mem(struct vy_index *index, struct vy_mem *mem,
 		if (node == NULL)
 			return -1;
 
-		vy_stmt_counter_acct_tuple(&index->stat.memory.iterator.get,
+		vy_stmt_counter_acct_tuple(&lsm->stat.memory.iterator.get,
 					   stmt);
 
 		node->src_type = ITER_SRC_MEM;
@@ -226,22 +226,21 @@ vy_point_lookup_scan_mem(struct vy_index *index, struct vy_mem *mem,
 }
 
 /**
- * Scan all mems that belongs to the index.
+ * Scan all mems that belongs to the LSM tree.
  * Add found statements to the history list up to terminal statement.
  */
 static int
-vy_point_lookup_scan_mems(struct vy_index *index,
-			  const struct vy_read_view **rv,
+vy_point_lookup_scan_mems(struct vy_lsm *lsm, const struct vy_read_view **rv,
 			  struct tuple *key, struct rlist *history)
 {
-	assert(index->mem != NULL);
-	int rc = vy_point_lookup_scan_mem(index, index->mem, rv, key, history);
+	assert(lsm->mem != NULL);
+	int rc = vy_point_lookup_scan_mem(lsm, lsm->mem, rv, key, history);
 	struct vy_mem *mem;
-	rlist_foreach_entry(mem, &index->sealed, in_sealed) {
+	rlist_foreach_entry(mem, &lsm->sealed, in_sealed) {
 		if (rc != 0 || vy_stmt_history_is_terminal(history))
 			return rc;
 
-		rc = vy_point_lookup_scan_mem(index, mem, rv, key, history);
+		rc = vy_point_lookup_scan_mem(lsm, mem, rv, key, history);
 	}
 	return 0;
 }
@@ -253,7 +252,7 @@ vy_point_lookup_scan_mems(struct vy_index *index,
  * was found.
  */
 static int
-vy_point_lookup_scan_slice(struct vy_index *index, struct vy_slice *slice,
+vy_point_lookup_scan_slice(struct vy_lsm *lsm, struct vy_slice *slice,
 			   const struct vy_read_view **rv, struct tuple *key,
 			   struct rlist *history, bool *terminal_found)
 {
@@ -264,10 +263,10 @@ vy_point_lookup_scan_slice(struct vy_index *index, struct vy_slice *slice,
 	 * format in vy_mem.
 	 */
 	struct vy_run_iterator run_itr;
-	vy_run_iterator_open(&run_itr, &index->stat.disk.iterator, slice,
-			     ITER_EQ, key, rv, index->cmp_def, index->key_def,
-			     index->disk_format, index->upsert_format,
-			     index->index_id == 0);
+	vy_run_iterator_open(&run_itr, &lsm->stat.disk.iterator, slice,
+			     ITER_EQ, key, rv, lsm->cmp_def, lsm->key_def,
+			     lsm->disk_format, lsm->upsert_format,
+			     lsm->index_id == 0);
 	struct tuple *stmt;
 	rc = vy_run_iterator_next_key(&run_itr, &stmt);
 	while (rc == 0 && stmt != NULL) {
@@ -297,11 +296,10 @@ vy_point_lookup_scan_slice(struct vy_index *index, struct vy_slice *slice,
  * that complete history from runs will be extracted.
  */
 static int
-vy_point_lookup_scan_slices(struct vy_index *index,
-			    const struct vy_read_view **rv,
+vy_point_lookup_scan_slices(struct vy_lsm *lsm, const struct vy_read_view **rv,
 			    struct tuple *key, struct rlist *history)
 {
-	struct vy_range *range = vy_range_tree_find_by_key(index->tree,
+	struct vy_range *range = vy_range_tree_find_by_key(lsm->tree,
 							   ITER_EQ, key);
 	assert(range != NULL);
 	int slice_count = range->slice_count;
@@ -323,7 +321,7 @@ vy_point_lookup_scan_slices(struct vy_index *index,
 	bool terminal_found = false;
 	for (i = 0; i < slice_count; i++) {
 		if (rc == 0 && !terminal_found)
-			rc = vy_point_lookup_scan_slice(index, slices[i],
+			rc = vy_point_lookup_scan_slice(lsm, slices[i],
 					rv, key, history, &terminal_found);
 		vy_slice_unpin(slices[i]);
 	}
@@ -334,7 +332,7 @@ vy_point_lookup_scan_slices(struct vy_index *index,
  * Get a resultant statement from collected history. Add to cache if possible.
  */
 static int
-vy_point_lookup_apply_history(struct vy_index *index,
+vy_point_lookup_apply_history(struct vy_lsm *lsm,
 			      const struct vy_read_view **rv,
 			      struct tuple *key, struct rlist *history,
 			      struct tuple **ret)
@@ -365,9 +363,9 @@ vy_point_lookup_apply_history(struct vy_index *index,
 		       vy_stmt_lsn(node->stmt) <= (*rv)->vlsn);
 
 		struct tuple *stmt = vy_apply_upsert(node->stmt, curr_stmt,
-					index->cmp_def, index->mem_format,
-					index->upsert_format, true);
-		index->stat.upsert.applied++;
+					lsm->cmp_def, lsm->mem_format,
+					lsm->upsert_format, true);
+		lsm->stat.upsert.applied++;
 		if (stmt == NULL)
 			return -1;
 		if (curr_stmt != NULL)
@@ -376,62 +374,62 @@ vy_point_lookup_apply_history(struct vy_index *index,
 		node = rlist_prev_entry_safe(node, history, link);
 	}
 	if (curr_stmt != NULL) {
-		vy_stmt_counter_acct_tuple(&index->stat.get, curr_stmt);
+		vy_stmt_counter_acct_tuple(&lsm->stat.get, curr_stmt);
 		*ret = curr_stmt;
 	}
 	/**
 	 * Add a statement to the cache
 	 */
 	if ((*rv)->vlsn == INT64_MAX) /* Do not store non-latest data */
-		vy_cache_add(&index->cache, curr_stmt, NULL, key, ITER_EQ);
+		vy_cache_add(&lsm->cache, curr_stmt, NULL, key, ITER_EQ);
 	return 0;
 }
 
 int
-vy_point_lookup(struct vy_index *index, struct vy_tx *tx,
+vy_point_lookup(struct vy_lsm *lsm, struct vy_tx *tx,
 		const struct vy_read_view **rv,
 		struct tuple *key, struct tuple **ret)
 {
-	assert(tuple_field_count(key) >= index->cmp_def->part_count);
+	assert(tuple_field_count(key) >= lsm->cmp_def->part_count);
 
 	*ret = NULL;
 	size_t region_svp = region_used(&fiber()->gc);
 	double start_time = ev_monotonic_now(loop());
 	int rc = 0;
 
-	index->stat.lookup++;
+	lsm->stat.lookup++;
 	/* History list */
 	struct rlist history;
 restart:
 	rlist_create(&history);
 
-	rc = vy_point_lookup_scan_txw(index, tx, key, &history);
+	rc = vy_point_lookup_scan_txw(lsm, tx, key, &history);
 	if (rc != 0 || vy_stmt_history_is_terminal(&history))
 		goto done;
 
-	rc = vy_point_lookup_scan_cache(index, rv, key, &history);
+	rc = vy_point_lookup_scan_cache(lsm, rv, key, &history);
 	if (rc != 0 || vy_stmt_history_is_terminal(&history))
 		goto done;
 
-	rc = vy_point_lookup_scan_mems(index, rv, key, &history);
+	rc = vy_point_lookup_scan_mems(lsm, rv, key, &history);
 	if (rc != 0 || vy_stmt_history_is_terminal(&history))
 		goto done;
 
 	/* Save version before yield */
-	uint32_t mem_list_version = index->mem_list_version;
+	uint32_t mem_list_version = lsm->mem_list_version;
 
-	rc = vy_point_lookup_scan_slices(index, rv, key, &history);
+	rc = vy_point_lookup_scan_slices(lsm, rv, key, &history);
 	if (rc != 0)
 		goto done;
 
 	ERROR_INJECT(ERRINJ_VY_POINT_ITER_WAIT, {
-		while (mem_list_version == index->mem_list_version)
+		while (mem_list_version == lsm->mem_list_version)
 			fiber_sleep(0.01);
 		/* Turn of the injection to avoid infinite loop */
 		errinj(ERRINJ_VY_POINT_ITER_WAIT, ERRINJ_BOOL)->bparam = false;
 	});
 
-	if (mem_list_version != index->mem_list_version) {
+	if (mem_list_version != lsm->mem_list_version) {
 		/*
 		 * Mem list was changed during yield. This could be rotation
 		 * or a dump. In case of dump the memory referenced by
@@ -445,7 +443,7 @@ restart:
 
 done:
 	if (rc == 0) {
-		rc = vy_point_lookup_apply_history(index, rv, key,
+		rc = vy_point_lookup_apply_history(lsm, rv, key,
 						   &history, ret);
 	}
 	vy_stmt_history_cleanup(&history, region_svp);
@@ -454,11 +452,11 @@ done:
 		return -1;
 
 	double latency = ev_monotonic_now(loop()) - start_time;
-	latency_collect(&index->stat.latency, latency);
+	latency_collect(&lsm->stat.latency, latency);
 
-	if (latency > index->env->too_long_threshold) {
+	if (latency > lsm->env->too_long_threshold) {
 		say_warn("%s: get(%s) => %s took too long: %.3f sec",
-			 vy_index_name(index), tuple_str(key),
+			 vy_lsm_name(lsm), tuple_str(key),
 			 vy_stmt_str(*ret), latency);
 	}
 	return 0;
diff --git a/src/box/vy_point_lookup.h b/src/box/vy_point_lookup.h
index a4dbe77e..d74be9a9 100644
--- a/src/box/vy_point_lookup.h
+++ b/src/box/vy_point_lookup.h
@@ -33,7 +33,7 @@
 
 /**
  * Point lookup is a special case of read iterator that is designed for
- * retrieving one value from index by a full key (all parts are present).
+ * retrieving one value from an LSM tree by a full key (all parts are present).
  *
  * Iterator collects necessary history of the given key from different sources
  * (txw, cache, mems, runs) that consists of some number of sequential upserts
@@ -51,7 +51,7 @@
 extern "C" {
 #endif /* defined(__cplusplus) */
 
-struct vy_index;
+struct vy_lsm;
 struct vy_tx;
 struct vy_read_view;
 struct tuple;
@@ -59,7 +59,7 @@ struct tuple;
 /**
  * Given a key that has all index parts (including primary index
  * parts in case of a secondary index), lookup the corresponding
- * tuple in the index. The tuple is returned in @ret with its
+ * tuple in the LSM tree. The tuple is returned in @ret with its
  * reference counter elevated.
  *
  * The caller must guarantee that if the tuple looked up by this
@@ -70,7 +70,7 @@ struct tuple;
  * the tuple is already tracked in a secondary index.
  */
 int
-vy_point_lookup(struct vy_index *index, struct vy_tx *tx,
+vy_point_lookup(struct vy_lsm *lsm, struct vy_tx *tx,
 		const struct vy_read_view **rv,
 		struct tuple *key, struct tuple **ret);
 
diff --git a/src/box/vy_range.h b/src/box/vy_range.h
index c6d3a0ad..3a451fb4 100644
--- a/src/box/vy_range.h
+++ b/src/box/vy_range.h
@@ -54,7 +54,7 @@ struct tuple;
 struct vy_slice;
 
 /**
- * Range of keys in an index stored on disk.
+ * Range of keys in an LSM tree stored on disk.
  */
 struct vy_range {
 	/** Unique ID of this range. */
@@ -108,20 +108,19 @@ struct vy_range {
 	int compact_priority;
 	/** Number of times the range was compacted. */
 	int n_compactions;
-	/** Link in vy_index->tree. */
+	/** Link in vy_lsm->tree. */
 	rb_node(struct vy_range) tree_node;
-	/** Link in vy_index->range_heap. */
+	/** Link in vy_lsm->range_heap. */
 	struct heap_node heap_node;
 	/**
-	 * Incremented whenever an in-memory index or on disk
-	 * run is added to or deleted from this range. Used to
-	 * invalidate iterators.
+	 * Incremented whenever a run is added to or deleted
+	 * from this range. Used invalidate read iterators.
 	 */
 	uint32_t version;
 };
 
 /**
- * Heap of all ranges of the same index, prioritized by
+ * Heap of all ranges of the same LSM tree, prioritized by
  * vy_range->compact_priority.
  */
 #define HEAP_NAME vy_range_heap
@@ -145,7 +144,7 @@ vy_range_is_scheduled(struct vy_range *range)
 }
 
 /**
- * Search tree of all ranges of the same index, sorted by
+ * Search tree of all ranges of the same LSM tree, sorted by
  * vy_range->begin. Ranges in a tree are supposed to span
  * all possible keys without overlaps.
  */
diff --git a/src/box/vy_read_iterator.c b/src/box/vy_read_iterator.c
index 3b5e34fc..37493e19 100644
--- a/src/box/vy_read_iterator.c
+++ b/src/box/vy_read_iterator.c
@@ -35,7 +35,7 @@
 #include "vy_tx.h"
 #include "fiber.h"
 #include "vy_upsert.h"
-#include "vy_index.h"
+#include "vy_lsm.h"
 #include "vy_stat.h"
 
 /**
@@ -141,7 +141,7 @@ vy_read_iterator_range_is_done(struct vy_read_iterator *itr)
 {
 	struct tuple *stmt = itr->curr_stmt;
 	struct vy_range *range = itr->curr_range;
-	struct key_def *cmp_def = itr->index->cmp_def;
+	struct key_def *cmp_def = itr->lsm->cmp_def;
 	int dir = iterator_direction(itr->iterator_type);
 
 	if (dir > 0 && range->end != NULL &&
@@ -182,7 +182,7 @@ vy_read_iterator_cmp_stmt(struct vy_read_iterator *itr,
 	if (a == NULL && b == NULL)
 		return 0;
 	return iterator_direction(itr->iterator_type) *
-		vy_tuple_compare(a, b, itr->index->cmp_def);
+		vy_tuple_compare(a, b, itr->lsm->cmp_def);
 }
 
 /**
@@ -195,7 +195,7 @@ vy_read_iterator_is_exact_match(struct vy_read_iterator *itr,
 {
 	struct tuple *key = itr->key;
 	enum iterator_type type = itr->iterator_type;
-	struct key_def *cmp_def = itr->index->cmp_def;
+	struct key_def *cmp_def = itr->lsm->cmp_def;
 
 	/*
 	 * If the index is unique and the search key is full,
@@ -442,7 +442,7 @@ vy_read_iterator_next_key(struct vy_read_iterator *itr, struct tuple **ret)
 
 	if (itr->last_stmt != NULL && (itr->iterator_type == ITER_EQ ||
 				       itr->iterator_type == ITER_REQ) &&
-	    tuple_field_count(itr->key) >= itr->index->cmp_def->part_count) {
+	    tuple_field_count(itr->key) >= itr->lsm->cmp_def->part_count) {
 		/*
 		 * There may be one statement at max satisfying
 		 * EQ with a full key.
@@ -451,11 +451,11 @@ vy_read_iterator_next_key(struct vy_read_iterator *itr, struct tuple **ret)
 		return 0;
 	}
 	/*
-	 * Restore the iterator position if the index has changed
+	 * Restore the iterator position if the LSM tree has changed
 	 * since the last iteration.
 	 */
-	if (itr->mem_list_version != itr->index->mem_list_version ||
-	    itr->range_tree_version != itr->index->range_tree_version ||
+	if (itr->mem_list_version != itr->lsm->mem_list_version ||
+	    itr->range_tree_version != itr->lsm->range_tree_version ||
 	    itr->range_version != itr->curr_range->version) {
 		vy_read_iterator_restore(itr);
 	}
@@ -501,8 +501,8 @@ rescan_disk:
 	 * because all slices were pinned and hence could not be
 	 * removed.
 	 */
-	if (itr->mem_list_version != itr->index->mem_list_version ||
-	    itr->range_tree_version != itr->index->range_tree_version) {
+	if (itr->mem_list_version != itr->lsm->mem_list_version ||
+	    itr->range_tree_version != itr->lsm->range_tree_version) {
 		vy_read_iterator_restore(itr);
 		goto restart;
 	}
@@ -528,7 +528,7 @@ done:
 
 	if (itr->need_check_eq && itr->curr_stmt != NULL &&
 	    vy_stmt_compare(itr->curr_stmt, itr->key,
-			    itr->index->cmp_def) != 0)
+			    itr->lsm->cmp_def) != 0)
 		itr->curr_stmt = NULL;
 
 	if (vy_read_iterator_track_read(itr, itr->curr_stmt) != 0)
@@ -592,7 +592,7 @@ vy_read_iterator_next_lsn(struct vy_read_iterator *itr, struct tuple **ret)
 	/*
 	 * Look up the older statement in on-disk runs.
 	 *
-	 * Note, we don't need to check the index version after the yield
+	 * Note, we don't need to check the LSM tree version after the yield
 	 * caused by the disk read, because once we've come to this point,
 	 * we won't read any source except run slices, which are pinned
 	 * and hence cannot be removed during the yield.
@@ -645,11 +645,11 @@ vy_read_iterator_squash_upsert(struct vy_read_iterator *itr,
 			       struct tuple **ret)
 {
 	*ret = NULL;
-	struct vy_index *index = itr->index;
+	struct vy_lsm *lsm = itr->lsm;
 	struct tuple *t = itr->curr_stmt;
 
-	/* Upserts enabled only in the primary index. */
-	assert(vy_stmt_type(t) != IPROTO_UPSERT || index->index_id == 0);
+	/* Upserts enabled only in the primary index LSM tree. */
+	assert(vy_stmt_type(t) != IPROTO_UPSERT || lsm->index_id == 0);
 	tuple_ref(t);
 	while (vy_stmt_type(t) == IPROTO_UPSERT) {
 		struct tuple *next;
@@ -659,9 +659,9 @@ vy_read_iterator_squash_upsert(struct vy_read_iterator *itr,
 			return rc;
 		}
 		struct tuple *applied = vy_apply_upsert(t, next,
-				index->cmp_def, index->mem_format,
-				index->upsert_format, true);
-		index->stat.upsert.applied++;
+				lsm->cmp_def, lsm->mem_format,
+				lsm->upsert_format, true);
+		lsm->stat.upsert.applied++;
 		tuple_unref(t);
 		if (applied == NULL)
 			return -1;
@@ -679,9 +679,9 @@ vy_read_iterator_add_tx(struct vy_read_iterator *itr)
 	assert(itr->tx != NULL);
 	enum iterator_type iterator_type = (itr->iterator_type != ITER_REQ ?
 					    itr->iterator_type : ITER_LE);
-	struct vy_txw_iterator_stat *stat = &itr->index->stat.txw.iterator;
+	struct vy_txw_iterator_stat *stat = &itr->lsm->stat.txw.iterator;
 	struct vy_read_src *sub_src = vy_read_iterator_add_src(itr);
-	vy_txw_iterator_open(&sub_src->txw_iterator, stat, itr->tx, itr->index,
+	vy_txw_iterator_open(&sub_src->txw_iterator, stat, itr->tx, itr->lsm,
 			     iterator_type, itr->key);
 }
 
@@ -692,7 +692,7 @@ vy_read_iterator_add_cache(struct vy_read_iterator *itr)
 					    itr->iterator_type : ITER_LE);
 	struct vy_read_src *sub_src = vy_read_iterator_add_src(itr);
 	vy_cache_iterator_open(&sub_src->cache_iterator,
-			       &itr->index->cache, iterator_type,
+			       &itr->lsm->cache, iterator_type,
 			       itr->key, itr->read_view);
 }
 
@@ -701,22 +701,20 @@ vy_read_iterator_add_mem(struct vy_read_iterator *itr)
 {
 	enum iterator_type iterator_type = (itr->iterator_type != ITER_REQ ?
 					    itr->iterator_type : ITER_LE);
-	struct vy_index *index = itr->index;
+	struct vy_lsm *lsm = itr->lsm;
 	struct vy_read_src *sub_src;
 
 	/* Add the active in-memory index. */
-	assert(index->mem != NULL);
+	assert(lsm->mem != NULL);
 	sub_src = vy_read_iterator_add_src(itr);
-	vy_mem_iterator_open(&sub_src->mem_iterator,
-			     &index->stat.memory.iterator,
-			     index->mem, iterator_type, itr->key,
-			     itr->read_view);
+	vy_mem_iterator_open(&sub_src->mem_iterator, &lsm->stat.memory.iterator,
+			     lsm->mem, iterator_type, itr->key, itr->read_view);
 	/* Add sealed in-memory indexes. */
 	struct vy_mem *mem;
-	rlist_foreach_entry(mem, &index->sealed, in_sealed) {
+	rlist_foreach_entry(mem, &lsm->sealed, in_sealed) {
 		sub_src = vy_read_iterator_add_src(itr);
 		vy_mem_iterator_open(&sub_src->mem_iterator,
-				     &index->stat.memory.iterator,
+				     &lsm->stat.memory.iterator,
 				     mem, iterator_type, itr->key,
 				     itr->read_view);
 	}
@@ -728,7 +726,7 @@ vy_read_iterator_add_disk(struct vy_read_iterator *itr)
 	assert(itr->curr_range != NULL);
 	enum iterator_type iterator_type = (itr->iterator_type != ITER_REQ ?
 					    itr->iterator_type : ITER_LE);
-	struct vy_index *index = itr->index;
+	struct vy_lsm *lsm = itr->lsm;
 	struct vy_slice *slice;
 	/*
 	 * The format of the statement must be exactly the space
@@ -742,21 +740,20 @@ vy_read_iterator_add_disk(struct vy_read_iterator *itr)
 		 * dumped in-memory trees. We must not add both
 		 * the slice and the trees in this case, because
 		 * the read iterator can't deal with duplicates.
-		 * Since index->dump_lsn is bumped after deletion
+		 * Since lsm->dump_lsn is bumped after deletion
 		 * of dumped in-memory trees, we can filter out
 		 * the run slice containing duplicates by LSN.
 		 */
-		if (slice->run->info.min_lsn > index->dump_lsn)
+		if (slice->run->info.min_lsn > lsm->dump_lsn)
 			continue;
-		assert(slice->run->info.max_lsn <= index->dump_lsn);
+		assert(slice->run->info.max_lsn <= lsm->dump_lsn);
 		struct vy_read_src *sub_src = vy_read_iterator_add_src(itr);
 		vy_run_iterator_open(&sub_src->run_iterator,
-				     &index->stat.disk.iterator, slice,
+				     &lsm->stat.disk.iterator, slice,
 				     iterator_type, itr->key,
-				     itr->read_view, index->cmp_def,
-				     index->key_def, index->disk_format,
-				     index->upsert_format,
-				     index->index_id == 0);
+				     itr->read_view, lsm->cmp_def,
+				     lsm->key_def, lsm->disk_format,
+				     lsm->upsert_format, lsm->index_id == 0);
 	}
 }
 
@@ -799,13 +796,13 @@ vy_read_iterator_cleanup(struct vy_read_iterator *itr)
 }
 
 void
-vy_read_iterator_open(struct vy_read_iterator *itr, struct vy_index *index,
+vy_read_iterator_open(struct vy_read_iterator *itr, struct vy_lsm *lsm,
 		      struct vy_tx *tx, enum iterator_type iterator_type,
 		      struct tuple *key, const struct vy_read_view **rv)
 {
 	memset(itr, 0, sizeof(*itr));
 
-	itr->index = index;
+	itr->lsm = lsm;
 	itr->tx = tx;
 	itr->iterator_type = iterator_type;
 	itr->key = key;
@@ -851,9 +848,9 @@ vy_read_iterator_restore(struct vy_read_iterator *itr)
 {
 	vy_read_iterator_cleanup(itr);
 
-	itr->mem_list_version = itr->index->mem_list_version;
-	itr->range_tree_version = itr->index->range_tree_version;
-	itr->curr_range = vy_range_tree_find_by_key(itr->index->tree,
+	itr->mem_list_version = itr->lsm->mem_list_version;
+	itr->range_tree_version = itr->lsm->range_tree_version;
+	itr->curr_range = vy_range_tree_find_by_key(itr->lsm->tree,
 			itr->iterator_type, itr->last_stmt ?: itr->key);
 	itr->range_version = itr->curr_range->version;
 
@@ -879,13 +876,13 @@ static void
 vy_read_iterator_next_range(struct vy_read_iterator *itr)
 {
 	struct vy_range *range = itr->curr_range;
-	struct key_def *cmp_def = itr->index->cmp_def;
+	struct key_def *cmp_def = itr->lsm->cmp_def;
 	int dir = iterator_direction(itr->iterator_type);
 
 	assert(range != NULL);
 	while (true) {
-		range = dir > 0 ? vy_range_tree_next(itr->index->tree, range) :
-				  vy_range_tree_prev(itr->index->tree, range);
+		range = dir > 0 ? vy_range_tree_next(itr->lsm->tree, range) :
+				  vy_range_tree_prev(itr->lsm->tree, range);
 		assert(range != NULL);
 
 		if (itr->last_stmt == NULL)
@@ -927,16 +924,16 @@ vy_read_iterator_track_read(struct vy_read_iterator *itr, struct tuple *stmt)
 	if (stmt == NULL) {
 		stmt = (itr->iterator_type == ITER_EQ ||
 			itr->iterator_type == ITER_REQ ?
-			itr->key : itr->index->env->empty_key);
+			itr->key : itr->lsm->env->empty_key);
 	}
 
 	int rc;
 	if (iterator_direction(itr->iterator_type) >= 0) {
-		rc = vy_tx_track(itr->tx, itr->index, itr->key,
+		rc = vy_tx_track(itr->tx, itr->lsm, itr->key,
 				 itr->iterator_type != ITER_GT,
 				 stmt, true);
 	} else {
-		rc = vy_tx_track(itr->tx, itr->index, stmt, true,
+		rc = vy_tx_track(itr->tx, itr->lsm, stmt, true,
 				 itr->key, itr->iterator_type != ITER_LT);
 	}
 	return rc;
@@ -951,7 +948,7 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result)
 
 	if (!itr->search_started) {
 		itr->search_started = true;
-		itr->index->stat.lookup++;
+		itr->lsm->stat.lookup++;
 		vy_read_iterator_restore(itr);
 	}
 
@@ -961,7 +958,7 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result)
 	bool skipped_txw_delete = false;
 
 	struct tuple *t = NULL;
-	struct vy_index *index = itr->index;
+	struct vy_lsm *lsm = itr->lsm;
 	int rc = 0;
 	while (true) {
 		rc = vy_read_iterator_next_key(itr, &t);
@@ -993,7 +990,7 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result)
 	       vy_stmt_type(*result) == IPROTO_INSERT ||
 	       vy_stmt_type(*result) == IPROTO_REPLACE);
 	if (*result != NULL)
-		vy_stmt_counter_acct_tuple(&index->stat.get, *result);
+		vy_stmt_counter_acct_tuple(&lsm->stat.get, *result);
 
 #ifndef NDEBUG
 	/* Check constraints. */
@@ -1005,18 +1002,18 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result)
 	 */
 	if (itr->last_stmt != NULL && tuple_field_count(itr->key) > 0) {
 		int cmp = dir * vy_stmt_compare(*result, itr->key,
-						itr->index->cmp_def);
+						itr->lsm->cmp_def);
 		assert(cmp >= 0);
 	}
 	/*
 	 * Ensure the read iterator does not return duplicates
-	 * and respects statements order (index->cmp_def includes
+	 * and respects statements order (lsm->cmp_def includes
 	 * primary parts, so prev_key != itr->last_stmt for any
-	 * index).
+	 * LSM tree).
 	 */
 	if (prev_key != NULL && itr->last_stmt != NULL) {
 		assert(dir * vy_tuple_compare(prev_key, itr->last_stmt,
-					      index->cmp_def) < 0);
+					      lsm->cmp_def) < 0);
 	}
 #endif
 
@@ -1034,7 +1031,7 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result)
 			 */
 			cache_prev = NULL;
 		}
-		vy_cache_add(&itr->index->cache, *result, cache_prev,
+		vy_cache_add(&itr->lsm->cache, *result, cache_prev,
 			     itr->key, itr->iterator_type);
 	}
 clear:
@@ -1042,11 +1039,11 @@ clear:
 		tuple_unref(prev_key);
 
 	ev_tstamp latency = ev_monotonic_now(loop()) - start_time;
-	latency_collect(&index->stat.latency, latency);
+	latency_collect(&lsm->stat.latency, latency);
 
-	if (latency > index->env->too_long_threshold) {
+	if (latency > lsm->env->too_long_threshold) {
 		say_warn("%s: select(%s, %s) => %s took too long: %.3f sec",
-			 vy_index_name(index), tuple_str(itr->key),
+			 vy_lsm_name(lsm), tuple_str(itr->key),
 			 iterator_type_strs[itr->iterator_type],
 			 vy_stmt_str(itr->last_stmt), latency);
 	}
diff --git a/src/box/vy_read_iterator.h b/src/box/vy_read_iterator.h
index 5726b042..4f9d3d4b 100644
--- a/src/box/vy_read_iterator.h
+++ b/src/box/vy_read_iterator.h
@@ -44,11 +44,11 @@ extern "C" {
 /**
  * Vinyl read iterator.
  *
- * Used for executing a SELECT request over a Vinyl index.
+ * Used for executing a SELECT request over an LSM tree.
  */
 struct vy_read_iterator {
-	/** Index to iterate over. */
-	struct vy_index *index;
+	/** LSM tree to iterate over. */
+	struct vy_lsm *lsm;
 	/** Active transaction or NULL. */
 	struct vy_tx *tx;
 	/** Iterator type. */
@@ -67,12 +67,12 @@ struct vy_read_iterator {
 	/** Last statement returned by vy_read_iterator_next(). */
 	struct tuple *last_stmt;
 	/**
-	 * Copy of index->range_tree_version.
+	 * Copy of lsm->range_tree_version.
 	 * Used for detecting range tree changes.
 	 */
 	uint32_t range_tree_version;
 	/**
-	 * Copy of index->mem_list_version.
+	 * Copy of lsm->mem_list_version.
 	 * Used for detecting memory level changes.
 	 */
 	uint32_t mem_list_version;
@@ -94,7 +94,7 @@ struct vy_read_iterator {
 	uint32_t src_count;
 	/** Maximal capacity of the src array. */
 	uint32_t src_capacity;
-	/** Index of the current merge source. */
+	/** Offset of the current merge source. */
 	uint32_t curr_src;
 	/** Statement returned by the current merge source. */
 	struct tuple *curr_stmt;
@@ -122,7 +122,7 @@ struct vy_read_iterator {
 /**
  * Open the read iterator.
  * @param itr           Read iterator.
- * @param index         Vinyl index to iterate.
+ * @param lsm           LSM tree to iterate.
  * @param tx            Current transaction, if exists.
  * @param iterator_type Type of the iterator that determines order
  *                      of the iteration.
@@ -130,7 +130,7 @@ struct vy_read_iterator {
  * @param rv            Read view.
  */
 void
-vy_read_iterator_open(struct vy_read_iterator *itr, struct vy_index *index,
+vy_read_iterator_open(struct vy_read_iterator *itr, struct vy_lsm *lsm,
 		      struct vy_tx *tx, enum iterator_type iterator_type,
 		      struct tuple *key, const struct vy_read_view **rv);
 
diff --git a/src/box/vy_read_set.c b/src/box/vy_read_set.c
index bb54a4a6..0f3fab61 100644
--- a/src/box/vy_read_set.c
+++ b/src/box/vy_read_set.c
@@ -37,15 +37,15 @@
 
 #include "trivia/util.h"
 #include "tuple.h"
-#include "vy_index.h"
+#include "vy_lsm.h"
 #include "vy_stmt.h"
 
 int
 vy_read_interval_cmpl(const struct vy_read_interval *a,
 		      const struct vy_read_interval *b)
 {
-	assert(a->index == b->index);
-	struct key_def *cmp_def = a->index->cmp_def;
+	assert(a->lsm == b->lsm);
+	struct key_def *cmp_def = a->lsm->cmp_def;
 	int cmp = vy_stmt_compare(a->left, b->left, cmp_def);
 	if (cmp != 0)
 		return cmp;
@@ -67,8 +67,8 @@ int
 vy_read_interval_cmpr(const struct vy_read_interval *a,
 		      const struct vy_read_interval *b)
 {
-	assert(a->index == b->index);
-	struct key_def *cmp_def = a->index->cmp_def;
+	assert(a->lsm == b->lsm);
+	struct key_def *cmp_def = a->lsm->cmp_def;
 	int cmp = vy_stmt_compare(a->right, b->right, cmp_def);
 	if (cmp != 0)
 		return cmp;
@@ -90,9 +90,9 @@ bool
 vy_read_interval_should_merge(const struct vy_read_interval *l,
 			      const struct vy_read_interval *r)
 {
-	assert(l->index == r->index);
+	assert(l->lsm == r->lsm);
 	assert(vy_read_interval_cmpl(l, r) <= 0);
-	struct key_def *cmp_def = l->index->cmp_def;
+	struct key_def *cmp_def = l->lsm->cmp_def;
 	int cmp = vy_stmt_compare(l->right, r->left, cmp_def);
 	if (cmp > 0)
 		return true;
@@ -116,13 +116,13 @@ struct vy_tx *
 vy_tx_conflict_iterator_next(struct vy_tx_conflict_iterator *it)
 {
 	struct vy_read_interval *curr, *left, *right;
-	while ((curr = vy_index_read_set_walk_next(&it->tree_walk, it->tree_dir,
-						   &left, &right)) != NULL) {
-		struct key_def *cmp_def = curr->index->cmp_def;
+	while ((curr = vy_lsm_read_set_walk_next(&it->tree_walk, it->tree_dir,
+						 &left, &right)) != NULL) {
+		struct key_def *cmp_def = curr->lsm->cmp_def;
 		const struct vy_read_interval *last = curr->subtree_last;
 
-		assert(left == NULL || left->index == curr->index);
-		assert(right == NULL || right->index == curr->index);
+		assert(left == NULL || left->lsm == curr->lsm);
+		assert(right == NULL || right->lsm == curr->lsm);
 
 		int cmp_right = vy_stmt_compare(it->stmt, last->right, cmp_def);
 		if (cmp_right == 0 && !last->right_belongs)
diff --git a/src/box/vy_read_set.h b/src/box/vy_read_set.h
index 272da63a..1b139ccf 100644
--- a/src/box/vy_read_set.h
+++ b/src/box/vy_read_set.h
@@ -48,7 +48,7 @@ extern "C" {
 
 struct tuple;
 struct vy_tx;
-struct vy_index;
+struct vy_lsm;
 
 /**
  * A tuple interval read by a transaction.
@@ -56,8 +56,8 @@ struct vy_index;
 struct vy_read_interval {
 	/** Transaction. */
 	struct vy_tx *tx;
-	/** Index that the transaction read from. */
-	struct vy_index *index;
+	/** LSM tree that the transaction read from. */
+	struct vy_lsm *lsm;
 	/** Left boundary of the interval. */
 	struct tuple *left;
 	/** Right boundary of the interval. */
@@ -73,8 +73,8 @@ struct vy_read_interval {
 	const struct vy_read_interval *subtree_last;
 	/** Link in vy_tx->read_set. */
 	rb_node(struct vy_read_interval) in_tx;
-	/** Link in vy_index->read_set. */
-	rb_node(struct vy_read_interval) in_index;
+	/** Link in vy_lsm->read_set. */
+	rb_node(struct vy_read_interval) in_lsm;
 	/**
 	 * Auxiliary list node. Used by vy_tx_track() to
 	 * link intervals to be merged.
@@ -125,7 +125,7 @@ vy_read_interval_should_merge(const struct vy_read_interval *l,
 
 /**
  * Tree that contains tuple intervals read by a transactions.
- * Linked by vy_read_interval->in_tx. Sorted by vy_index, then
+ * Linked by vy_read_interval->in_tx. Sorted by vy_lsm, then
  * by vy_read_interval->left. Intervals stored in this tree
  * must not intersect.
  */
@@ -136,7 +136,7 @@ vy_tx_read_set_cmp(const struct vy_read_interval *a,
 		   const struct vy_read_interval *b)
 {
 	assert(a->tx == b->tx);
-	int rc = a->index < b->index ? -1 : a->index > b->index;
+	int rc = a->lsm < b->lsm ? -1 : a->lsm > b->lsm;
 	if (rc == 0)
 		rc = vy_read_interval_cmpl(a, b);
 	return rc;
@@ -146,18 +146,18 @@ rb_gen(MAYBE_UNUSED static inline, vy_tx_read_set_, vy_tx_read_set_t,
        struct vy_read_interval, in_tx, vy_tx_read_set_cmp);
 
 /**
- * Interval tree used for tracking reads done from an index by
- * all active transactions. Linked by vy_read_interval->in_index.
+ * Interval tree used for tracking reads done from an LSM tree by
+ * all active transactions. Linked by vy_read_interval->in_lsm.
  * Sorted by vy_read_interval->left, then by vy_tx. Intervals that
  * belong to different transactions may intersect.
  */
-typedef rb_tree(struct vy_read_interval) vy_index_read_set_t;
+typedef rb_tree(struct vy_read_interval) vy_lsm_read_set_t;
 
 static inline int
-vy_index_read_set_cmp(const struct vy_read_interval *a,
-		      const struct vy_read_interval *b)
+vy_lsm_read_set_cmp(const struct vy_read_interval *a,
+		    const struct vy_read_interval *b)
 {
-	assert(a->index == b->index);
+	assert(a->lsm == b->lsm);
 	int rc = vy_read_interval_cmpl(a, b);
 	if (rc == 0)
 		rc = a->tx < b->tx ? -1 : a->tx > b->tx;
@@ -165,9 +165,9 @@ vy_index_read_set_cmp(const struct vy_read_interval *a,
 }
 
 static inline void
-vy_index_read_set_aug(struct vy_read_interval *node,
-		      const struct vy_read_interval *left,
-		      const struct vy_read_interval *right)
+vy_lsm_read_set_aug(struct vy_read_interval *node,
+		    const struct vy_read_interval *left,
+		    const struct vy_read_interval *right)
 {
 	node->subtree_last = node;
 	if (left != NULL &&
@@ -178,9 +178,9 @@ vy_index_read_set_aug(struct vy_read_interval *node,
 		node->subtree_last = right->subtree_last;
 }
 
-rb_gen_aug(MAYBE_UNUSED static inline, vy_index_read_set_, vy_index_read_set_t,
-	   struct vy_read_interval, in_index, vy_index_read_set_cmp,
-	   vy_index_read_set_aug);
+rb_gen_aug(MAYBE_UNUSED static inline, vy_lsm_read_set_, vy_lsm_read_set_t,
+	   struct vy_read_interval, in_lsm, vy_lsm_read_set_cmp,
+	   vy_lsm_read_set_aug);
 
 /**
  * Iterator over transactions that conflict with a statement.
@@ -189,10 +189,10 @@ struct vy_tx_conflict_iterator {
 	/** The statement. */
 	const struct tuple *stmt;
 	/**
-	 * Iterator over the index interval tree checked
+	 * Iterator over the interval tree checked
 	 * for intersections with the statement.
 	 */
-	struct vy_index_read_set_walk tree_walk;
+	struct vy_lsm_read_set_walk tree_walk;
 	/**
 	 * Direction of tree traversal to be used on the
 	 * next iteration.
@@ -202,10 +202,10 @@ struct vy_tx_conflict_iterator {
 
 static inline void
 vy_tx_conflict_iterator_init(struct vy_tx_conflict_iterator *it,
-			     vy_index_read_set_t *read_set,
+			     vy_lsm_read_set_t *read_set,
 			     const struct tuple *stmt)
 {
-	vy_index_read_set_walk_init(&it->tree_walk, read_set);
+	vy_lsm_read_set_walk_init(&it->tree_walk, read_set);
 	it->tree_dir = 0;
 	it->stmt = stmt;
 }
diff --git a/src/box/vy_run.c b/src/box/vy_run.c
index f8d96f33..7f792c13 100644
--- a/src/box/vy_run.c
+++ b/src/box/vy_run.c
@@ -236,7 +236,7 @@ vy_run_new(struct vy_run_env *env, int64_t id)
 	run->dump_lsn = -1;
 	run->fd = -1;
 	run->refs = 1;
-	rlist_create(&run->in_index);
+	rlist_create(&run->in_lsm);
 	rlist_create(&run->in_unused);
 	TRASH(&run->info.bloom);
 	return run;
@@ -719,8 +719,7 @@ vy_page_xrow(struct vy_page *page, uint32_t stmt_no,
  * Read raw stmt data from the page
  * @param page          Page.
  * @param stmt_no       Statement position in the page.
- * @param cmp_def       Key definition of an index, including
- *                      primary key parts.
+ * @param cmp_def       Key definition, including primary key parts.
  * @param format        Format for REPLACE/DELETE tuples.
  * @param upsert_format Format for UPSERT tuples.
  * @param is_primary    True if the index is primary.
diff --git a/src/box/vy_run.h b/src/box/vy_run.h
index 6973ee2d..ecf55350 100644
--- a/src/box/vy_run.h
+++ b/src/box/vy_run.h
@@ -144,8 +144,8 @@ struct vy_run {
 	 * after compaction.
 	 */
 	struct rlist in_unused;
-	/** Link in vy_index::runs list. */
-	struct rlist in_index;
+	/** Link in vy_lsm::runs list. */
+	struct rlist in_lsm;
 };
 
 /**
@@ -214,9 +214,9 @@ struct vy_run_iterator {
 	struct vy_run_iterator_stat *stat;
 
 	/* Members needed for memory allocation and disk access */
-	/** Index key definition used for storing statements on disk. */
+	/** Key definition used for comparing statements on disk. */
 	const struct key_def *cmp_def;
-	/** Index key definition defined by the user. */
+	/** Key definition provided by the user. */
 	const struct key_def *key_def;
 	/**
 	 * Format ot allocate REPLACE and DELETE tuples read from
@@ -382,8 +382,8 @@ enum vy_file_type {
 extern const char *vy_file_suffix[];
 
 static inline int
-vy_index_snprint_path(char *buf, int size, const char *dir,
-		      uint32_t space_id, uint32_t iid)
+vy_lsm_snprint_path(char *buf, int size, const char *dir,
+		    uint32_t space_id, uint32_t iid)
 {
 	return snprintf(buf, size, "%s/%u/%u",
 			dir, (unsigned)space_id, (unsigned)iid);
@@ -403,7 +403,7 @@ vy_run_snprint_path(char *buf, int size, const char *dir,
 		    int64_t run_id, enum vy_file_type type)
 {
 	int total = 0;
-	SNPRINT(total, vy_index_snprint_path, buf, size,
+	SNPRINT(total, vy_lsm_snprint_path, buf, size,
 		dir, (unsigned)space_id, (unsigned)iid);
 	SNPRINT(total, snprintf, buf, size, "/");
 	SNPRINT(total, vy_run_snprint_filename, buf, size, run_id, type);
diff --git a/src/box/vy_scheduler.c b/src/box/vy_scheduler.c
index 2ae0d8ca..27961155 100644
--- a/src/box/vy_scheduler.c
+++ b/src/box/vy_scheduler.c
@@ -48,7 +48,7 @@
 #include "fiber_cond.h"
 #include "salad/stailq.h"
 #include "say.h"
-#include "vy_index.h"
+#include "vy_lsm.h"
 #include "vy_log.h"
 #include "vy_mem.h"
 #include "vy_range.h"
@@ -93,7 +93,7 @@ struct vy_task_ops {
 	/**
 	 * This function is called by the scheduler if either ->execute
 	 * or ->complete failed. It may be used to undo changes done to
-	 * the index when preparing the task.
+	 * the LSM tree when preparing the task.
 	 *
 	 * If @in_shutdown is set, the callback is invoked from the
 	 * engine destructor.
@@ -108,10 +108,10 @@ struct vy_task {
 	int status;
 	/** If ->execute fails, the error is stored here. */
 	struct diag diag;
-	/** Index this task is for. */
-	struct vy_index *index;
+	/** LSM tree this task is for. */
+	struct vy_lsm *lsm;
 	/**
-	 * Copies of index->key/cmp_def to protect from
+	 * Copies of lsm->key/cmp_def to protect from
 	 * multithread read/write on alter.
 	 */
 	struct key_def *cmp_def;
@@ -154,11 +154,11 @@ struct vy_task {
  * Allocate a new task to be executed by a worker thread.
  * When preparing an asynchronous task, this function must
  * be called before yielding the current fiber in order to
- * pin the index the task is for so that a concurrent fiber
+ * pin the LSM tree the task is for so that a concurrent fiber
  * does not free it from under us.
  */
 static struct vy_task *
-vy_task_new(struct mempool *pool, struct vy_index *index,
+vy_task_new(struct mempool *pool, struct vy_lsm *lsm,
 	    const struct vy_task_ops *ops)
 {
 	struct vy_task *task = mempool_alloc(pool);
@@ -169,19 +169,19 @@ vy_task_new(struct mempool *pool, struct vy_index *index,
 	}
 	memset(task, 0, sizeof(*task));
 	task->ops = ops;
-	task->index = index;
-	task->cmp_def = key_def_dup(index->cmp_def);
+	task->lsm = lsm;
+	task->cmp_def = key_def_dup(lsm->cmp_def);
 	if (task->cmp_def == NULL) {
 		mempool_free(pool, task);
 		return NULL;
 	}
-	task->key_def = key_def_dup(index->key_def);
+	task->key_def = key_def_dup(lsm->key_def);
 	if (task->key_def == NULL) {
 		key_def_delete(task->cmp_def);
 		mempool_free(pool, task);
 		return NULL;
 	}
-	vy_index_ref(index);
+	vy_lsm_ref(lsm);
 	diag_create(&task->diag);
 	return task;
 }
@@ -192,7 +192,7 @@ vy_task_delete(struct mempool *pool, struct vy_task *task)
 {
 	key_def_delete(task->cmp_def);
 	key_def_delete(task->key_def);
-	vy_index_unref(task->index);
+	vy_lsm_unref(task->lsm);
 	diag_destroy(&task->diag);
 	TRASH(task);
 	mempool_free(pool, task);
@@ -201,21 +201,22 @@ vy_task_delete(struct mempool *pool, struct vy_task *task)
 static bool
 vy_dump_heap_less(struct heap_node *a, struct heap_node *b)
 {
-	struct vy_index *i1 = container_of(a, struct vy_index, in_dump);
-	struct vy_index *i2 = container_of(b, struct vy_index, in_dump);
+	struct vy_lsm *i1 = container_of(a, struct vy_lsm, in_dump);
+	struct vy_lsm *i2 = container_of(b, struct vy_lsm, in_dump);
 
 	/*
-	 * Indexes that are currently being dumped or can't be scheduled
-	 * for dump right now are moved off the top of the heap.
+	 * LSM trees that are currently being dumped or can't be
+	 * scheduled for dump right now are moved off the top of
+	 * the heap.
 	 */
 	if (i1->is_dumping != i2->is_dumping)
 		return i1->is_dumping < i2->is_dumping;
 	if (i1->pin_count != i2->pin_count)
 		return i1->pin_count < i2->pin_count;
 
-	/* Older indexes are dumped first. */
-	int64_t i1_generation = vy_index_generation(i1);
-	int64_t i2_generation = vy_index_generation(i2);
+	/* Older LSM trees are dumped first. */
+	int64_t i1_generation = vy_lsm_generation(i1);
+	int64_t i2_generation = vy_lsm_generation(i2);
 	if (i1_generation != i2_generation)
 		return i1_generation < i2_generation;
 	/*
@@ -240,13 +241,13 @@ vy_dump_heap_less(struct heap_node *a, struct heap_node *b)
 static bool
 vy_compact_heap_less(struct heap_node *a, struct heap_node *b)
 {
-	struct vy_index *i1 = container_of(a, struct vy_index, in_compact);
-	struct vy_index *i2 = container_of(b, struct vy_index, in_compact);
+	struct vy_lsm *i1 = container_of(a, struct vy_lsm, in_compact);
+	struct vy_lsm *i2 = container_of(b, struct vy_lsm, in_compact);
 	/*
-	 * Prefer indexes whose read amplification will be reduced
+	 * Prefer LSM trees whose read amplification will be reduced
 	 * most as a result of compaction.
 	 */
-	return vy_index_compact_priority(i1) > vy_index_compact_priority(i2);
+	return vy_lsm_compact_priority(i1) > vy_lsm_compact_priority(i2);
 }
 
 #define HEAP_NAME vy_compact_heap
@@ -388,58 +389,55 @@ vy_scheduler_destroy(struct vy_scheduler *scheduler)
 }
 
 void
-vy_scheduler_add_index(struct vy_scheduler *scheduler,
-		       struct vy_index *index)
+vy_scheduler_add_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm)
 {
-	assert(index->in_dump.pos == UINT32_MAX);
-	assert(index->in_compact.pos == UINT32_MAX);
-	vy_dump_heap_insert(&scheduler->dump_heap, &index->in_dump);
-	vy_compact_heap_insert(&scheduler->compact_heap, &index->in_compact);
+	assert(lsm->in_dump.pos == UINT32_MAX);
+	assert(lsm->in_compact.pos == UINT32_MAX);
+	vy_dump_heap_insert(&scheduler->dump_heap, &lsm->in_dump);
+	vy_compact_heap_insert(&scheduler->compact_heap, &lsm->in_compact);
 }
 
 void
-vy_scheduler_remove_index(struct vy_scheduler *scheduler,
-			  struct vy_index *index)
+vy_scheduler_remove_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm)
 {
-	assert(index->in_dump.pos != UINT32_MAX);
-	assert(index->in_compact.pos != UINT32_MAX);
-	vy_dump_heap_delete(&scheduler->dump_heap, &index->in_dump);
-	vy_compact_heap_delete(&scheduler->compact_heap, &index->in_compact);
-	index->in_dump.pos = UINT32_MAX;
-	index->in_compact.pos = UINT32_MAX;
+	assert(lsm->in_dump.pos != UINT32_MAX);
+	assert(lsm->in_compact.pos != UINT32_MAX);
+	vy_dump_heap_delete(&scheduler->dump_heap, &lsm->in_dump);
+	vy_compact_heap_delete(&scheduler->compact_heap, &lsm->in_compact);
+	lsm->in_dump.pos = UINT32_MAX;
+	lsm->in_compact.pos = UINT32_MAX;
 }
 
 static void
-vy_scheduler_update_index(struct vy_scheduler *scheduler,
-			  struct vy_index *index)
+vy_scheduler_update_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm)
 {
-	if (index->is_dropped) {
-		/* Dropped indexes are exempted from scheduling. */
-		assert(index->in_dump.pos == UINT32_MAX);
-		assert(index->in_compact.pos == UINT32_MAX);
+	if (lsm->is_dropped) {
+		/* Dropped LSM trees are exempted from scheduling. */
+		assert(lsm->in_dump.pos == UINT32_MAX);
+		assert(lsm->in_compact.pos == UINT32_MAX);
 		return;
 	}
-	assert(index->in_dump.pos != UINT32_MAX);
-	assert(index->in_compact.pos != UINT32_MAX);
-	vy_dump_heap_update(&scheduler->dump_heap, &index->in_dump);
-	vy_compact_heap_update(&scheduler->compact_heap, &index->in_compact);
+	assert(lsm->in_dump.pos != UINT32_MAX);
+	assert(lsm->in_compact.pos != UINT32_MAX);
+	vy_dump_heap_update(&scheduler->dump_heap, &lsm->in_dump);
+	vy_compact_heap_update(&scheduler->compact_heap, &lsm->in_compact);
 }
 
 static void
-vy_scheduler_pin_index(struct vy_scheduler *scheduler, struct vy_index *index)
+vy_scheduler_pin_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm)
 {
-	assert(!index->is_dumping);
-	if (index->pin_count++ == 0)
-		vy_scheduler_update_index(scheduler, index);
+	assert(!lsm->is_dumping);
+	if (lsm->pin_count++ == 0)
+		vy_scheduler_update_lsm(scheduler, lsm);
 }
 
 static void
-vy_scheduler_unpin_index(struct vy_scheduler *scheduler, struct vy_index *index)
+vy_scheduler_unpin_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm)
 {
-	assert(!index->is_dumping);
-	assert(index->pin_count > 0);
-	if (--index->pin_count == 0)
-		vy_scheduler_update_index(scheduler, index);
+	assert(!lsm->is_dumping);
+	assert(lsm->pin_count > 0);
+	if (--lsm->pin_count == 0)
+		vy_scheduler_update_lsm(scheduler, lsm);
 }
 
 void
@@ -486,22 +484,21 @@ vy_scheduler_complete_dump(struct vy_scheduler *scheduler)
 	int64_t min_generation = scheduler->generation;
 	struct heap_node *pn = vy_dump_heap_top(&scheduler->dump_heap);
 	if (pn != NULL) {
-		struct vy_index *index;
-		index = container_of(pn, struct vy_index, in_dump);
-		min_generation = vy_index_generation(index);
+		struct vy_lsm *lsm = container_of(pn, struct vy_lsm, in_dump);
+		min_generation = vy_lsm_generation(lsm);
 	}
 	if (min_generation == scheduler->dump_generation) {
 		/*
-		 * There are still indexes that must be dumped
+		 * There are still LSM trees that must be dumped
 		 * during the current dump round.
 		 */
 		return;
 	}
 
 	/*
-	 * The oldest index data is newer than @dump_generation,
-	 * so the current dump round has been finished. Notify
-	 * about dump completion.
+	 * The oldest LSM tree data is newer than @dump_generation,
+	 * so the current dump round has been finished. Notify about
+	 * dump completion.
 	 */
 	double now = ev_monotonic_now(loop());
 	double dump_duration = now - scheduler->dump_start;
@@ -590,19 +587,19 @@ vy_scheduler_end_checkpoint(struct vy_scheduler *scheduler)
 }
 
 /**
- * Allocate a new run for an index and write the information
+ * Allocate a new run for an LSM tree and write the information
  * about it to the metadata log so that we could still find
  * and delete it in case a write error occured. This function
  * is called from dump/compaction task constructor.
  */
 static struct vy_run *
-vy_run_prepare(struct vy_run_env *run_env, struct vy_index *index)
+vy_run_prepare(struct vy_run_env *run_env, struct vy_lsm *lsm)
 {
 	struct vy_run *run = vy_run_new(run_env, vy_log_next_id());
 	if (run == NULL)
 		return NULL;
 	vy_log_tx_begin();
-	vy_log_prepare_run(index->id, run->id);
+	vy_log_prepare_run(lsm->id, run->id);
 	if (vy_log_tx_commit() < 0) {
 		vy_run_unref(run);
 		return NULL;
@@ -643,7 +640,7 @@ vy_run_discard(struct vy_run *run)
 static int
 vy_task_write_run(struct vy_scheduler *scheduler, struct vy_task *task)
 {
-	struct vy_index *index = task->index;
+	struct vy_lsm *lsm = task->lsm;
 	struct vy_stmt_stream *wi = task->wi;
 
 	ERROR_INJECT(ERRINJ_VY_RUN_WRITE,
@@ -655,8 +652,8 @@ vy_task_write_run(struct vy_scheduler *scheduler, struct vy_task *task)
 		usleep(inj->dparam * 1000000);
 
 	struct vy_run_writer writer;
-	if (vy_run_writer_create(&writer, task->new_run, index->env->path,
-				 index->space_id, index->index_id,
+	if (vy_run_writer_create(&writer, task->new_run, lsm->env->path,
+				 lsm->space_id, lsm->index_id,
 				 task->cmp_def, task->key_def,
 				 task->page_size, task->bloom_fpr,
 				 task->max_output_count) != 0)
@@ -705,34 +702,34 @@ vy_task_dump_execute(struct vy_scheduler *scheduler, struct vy_task *task)
 static int
 vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 {
-	struct vy_index *index = task->index;
+	struct vy_lsm *lsm = task->lsm;
 	struct vy_run *new_run = task->new_run;
 	int64_t dump_lsn = new_run->dump_lsn;
-	struct tuple_format *key_format = index->env->key_format;
+	struct tuple_format *key_format = lsm->env->key_format;
 	struct vy_mem *mem, *next_mem;
 	struct vy_slice **new_slices, *slice;
 	struct vy_range *range, *begin_range, *end_range;
 	struct tuple *min_key, *max_key;
 	int i, loops = 0;
 
-	assert(index->is_dumping);
+	assert(lsm->is_dumping);
 
 	if (vy_run_is_empty(new_run)) {
 		/*
 		 * In case the run is empty, we can discard the run
 		 * and delete dumped in-memory trees right away w/o
 		 * inserting slices into ranges. However, we need
-		 * to log index dump anyway.
+		 * to log LSM tree dump anyway.
 		 */
 		vy_log_tx_begin();
-		vy_log_dump_index(index->id, dump_lsn);
+		vy_log_dump_lsm(lsm->id, dump_lsn);
 		if (vy_log_tx_commit() < 0)
 			goto fail;
 		vy_run_discard(new_run);
 		goto delete_mems;
 	}
 
-	assert(new_run->info.min_lsn > index->dump_lsn);
+	assert(new_run->info.min_lsn > lsm->dump_lsn);
 	assert(new_run->info.max_lsn <= dump_lsn);
 
 	/*
@@ -750,28 +747,28 @@ vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 		tuple_unref(min_key);
 		goto fail;
 	}
-	begin_range = vy_range_tree_psearch(index->tree, min_key);
-	end_range = vy_range_tree_nsearch(index->tree, max_key);
+	begin_range = vy_range_tree_psearch(lsm->tree, min_key);
+	end_range = vy_range_tree_nsearch(lsm->tree, max_key);
 	tuple_unref(min_key);
 	tuple_unref(max_key);
 
 	/*
 	 * For each intersected range allocate a slice of the new run.
 	 */
-	new_slices = calloc(index->range_count, sizeof(*new_slices));
+	new_slices = calloc(lsm->range_count, sizeof(*new_slices));
 	if (new_slices == NULL) {
-		diag_set(OutOfMemory, index->range_count * sizeof(*new_slices),
+		diag_set(OutOfMemory, lsm->range_count * sizeof(*new_slices),
 			 "malloc", "struct vy_slice *");
 		goto fail;
 	}
 	for (range = begin_range, i = 0; range != end_range;
-	     range = vy_range_tree_next(index->tree, range), i++) {
+	     range = vy_range_tree_next(lsm->tree, range), i++) {
 		slice = vy_slice_new(vy_log_next_id(), new_run,
-				     range->begin, range->end, index->cmp_def);
+				     range->begin, range->end, lsm->cmp_def);
 		if (slice == NULL)
 			goto fail_free_slices;
 
-		assert(i < index->range_count);
+		assert(i < lsm->range_count);
 		new_slices[i] = slice;
 		/*
 		 * It's OK to yield here for the range tree can only
@@ -785,10 +782,10 @@ vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 	 * Log change in metadata.
 	 */
 	vy_log_tx_begin();
-	vy_log_create_run(index->id, new_run->id, dump_lsn);
+	vy_log_create_run(lsm->id, new_run->id, dump_lsn);
 	for (range = begin_range, i = 0; range != end_range;
-	     range = vy_range_tree_next(index->tree, range), i++) {
-		assert(i < index->range_count);
+	     range = vy_range_tree_next(lsm->tree, range), i++) {
+		assert(i < lsm->range_count);
 		slice = new_slices[i];
 		vy_log_insert_slice(range->id, new_run->id, slice->id,
 				    tuple_data_or_null(slice->begin),
@@ -797,15 +794,15 @@ vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 		if (++loops % VY_YIELD_LOOPS == 0)
 			fiber_sleep(0); /* see comment above */
 	}
-	vy_log_dump_index(index->id, dump_lsn);
+	vy_log_dump_lsm(lsm->id, dump_lsn);
 	if (vy_log_tx_commit() < 0)
 		goto fail_free_slices;
 
 	/*
 	 * Account the new run.
 	 */
-	vy_index_add_run(index, new_run);
-	vy_stmt_counter_add_disk(&index->stat.disk.dump.out, &new_run->count);
+	vy_lsm_add_run(lsm, new_run);
+	vy_stmt_counter_add_disk(&lsm->stat.disk.dump.out, &new_run->count);
 
 	/* Drop the reference held by the task. */
 	vy_run_unref(new_run);
@@ -814,23 +811,23 @@ vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 	 * Add new slices to ranges.
 	 */
 	for (range = begin_range, i = 0; range != end_range;
-	     range = vy_range_tree_next(index->tree, range), i++) {
-		assert(i < index->range_count);
+	     range = vy_range_tree_next(lsm->tree, range), i++) {
+		assert(i < lsm->range_count);
 		slice = new_slices[i];
-		vy_index_unacct_range(index, range);
+		vy_lsm_unacct_range(lsm, range);
 		vy_range_add_slice(range, slice);
-		vy_index_acct_range(index, range);
-		vy_range_update_compact_priority(range, &index->opts);
+		vy_lsm_acct_range(lsm, range);
+		vy_range_update_compact_priority(range, &lsm->opts);
 		if (!vy_range_is_scheduled(range))
-			vy_range_heap_update(&index->range_heap,
+			vy_range_heap_update(&lsm->range_heap,
 					     &range->heap_node);
 		range->version++;
 		/*
 		 * If we yield here, a concurrent fiber will see
 		 * a range with a run slice containing statements
-		 * present in the in-memory trees of the index.
+		 * present in the in-memory indexes of the LSM tree.
 		 * This is OK, because read iterator won't use the
-		 * new run slice until index->dump_lsn is bumped,
+		 * new run slice until lsm->dump_lsn is bumped,
 		 * which is only done after in-memory trees are
 		 * removed (see vy_read_iterator_add_disk()).
 		 */
@@ -843,34 +840,34 @@ delete_mems:
 	/*
 	 * Delete dumped in-memory trees.
 	 */
-	rlist_foreach_entry_safe(mem, &index->sealed, in_sealed, next_mem) {
+	rlist_foreach_entry_safe(mem, &lsm->sealed, in_sealed, next_mem) {
 		if (mem->generation > scheduler->dump_generation)
 			continue;
-		vy_stmt_counter_add(&index->stat.disk.dump.in, &mem->count);
-		vy_index_delete_mem(index, mem);
+		vy_stmt_counter_add(&lsm->stat.disk.dump.in, &mem->count);
+		vy_lsm_delete_mem(lsm, mem);
 	}
-	index->dump_lsn = dump_lsn;
-	index->stat.disk.dump.count++;
+	lsm->dump_lsn = dump_lsn;
+	lsm->stat.disk.dump.count++;
 
 	/* The iterator has been cleaned up in a worker thread. */
 	task->wi->iface->close(task->wi);
 
-	index->is_dumping = false;
-	vy_scheduler_update_index(scheduler, index);
+	lsm->is_dumping = false;
+	vy_scheduler_update_lsm(scheduler, lsm);
 
-	if (index->index_id != 0)
-		vy_scheduler_unpin_index(scheduler, index->pk);
+	if (lsm->index_id != 0)
+		vy_scheduler_unpin_lsm(scheduler, lsm->pk);
 
 	assert(scheduler->dump_task_count > 0);
 	scheduler->dump_task_count--;
 
-	say_info("%s: dump completed", vy_index_name(index));
+	say_info("%s: dump completed", vy_lsm_name(lsm));
 
 	vy_scheduler_complete_dump(scheduler);
 	return 0;
 
 fail_free_slices:
-	for (i = 0; i < index->range_count; i++) {
+	for (i = 0; i < lsm->range_count; i++) {
 		slice = new_slices[i];
 		if (slice != NULL)
 			vy_slice_delete(slice);
@@ -886,21 +883,21 @@ static void
 vy_task_dump_abort(struct vy_scheduler *scheduler, struct vy_task *task,
 		   bool in_shutdown)
 {
-	struct vy_index *index = task->index;
+	struct vy_lsm *lsm = task->lsm;
 
-	assert(index->is_dumping);
+	assert(lsm->is_dumping);
 
 	/* The iterator has been cleaned up in a worker thread. */
 	task->wi->iface->close(task->wi);
 
 	/*
 	 * It's no use alerting the user if the server is
-	 * shutting down or the index was dropped.
+	 * shutting down or the LSM tree was dropped.
 	 */
-	if (!in_shutdown && !index->is_dropped) {
+	if (!in_shutdown && !lsm->is_dropped) {
 		struct error *e = diag_last_error(&task->diag);
 		error_log(e);
-		say_error("%s: dump failed", vy_index_name(index));
+		say_error("%s: dump failed", vy_lsm_name(lsm));
 	}
 
 	/* The metadata log is unavailable on shutdown. */
@@ -909,36 +906,36 @@ vy_task_dump_abort(struct vy_scheduler *scheduler, struct vy_task *task,
 	else
 		vy_run_unref(task->new_run);
 
-	index->is_dumping = false;
-	vy_scheduler_update_index(scheduler, index);
+	lsm->is_dumping = false;
+	vy_scheduler_update_lsm(scheduler, lsm);
 
-	if (index->index_id != 0)
-		vy_scheduler_unpin_index(scheduler, index->pk);
+	if (lsm->index_id != 0)
+		vy_scheduler_unpin_lsm(scheduler, lsm->pk);
 
 	assert(scheduler->dump_task_count > 0);
 	scheduler->dump_task_count--;
 
 	/*
-	 * If the index was dropped during dump, we abort the
-	 * dump task, but we should still poke the scheduler
+	 * If the LSM tree was dropped during dump, we abort
+	 * the dump task, but we should still poke the scheduler
 	 * to check if the current dump round is complete.
-	 * If we don't and this index happens to be the last
+	 * If we don't and this LSM tree happens to be the last
 	 * one of the current generation, the scheduler will
 	 * never be notified about dump completion and hence
 	 * memory will never be released.
 	 */
-	if (index->is_dropped)
+	if (lsm->is_dropped)
 		vy_scheduler_complete_dump(scheduler);
 }
 
 /**
- * Create a task to dump an index.
+ * Create a task to dump an LSM tree.
  *
  * On success the task is supposed to dump all in-memory
  * trees created at @scheduler->dump_generation.
  */
 static int
-vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index,
+vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_lsm *lsm,
 		 struct vy_task **p_task)
 {
 	static struct vy_task_ops dump_ops = {
@@ -947,21 +944,21 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index,
 		.abort = vy_task_dump_abort,
 	};
 
-	assert(!index->is_dropped);
-	assert(!index->is_dumping);
-	assert(index->pin_count == 0);
-	assert(vy_index_generation(index) == scheduler->dump_generation);
+	assert(!lsm->is_dropped);
+	assert(!lsm->is_dumping);
+	assert(lsm->pin_count == 0);
+	assert(vy_lsm_generation(lsm) == scheduler->dump_generation);
 	assert(scheduler->dump_generation < scheduler->generation);
 
 	struct errinj *inj = errinj(ERRINJ_VY_INDEX_DUMP, ERRINJ_INT);
-	if (inj != NULL && inj->iparam == (int)index->index_id) {
+	if (inj != NULL && inj->iparam == (int)lsm->index_id) {
 		diag_set(ClientError, ER_INJECTION, "vinyl index dump");
 		goto err;
 	}
 
 	/* Rotate the active tree if it needs to be dumped. */
-	if (index->mem->generation == scheduler->dump_generation &&
-	    vy_index_rotate_mem(index) != 0)
+	if (lsm->mem->generation == scheduler->dump_generation &&
+	    vy_lsm_rotate_mem(lsm) != 0)
 		goto err;
 
 	/*
@@ -971,7 +968,7 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index,
 	int64_t dump_lsn = -1;
 	size_t max_output_count = 0;
 	struct vy_mem *mem, *next_mem;
-	rlist_foreach_entry_safe(mem, &index->sealed, in_sealed, next_mem) {
+	rlist_foreach_entry_safe(mem, &lsm->sealed, in_sealed, next_mem) {
 		if (mem->generation > scheduler->dump_generation)
 			continue;
 		vy_mem_wait_pinned(mem);
@@ -980,7 +977,7 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index,
 			 * The tree is empty so we can delete it
 			 * right away, without involving a worker.
 			 */
-			vy_index_delete_mem(index, mem);
+			vy_lsm_delete_mem(lsm, mem);
 			continue;
 		}
 		dump_lsn = MAX(dump_lsn, mem->max_lsn);
@@ -988,18 +985,18 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index,
 	}
 
 	if (max_output_count == 0) {
-		/* Nothing to do, pick another index. */
-		vy_scheduler_update_index(scheduler, index);
+		/* Nothing to do, pick another LSM tree. */
+		vy_scheduler_update_lsm(scheduler, lsm);
 		vy_scheduler_complete_dump(scheduler);
 		return 0;
 	}
 
 	struct vy_task *task = vy_task_new(&scheduler->task_pool,
-					   index, &dump_ops);
+					   lsm, &dump_ops);
 	if (task == NULL)
 		goto err;
 
-	struct vy_run *new_run = vy_run_prepare(scheduler->run_env, index);
+	struct vy_run *new_run = vy_run_prepare(scheduler->run_env, lsm);
 	if (new_run == NULL)
 		goto err_run;
 
@@ -1007,13 +1004,13 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index,
 	new_run->dump_lsn = dump_lsn;
 
 	struct vy_stmt_stream *wi;
-	bool is_last_level = (index->run_count == 0);
-	wi = vy_write_iterator_new(task->cmp_def, index->disk_format,
-				   index->upsert_format, index->index_id == 0,
+	bool is_last_level = (lsm->run_count == 0);
+	wi = vy_write_iterator_new(task->cmp_def, lsm->disk_format,
+				   lsm->upsert_format, lsm->index_id == 0,
 				   is_last_level, scheduler->read_views);
 	if (wi == NULL)
 		goto err_wi;
-	rlist_foreach_entry(mem, &index->sealed, in_sealed) {
+	rlist_foreach_entry(mem, &lsm->sealed, in_sealed) {
 		if (mem->generation > scheduler->dump_generation)
 			continue;
 		if (vy_write_iterator_new_mem(wi, mem) != 0)
@@ -1023,27 +1020,27 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index,
 	task->new_run = new_run;
 	task->wi = wi;
 	task->max_output_count = max_output_count;
-	task->bloom_fpr = index->opts.bloom_fpr;
-	task->page_size = index->opts.page_size;
+	task->bloom_fpr = lsm->opts.bloom_fpr;
+	task->page_size = lsm->opts.page_size;
 
-	index->is_dumping = true;
-	vy_scheduler_update_index(scheduler, index);
+	lsm->is_dumping = true;
+	vy_scheduler_update_lsm(scheduler, lsm);
 
-	if (index->index_id != 0) {
+	if (lsm->index_id != 0) {
 		/*
-		 * The primary index must be dumped after all
-		 * secondary indexes of the same space - see
-		 * vy_dump_heap_less(). To make sure it isn't
-		 * picked by the scheduler while all secondary
-		 * indexes are being dumped, temporarily remove
+		 * The primary index LSM tree must be dumped after
+		 * all secondary index LSM trees of the same space,
+		 * see vy_dump_heap_less(). To make sure it isn't
+		 * picked by the scheduler while all secondary index
+		 * LSM trees are being dumped, temporarily remove
 		 * it from the dump heap.
 		 */
-		vy_scheduler_pin_index(scheduler, index->pk);
+		vy_scheduler_pin_lsm(scheduler, lsm->pk);
 	}
 
 	scheduler->dump_task_count++;
 
-	say_info("%s: dump started", vy_index_name(index));
+	say_info("%s: dump started", vy_lsm_name(lsm));
 	*p_task = task;
 	return 0;
 
@@ -1055,7 +1052,7 @@ err_run:
 	vy_task_delete(&scheduler->task_pool, task);
 err:
 	diag_log();
-	say_error("%s: could not start dump", vy_index_name(index));
+	say_error("%s: could not start dump", vy_lsm_name(lsm));
 	return -1;
 }
 
@@ -1068,7 +1065,7 @@ vy_task_compact_execute(struct vy_scheduler *scheduler, struct vy_task *task)
 static int
 vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 {
-	struct vy_index *index = task->index;
+	struct vy_lsm *lsm = task->lsm;
 	struct vy_range *range = task->range;
 	struct vy_run *new_run = task->new_run;
 	struct vy_slice *first_slice = task->first_slice;
@@ -1084,8 +1081,8 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 	 * compacted runs.
 	 */
 	if (!vy_run_is_empty(new_run)) {
-		new_slice = vy_slice_new(vy_log_next_id(), new_run, NULL, NULL,
-					 index->cmp_def);
+		new_slice = vy_slice_new(vy_log_next_id(), new_run,
+					 NULL, NULL, lsm->cmp_def);
 		if (new_slice == NULL)
 			return -1;
 	}
@@ -1122,8 +1119,7 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 	rlist_foreach_entry(run, &unused_runs, in_unused)
 		vy_log_drop_run(run->id, gc_lsn);
 	if (new_slice != NULL) {
-		vy_log_create_run(index->id, new_run->id,
-				  new_run->dump_lsn);
+		vy_log_create_run(lsm->id, new_run->id, new_run->dump_lsn);
 		vy_log_insert_slice(range->id, new_run->id, new_slice->id,
 				    tuple_data_or_null(new_slice->begin),
 				    tuple_data_or_null(new_slice->end));
@@ -1142,10 +1138,8 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 		 */
 		vy_log_tx_begin();
 		rlist_foreach_entry(run, &unused_runs, in_unused) {
-			if (vy_run_remove_files(index->env->path,
-						index->space_id,
-						index->index_id,
-						run->id) == 0) {
+			if (vy_run_remove_files(lsm->env->path, lsm->space_id,
+						lsm->index_id, run->id) == 0) {
 				vy_log_forget_run(run->id);
 			}
 		}
@@ -1157,8 +1151,8 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 	 * otherwise discard it.
 	 */
 	if (new_slice != NULL) {
-		vy_index_add_run(index, new_run);
-		vy_stmt_counter_add_disk(&index->stat.disk.compact.out,
+		vy_lsm_add_run(lsm, new_run);
+		vy_stmt_counter_add_disk(&lsm->stat.disk.compact.out,
 					 &new_run->count);
 		/* Drop the reference held by the task. */
 		vy_run_unref(new_run);
@@ -1174,29 +1168,29 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 	 * the compacted slices were.
 	 */
 	RLIST_HEAD(compacted_slices);
-	vy_index_unacct_range(index, range);
+	vy_lsm_unacct_range(lsm, range);
 	if (new_slice != NULL)
 		vy_range_add_slice_before(range, new_slice, first_slice);
 	for (slice = first_slice; ; slice = next_slice) {
 		next_slice = rlist_next_entry(slice, in_range);
 		vy_range_remove_slice(range, slice);
 		rlist_add_entry(&compacted_slices, slice, in_range);
-		vy_stmt_counter_add_disk(&index->stat.disk.compact.in,
+		vy_stmt_counter_add_disk(&lsm->stat.disk.compact.in,
 					 &slice->count);
 		if (slice == last_slice)
 			break;
 	}
 	range->n_compactions++;
 	range->version++;
-	vy_index_acct_range(index, range);
-	vy_range_update_compact_priority(range, &index->opts);
-	index->stat.disk.compact.count++;
+	vy_lsm_acct_range(lsm, range);
+	vy_range_update_compact_priority(range, &lsm->opts);
+	lsm->stat.disk.compact.count++;
 
 	/*
 	 * Unaccount unused runs and delete compacted slices.
 	 */
 	rlist_foreach_entry(run, &unused_runs, in_unused)
-		vy_index_remove_run(index, run);
+		vy_lsm_remove_run(lsm, run);
 	rlist_foreach_entry_safe(slice, &compacted_slices,
 				 in_range, next_slice) {
 		vy_slice_wait_pinned(slice);
@@ -1207,11 +1201,11 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task)
 	task->wi->iface->close(task->wi);
 
 	assert(range->heap_node.pos == UINT32_MAX);
-	vy_range_heap_insert(&index->range_heap, &range->heap_node);
-	vy_scheduler_update_index(scheduler, index);
+	vy_range_heap_insert(&lsm->range_heap, &range->heap_node);
+	vy_scheduler_update_lsm(scheduler, lsm);
 
 	say_info("%s: completed compacting range %s",
-		 vy_index_name(index), vy_range_str(range));
+		 vy_lsm_name(lsm), vy_range_str(range));
 	return 0;
 }
 
@@ -1219,7 +1213,7 @@ static void
 vy_task_compact_abort(struct vy_scheduler *scheduler, struct vy_task *task,
 		      bool in_shutdown)
 {
-	struct vy_index *index = task->index;
+	struct vy_lsm *lsm = task->lsm;
 	struct vy_range *range = task->range;
 
 	/* The iterator has been cleaned up in worker. */
@@ -1227,13 +1221,13 @@ vy_task_compact_abort(struct vy_scheduler *scheduler, struct vy_task *task,
 
 	/*
 	 * It's no use alerting the user if the server is
-	 * shutting down or the index was dropped.
+	 * shutting down or the LSM tree was dropped.
 	 */
-	if (!in_shutdown && !index->is_dropped) {
+	if (!in_shutdown && !lsm->is_dropped) {
 		struct error *e = diag_last_error(&task->diag);
 		error_log(e);
 		say_error("%s: failed to compact range %s",
-			  vy_index_name(index), vy_range_str(range));
+			  vy_lsm_name(lsm), vy_range_str(range));
 	}
 
 	/* The metadata log is unavailable on shutdown. */
@@ -1243,12 +1237,12 @@ vy_task_compact_abort(struct vy_scheduler *scheduler, struct vy_task *task,
 		vy_run_unref(task->new_run);
 
 	assert(range->heap_node.pos == UINT32_MAX);
-	vy_range_heap_insert(&index->range_heap, &range->heap_node);
-	vy_scheduler_update_index(scheduler, index);
+	vy_range_heap_insert(&lsm->range_heap, &range->heap_node);
+	vy_scheduler_update_lsm(scheduler, lsm);
 }
 
 static int
-vy_task_compact_new(struct vy_scheduler *scheduler, struct vy_index *index,
+vy_task_compact_new(struct vy_scheduler *scheduler, struct vy_lsm *lsm,
 		    struct vy_task **p_task)
 {
 	static struct vy_task_ops compact_ops = {
@@ -1260,32 +1254,32 @@ vy_task_compact_new(struct vy_scheduler *scheduler, struct vy_index *index,
 	struct heap_node *range_node;
 	struct vy_range *range;
 
-	assert(!index->is_dropped);
+	assert(!lsm->is_dropped);
 
-	range_node = vy_range_heap_top(&index->range_heap);
+	range_node = vy_range_heap_top(&lsm->range_heap);
 	assert(range_node != NULL);
 	range = container_of(range_node, struct vy_range, heap_node);
 	assert(range->compact_priority > 1);
 
-	if (vy_index_split_range(index, range) ||
-	    vy_index_coalesce_range(index, range)) {
-		vy_scheduler_update_index(scheduler, index);
+	if (vy_lsm_split_range(lsm, range) ||
+	    vy_lsm_coalesce_range(lsm, range)) {
+		vy_scheduler_update_lsm(scheduler, lsm);
 		return 0;
 	}
 
 	struct vy_task *task = vy_task_new(&scheduler->task_pool,
-					   index, &compact_ops);
+					   lsm, &compact_ops);
 	if (task == NULL)
 		goto err_task;
 
-	struct vy_run *new_run = vy_run_prepare(scheduler->run_env, index);
+	struct vy_run *new_run = vy_run_prepare(scheduler->run_env, lsm);
 	if (new_run == NULL)
 		goto err_run;
 
 	struct vy_stmt_stream *wi;
 	bool is_last_level = (range->compact_priority == range->slice_count);
-	wi = vy_write_iterator_new(task->cmp_def, index->disk_format,
-				   index->upsert_format, index->index_id == 0,
+	wi = vy_write_iterator_new(task->cmp_def, lsm->disk_format,
+				   lsm->upsert_format, lsm->index_id == 0,
 				   is_last_level, scheduler->read_views);
 	if (wi == NULL)
 		goto err_wi;
@@ -1314,19 +1308,19 @@ vy_task_compact_new(struct vy_scheduler *scheduler, struct vy_index *index,
 	task->range = range;
 	task->new_run = new_run;
 	task->wi = wi;
-	task->bloom_fpr = index->opts.bloom_fpr;
-	task->page_size = index->opts.page_size;
+	task->bloom_fpr = lsm->opts.bloom_fpr;
+	task->page_size = lsm->opts.page_size;
 
 	/*
 	 * Remove the range we are going to compact from the heap
 	 * so that it doesn't get selected again.
 	 */
-	vy_range_heap_delete(&index->range_heap, range_node);
+	vy_range_heap_delete(&lsm->range_heap, range_node);
 	range_node->pos = UINT32_MAX;
-	vy_scheduler_update_index(scheduler, index);
+	vy_scheduler_update_lsm(scheduler, lsm);
 
 	say_info("%s: started compacting range %s, runs %d/%d",
-		 vy_index_name(index), vy_range_str(range),
+		 vy_lsm_name(lsm), vy_range_str(range),
                  range->compact_priority, range->slice_count);
 	*p_task = task;
 	return 0;
@@ -1340,17 +1334,17 @@ err_run:
 err_task:
 	diag_log();
 	say_error("%s: could not start compacting range %s: %s",
-		  vy_index_name(index), vy_range_str(range));
+		  vy_lsm_name(lsm), vy_range_str(range));
 	return -1;
 }
 
 /**
- * Create a task for dumping an index. The new task is returned
- * in @ptask. If there's no index that needs to be dumped @ptask
+ * Create a task for dumping an LSM tree. The new task is returned
+ * in @ptask. If there's no LSM tree that needs to be dumped @ptask
  * is set to NULL.
  *
- * We only dump an index if it needs to be snapshotted or the quota
- * on memory usage is exceeded. In either case, the oldest index
+ * We only dump an LSM tree if it needs to be snapshotted or the quota
+ * on memory usage is exceeded. In either case, the oldest LSM tree
  * is selected, because dumping it will free the maximal amount of
  * memory due to log structured design of the memory allocator.
  *
@@ -1370,38 +1364,38 @@ retry:
 		return 0;
 	}
 	/*
-	 * Look up the oldest index eligible for dump.
+	 * Look up the oldest LSM tree eligible for dump.
 	 */
 	struct heap_node *pn = vy_dump_heap_top(&scheduler->dump_heap);
 	if (pn == NULL) {
 		/*
-		 * There is no vinyl index and so no task to schedule.
+		 * There is no LSM tree and so no task to schedule.
 		 * Complete the current dump round.
 		 */
 		vy_scheduler_complete_dump(scheduler);
 		return 0;
 	}
-	struct vy_index *index = container_of(pn, struct vy_index, in_dump);
-	if (!index->is_dumping && index->pin_count == 0 &&
-	    vy_index_generation(index) == scheduler->dump_generation) {
+	struct vy_lsm *lsm = container_of(pn, struct vy_lsm, in_dump);
+	if (!lsm->is_dumping && lsm->pin_count == 0 &&
+	    vy_lsm_generation(lsm) == scheduler->dump_generation) {
 		/*
-		 * Dump is in progress and there is an index that
+		 * Dump is in progress and there is an LSM tree that
 		 * contains data that must be dumped at the current
 		 * round. Try to create a task for it.
 		 */
-		if (vy_task_dump_new(scheduler, index, ptask) != 0)
+		if (vy_task_dump_new(scheduler, lsm, ptask) != 0)
 			return -1;
 		if (*ptask != NULL)
 			return 0; /* new task */
 		/*
 		 * All in-memory trees eligible for dump were empty
 		 * and so were deleted without involving a worker
-		 * thread. Check another index.
+		 * thread. Check another LSM tree.
 		 */
 		goto retry;
 	}
 	/*
-	 * Dump is in progress, but all eligible indexes are
+	 * Dump is in progress, but all eligible LSM trees are
 	 * already being dumped. Wait until the current round
 	 * is complete.
 	 */
@@ -1430,13 +1424,13 @@ retry:
 	struct heap_node *pn = vy_compact_heap_top(&scheduler->compact_heap);
 	if (pn == NULL)
 		return 0; /* nothing to do */
-	struct vy_index *index = container_of(pn, struct vy_index, in_compact);
-	if (vy_index_compact_priority(index) <= 1)
+	struct vy_lsm *lsm = container_of(pn, struct vy_lsm, in_compact);
+	if (vy_lsm_compact_priority(lsm) <= 1)
 		return 0; /* nothing to do */
-	if (vy_task_compact_new(scheduler, index, ptask) != 0)
+	if (vy_task_compact_new(scheduler, lsm, ptask) != 0)
 		return -1;
 	if (*ptask == NULL)
-		goto retry; /* index dropped or range split/coalesced */
+		goto retry; /* LSM tree dropped or range split/coalesced */
 	return 0; /* new task */
 }
 
@@ -1480,7 +1474,7 @@ static int
 vy_scheduler_complete_task(struct vy_scheduler *scheduler,
 			   struct vy_task *task)
 {
-	if (task->index->is_dropped) {
+	if (task->lsm->is_dropped) {
 		if (task->ops->abort)
 			task->ops->abort(scheduler, task, false);
 		return 0;
diff --git a/src/box/vy_scheduler.h b/src/box/vy_scheduler.h
index 6724c01b..4db86152 100644
--- a/src/box/vy_scheduler.h
+++ b/src/box/vy_scheduler.h
@@ -50,7 +50,7 @@ extern "C" {
 
 struct cord;
 struct fiber;
-struct vy_index;
+struct vy_lsm;
 struct vy_run_env;
 struct vy_scheduler;
 
@@ -97,13 +97,13 @@ struct vy_scheduler {
 	 */
 	pthread_mutex_t mutex;
 	/**
-	 * Heap of indexes, ordered by dump priority,
-	 * linked by vy_index::in_dump.
+	 * Heap of LSM trees, ordered by dump priority,
+	 * linked by vy_lsm::in_dump.
 	 */
 	heap_t dump_heap;
 	/**
-	 * Heap of indexes, ordered by compaction priority,
-	 * linked by vy_index::in_compact.
+	 * Heap of LSM trees, ordered by compaction priority,
+	 * linked by vy_lsm::in_compact.
 	 */
 	heap_t compact_heap;
 	/** Last error seen by the scheduler. */
@@ -184,16 +184,16 @@ void
 vy_scheduler_destroy(struct vy_scheduler *scheduler);
 
 /**
- * Add an index to scheduler dump/compaction queues.
+ * Add an LSM tree to scheduler dump/compaction queues.
  */
 void
-vy_scheduler_add_index(struct vy_scheduler *, struct vy_index *);
+vy_scheduler_add_lsm(struct vy_scheduler *, struct vy_lsm *);
 
 /**
- * Remove an index from scheduler dump/compaction queues.
+ * Remove an LSM tree from scheduler dump/compaction queues.
  */
 void
-vy_scheduler_remove_index(struct vy_scheduler *, struct vy_index *);
+vy_scheduler_remove_lsm(struct vy_scheduler *, struct vy_lsm *);
 
 /**
  * Trigger dump of all currently existing in-memory trees.
diff --git a/src/box/vy_stat.h b/src/box/vy_stat.h
index 35442629..ca52c4d3 100644
--- a/src/box/vy_stat.h
+++ b/src/box/vy_stat.h
@@ -110,13 +110,13 @@ struct vy_compact_stat {
 	struct vy_stmt_counter out;
 };
 
-/** Vinyl index statistics. */
-struct vy_index_stat {
-	/** Number of lookups in the index. */
+/** LSM tree statistics. */
+struct vy_lsm_stat {
+	/** Number of lookups in the LSM tree. */
 	int64_t lookup;
-	/** Number of statements read from this index. */
+	/** Number of statements read from this LSM tree. */
 	struct vy_stmt_counter get;
-	/** Number of statements written to this index. */
+	/** Number of statements written to this LSM tree. */
 	struct vy_stmt_counter put;
 	/** Read latency. */
 	struct latency latency;
@@ -187,13 +187,13 @@ struct vy_tx_stat {
 };
 
 static inline int
-vy_index_stat_create(struct vy_index_stat *stat)
+vy_lsm_stat_create(struct vy_lsm_stat *stat)
 {
 	return latency_create(&stat->latency);
 }
 
 static inline void
-vy_index_stat_destroy(struct vy_index_stat *stat)
+vy_lsm_stat_destroy(struct vy_lsm_stat *stat)
 {
 	latency_destroy(&stat->latency);
 }
diff --git a/src/box/vy_tx.c b/src/box/vy_tx.c
index 1b583240..ed423ba3 100644
--- a/src/box/vy_tx.c
+++ b/src/box/vy_tx.c
@@ -50,7 +50,7 @@
 #include "trivia/util.h"
 #include "tuple.h"
 #include "vy_cache.h"
-#include "vy_index.h"
+#include "vy_lsm.h"
 #include "vy_mem.h"
 #include "vy_stat.h"
 #include "vy_stmt.h"
@@ -61,18 +61,18 @@
 int
 write_set_cmp(struct txv *a, struct txv *b)
 {
-	int rc = a->index < b->index ? -1 : a->index > b->index;
+	int rc = a->lsm < b->lsm ? -1 : a->lsm > b->lsm;
 	if (rc == 0)
-		return vy_tuple_compare(a->stmt, b->stmt, a->index->cmp_def);
+		return vy_tuple_compare(a->stmt, b->stmt, a->lsm->cmp_def);
 	return rc;
 }
 
 int
 write_set_key_cmp(struct write_set_key *a, struct txv *b)
 {
-	int rc = a->index < b->index ? -1 : a->index > b->index;
+	int rc = a->lsm < b->lsm ? -1 : a->lsm > b->lsm;
 	if (rc == 0)
-		return vy_stmt_compare(a->stmt, b->stmt, a->index->cmp_def);
+		return vy_stmt_compare(a->stmt, b->stmt, a->lsm->cmp_def);
 	return rc;
 }
 
@@ -204,7 +204,7 @@ tx_manager_vlsn(struct tx_manager *xm)
 }
 
 static struct txv *
-txv_new(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt)
+txv_new(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt)
 {
 	struct tx_manager *xm = tx->xm;
 	struct txv *v = mempool_alloc(&xm->txv_mempool);
@@ -212,8 +212,8 @@ txv_new(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt)
 		diag_set(OutOfMemory, sizeof(*v), "mempool", "struct txv");
 		return NULL;
 	}
-	v->index = index;
-	vy_index_ref(v->index);
+	v->lsm = lsm;
+	vy_lsm_ref(v->lsm);
 	v->mem = NULL;
 	v->stmt = stmt;
 	tuple_ref(stmt);
@@ -232,12 +232,12 @@ txv_delete(struct txv *v)
 	struct tx_manager *xm = v->tx->xm;
 	xm->write_set_size -= tuple_size(v->stmt);
 	tuple_unref(v->stmt);
-	vy_index_unref(v->index);
+	vy_lsm_unref(v->lsm);
 	mempool_free(&xm->txv_mempool, v);
 }
 
 static struct vy_read_interval *
-vy_read_interval_new(struct vy_tx *tx, struct vy_index *index,
+vy_read_interval_new(struct vy_tx *tx, struct vy_lsm *lsm,
 		     struct tuple *left, bool left_belongs,
 		     struct tuple *right, bool right_belongs)
 {
@@ -250,8 +250,8 @@ vy_read_interval_new(struct vy_tx *tx, struct vy_index *index,
 		return NULL;
 	}
 	interval->tx = tx;
-	vy_index_ref(index);
-	interval->index = index;
+	vy_lsm_ref(lsm);
+	interval->lsm = lsm;
 	tuple_ref(left);
 	interval->left = left;
 	interval->left_belongs = left_belongs;
@@ -272,7 +272,7 @@ vy_read_interval_delete(struct vy_read_interval *interval)
 	xm->read_set_size -= tuple_size(interval->left);
 	if (interval->left != interval->right)
 		xm->read_set_size -= tuple_size(interval->right);
-	vy_index_unref(interval->index);
+	vy_lsm_unref(interval->lsm);
 	tuple_unref(interval->left);
 	tuple_unref(interval->right);
 	mempool_free(&xm->read_interval_mempool, interval);
@@ -284,7 +284,7 @@ vy_tx_read_set_free_cb(vy_tx_read_set_t *read_set,
 {
 	(void)arg;
 	(void)read_set;
-	vy_index_read_set_remove(&interval->index->read_set, interval);
+	vy_lsm_read_set_remove(&interval->lsm->read_set, interval);
 	vy_read_interval_delete(interval);
 	return NULL;
 }
@@ -314,7 +314,7 @@ vy_tx_destroy(struct vy_tx *tx)
 
 	struct txv *v, *tmp;
 	stailq_foreach_entry_safe(v, tmp, &tx->log, next_in_log) {
-		vy_stmt_counter_unacct_tuple(&v->index->stat.txw.count,
+		vy_stmt_counter_unacct_tuple(&v->lsm->stat.txw.count,
 					     v->stmt);
 		txv_delete(v);
 	}
@@ -344,7 +344,7 @@ static int
 vy_tx_send_to_read_view(struct vy_tx *tx, struct txv *v)
 {
 	struct vy_tx_conflict_iterator it;
-	vy_tx_conflict_iterator_init(&it, &v->index->read_set, v->stmt);
+	vy_tx_conflict_iterator_init(&it, &v->lsm->read_set, v->stmt);
 	struct vy_tx *abort;
 	while ((abort = vy_tx_conflict_iterator_next(&it)) != NULL) {
 		/* Don't abort self. */
@@ -372,7 +372,7 @@ static void
 vy_tx_abort_readers(struct vy_tx *tx, struct txv *v)
 {
 	struct vy_tx_conflict_iterator it;
-	vy_tx_conflict_iterator_init(&it, &v->index->read_set, v->stmt);
+	vy_tx_conflict_iterator_init(&it, &v->lsm->read_set, v->stmt);
 	struct vy_tx *abort;
 	while ((abort = vy_tx_conflict_iterator_next(&it)) != NULL) {
 		/* Don't abort self. */
@@ -404,7 +404,7 @@ vy_tx_begin(struct tx_manager *xm)
 static int
 vy_tx_write_prepare(struct txv *v)
 {
-	struct vy_index *index = v->index;
+	struct vy_lsm *lsm = v->lsm;
 
 	/*
 	 * Allocate a new in-memory tree if either of the following
@@ -418,21 +418,21 @@ vy_tx_write_prepare(struct txv *v)
 	 *   We have to seal the tree, because we don't support mixing
 	 *   statements of different formats in the same tree.
 	 */
-	if (unlikely(index->mem->schema_version != schema_version ||
-		     index->mem->generation != *index->env->p_generation)) {
-		if (vy_index_rotate_mem(index) != 0)
+	if (unlikely(lsm->mem->schema_version != schema_version ||
+		     lsm->mem->generation != *lsm->env->p_generation)) {
+		if (vy_lsm_rotate_mem(lsm) != 0)
 			return -1;
 	}
-	vy_mem_pin(index->mem);
-	v->mem = index->mem;
+	vy_mem_pin(lsm->mem);
+	v->mem = lsm->mem;
 	return 0;
 }
 
 /**
- * Write a single statement into an index. If the statement has
+ * Write a single statement into an LSM tree. If the statement has
  * an lsregion copy then use it, else create it.
  *
- * @param index       Index to write to.
+ * @param lsm         LSM tree to write to.
  * @param mem         In-memory tree to write to.
  * @param stmt        Statement allocated with malloc().
  * @param region_stmt NULL or the same statement as stmt,
@@ -442,7 +442,7 @@ vy_tx_write_prepare(struct txv *v)
  * @retval -1 Memory error.
  */
 static int
-vy_tx_write(struct vy_index *index, struct vy_mem *mem,
+vy_tx_write(struct vy_lsm *lsm, struct vy_mem *mem,
 	    struct tuple *stmt, const struct tuple **region_stmt)
 {
 	assert(vy_stmt_is_refable(stmt));
@@ -458,7 +458,7 @@ vy_tx_write(struct vy_index *index, struct vy_mem *mem,
 	if (vy_stmt_type(stmt) == IPROTO_UPSERT) {
 		struct tuple *deleted = NULL;
 		/* Invalidate cache element. */
-		vy_cache_on_write(&index->cache, stmt, &deleted);
+		vy_cache_on_write(&lsm->cache, stmt, &deleted);
 		if (deleted != NULL) {
 			struct tuple *applied =
 				vy_apply_upsert(stmt, deleted, mem->cmp_def,
@@ -467,8 +467,8 @@ vy_tx_write(struct vy_index *index, struct vy_mem *mem,
 			tuple_unref(deleted);
 			if (applied != NULL) {
 				assert(vy_stmt_type(applied) == IPROTO_REPLACE);
-				int rc = vy_index_set(index, mem, applied,
-						      region_stmt);
+				int rc = vy_lsm_set(lsm, mem, applied,
+						    region_stmt);
 				tuple_unref(applied);
 				return rc;
 			}
@@ -479,9 +479,9 @@ vy_tx_write(struct vy_index *index, struct vy_mem *mem,
 		}
 	} else {
 		/* Invalidate cache element. */
-		vy_cache_on_write(&index->cache, stmt, NULL);
+		vy_cache_on_write(&lsm->cache, stmt, NULL);
 	}
-	return vy_index_set(index, mem, stmt, region_stmt);
+	return vy_lsm_set(lsm, mem, stmt, region_stmt);
 }
 
 int
@@ -517,21 +517,21 @@ vy_tx_prepare(struct vy_tx *tx)
 	}
 
 	/*
-	 * Flush transactional changes to the index.
+	 * Flush transactional changes to the LSM tree.
 	 * Sic: the loop below must not yield after recovery.
 	 */
 	/* repsert - REPLACE/UPSERT */
 	const struct tuple *delete = NULL, *repsert = NULL;
 	MAYBE_UNUSED uint32_t current_space_id = 0;
 	stailq_foreach_entry(v, &tx->log, next_in_log) {
-		struct vy_index *index = v->index;
-		if (index->index_id == 0) {
+		struct vy_lsm *lsm = v->lsm;
+		if (lsm->index_id == 0) {
 			/* The beginning of the new txn_stmt is met. */
-			current_space_id = index->space_id;
+			current_space_id = lsm->space_id;
 			repsert = NULL;
 			delete = NULL;
 		}
-		assert(index->space_id == current_space_id);
+		assert(lsm->space_id == current_space_id);
 
 		/* Do not save statements that was overwritten by the same tx */
 		if (v->is_overwritten)
@@ -570,7 +570,7 @@ vy_tx_prepare(struct vy_tx *tx)
 		vy_stmt_set_lsn(v->stmt, MAX_LSN + tx->psn);
 		const struct tuple **region_stmt =
 			(type == IPROTO_DELETE) ? &delete : &repsert;
-		if (vy_tx_write(index, v->mem, v->stmt, region_stmt) != 0)
+		if (vy_tx_write(lsm, v->mem, v->stmt, region_stmt) != 0)
 			return -1;
 		v->region_stmt = *region_stmt;
 	}
@@ -600,7 +600,7 @@ vy_tx_commit(struct vy_tx *tx, int64_t lsn)
 	stailq_foreach_entry(v, &tx->log, next_in_log) {
 		if (v->region_stmt != NULL) {
 			vy_stmt_set_lsn((struct tuple *)v->region_stmt, lsn);
-			vy_index_commit_stmt(v->index, v->mem, v->region_stmt);
+			vy_lsm_commit_stmt(v->lsm, v->mem, v->region_stmt);
 		}
 		if (v->mem != NULL)
 			vy_mem_unpin(v->mem);
@@ -645,8 +645,8 @@ vy_tx_rollback_after_prepare(struct vy_tx *tx)
 	struct txv *v;
 	stailq_foreach_entry(v, &tx->log, next_in_log) {
 		if (v->region_stmt != NULL)
-			vy_index_rollback_stmt(v->index, v->mem,
-					       v->region_stmt);
+			vy_lsm_rollback_stmt(v->lsm, v->mem,
+					     v->region_stmt);
 		if (v->mem != NULL)
 			vy_mem_unpin(v->mem);
 	}
@@ -699,7 +699,7 @@ vy_tx_rollback_to_savepoint(struct vy_tx *tx, void *svp)
 }
 
 int
-vy_tx_track(struct vy_tx *tx, struct vy_index *index,
+vy_tx_track(struct vy_tx *tx, struct vy_lsm *lsm,
 	    struct tuple *left, bool left_belongs,
 	    struct tuple *right, bool right_belongs)
 {
@@ -709,7 +709,7 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index,
 	}
 
 	struct vy_read_interval *new_interval;
-	new_interval = vy_read_interval_new(tx, index, left, left_belongs,
+	new_interval = vy_read_interval_new(tx, lsm, left, left_belongs,
 					    right, right_belongs);
 	if (new_interval == NULL)
 		return -1;
@@ -725,7 +725,7 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index,
 
 	struct vy_read_interval *interval;
 	interval = vy_tx_read_set_inext(&it);
-	if (interval != NULL && interval->index == index) {
+	if (interval != NULL && interval->lsm == lsm) {
 		if (vy_read_interval_cmpr(interval, new_interval) >= 0) {
 			/*
 			 * There is an interval in the tree spanning
@@ -742,13 +742,13 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index,
 		vy_tx_read_set_isearch_gt(&tx->read_set, new_interval, &it);
 
 	while ((interval = vy_tx_read_set_inext(&it)) != NULL &&
-	       interval->index == index &&
+	       interval->lsm == lsm &&
 	       vy_read_interval_should_merge(new_interval, interval))
 		stailq_add_tail_entry(&merge, interval, in_merge);
 
 	/*
 	 * Merge intersecting intervals with the new interval and
-	 * remove them from the transaction and index read sets.
+	 * remove them from the transaction and LSM tree read sets.
 	 */
 	if (!stailq_empty(&merge)) {
 		interval = stailq_first_entry(&merge, struct vy_read_interval,
@@ -771,38 +771,37 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index,
 		stailq_foreach_entry_safe(interval, next_interval, &merge,
 					  in_merge) {
 			vy_tx_read_set_remove(&tx->read_set, interval);
-			vy_index_read_set_remove(&index->read_set, interval);
+			vy_lsm_read_set_remove(&lsm->read_set, interval);
 			vy_read_interval_delete(interval);
 		}
 	}
 
 	vy_tx_read_set_insert(&tx->read_set, new_interval);
-	vy_index_read_set_insert(&index->read_set, new_interval);
+	vy_lsm_read_set_insert(&lsm->read_set, new_interval);
 	return 0;
 }
 
 int
-vy_tx_track_point(struct vy_tx *tx, struct vy_index *index,
-		  struct tuple *stmt)
+vy_tx_track_point(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt)
 {
-	assert(tuple_field_count(stmt) >= index->cmp_def->part_count);
+	assert(tuple_field_count(stmt) >= lsm->cmp_def->part_count);
 
 	if (vy_tx_is_in_read_view(tx)) {
 		/* No point in tracking reads. */
 		return 0;
 	}
 
-	struct txv *v = write_set_search_key(&tx->write_set, index, stmt);
+	struct txv *v = write_set_search_key(&tx->write_set, lsm, stmt);
 	if (v != NULL && vy_stmt_type(v->stmt) != IPROTO_UPSERT) {
 		/* Reading from own write set is serializable. */
 		return 0;
 	}
 
-	return vy_tx_track(tx, index, stmt, true, stmt, true);
+	return vy_tx_track(tx, lsm, stmt, true, stmt, true);
 }
 
 int
-vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt)
+vy_tx_set(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt)
 {
 	assert(vy_stmt_type(stmt) != 0);
 	/**
@@ -812,11 +811,10 @@ vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt)
 	vy_stmt_set_lsn(stmt, INT64_MAX);
 	struct tuple *applied = NULL;
 
-	/* Update concurrent index */
-	struct txv *old = write_set_search_key(&tx->write_set, index, stmt);
+	struct txv *old = write_set_search_key(&tx->write_set, lsm, stmt);
 	/* Found a match of the previous action of this transaction */
 	if (old != NULL && vy_stmt_type(stmt) == IPROTO_UPSERT) {
-		assert(index->index_id == 0);
+		assert(lsm->index_id == 0);
 		uint8_t old_type = vy_stmt_type(old->stmt);
 		assert(old_type == IPROTO_UPSERT ||
 		       old_type == IPROTO_INSERT ||
@@ -824,19 +822,19 @@ vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt)
 		       old_type == IPROTO_DELETE);
 		(void) old_type;
 
-		applied = vy_apply_upsert(stmt, old->stmt, index->cmp_def,
-					  index->mem_format,
-					  index->upsert_format, true);
-		index->stat.upsert.applied++;
+		applied = vy_apply_upsert(stmt, old->stmt, lsm->cmp_def,
+					  lsm->mem_format,
+					  lsm->upsert_format, true);
+		lsm->stat.upsert.applied++;
 		if (applied == NULL)
 			return -1;
 		stmt = applied;
 		assert(vy_stmt_type(stmt) != 0);
-		index->stat.upsert.squashed++;
+		lsm->stat.upsert.squashed++;
 	}
 
 	/* Allocate a MVCC container. */
-	struct txv *v = txv_new(tx, index, stmt);
+	struct txv *v = txv_new(tx, lsm, stmt);
 	if (applied != NULL)
 		tuple_unref(applied);
 	if (v == NULL)
@@ -869,7 +867,7 @@ vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt)
 	write_set_insert(&tx->write_set, v);
 	tx->write_set_version++;
 	tx->write_size += tuple_size(stmt);
-	vy_stmt_counter_acct_tuple(&index->stat.txw.count, stmt);
+	vy_stmt_counter_acct_tuple(&lsm->stat.txw.count, stmt);
 	stailq_add_tail_entry(&tx->log, v, next_in_log);
 	return 0;
 }
@@ -877,13 +875,13 @@ vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt)
 void
 vy_txw_iterator_open(struct vy_txw_iterator *itr,
 		     struct vy_txw_iterator_stat *stat,
-		     struct vy_tx *tx, struct vy_index *index,
+		     struct vy_tx *tx, struct vy_lsm *lsm,
 		     enum iterator_type iterator_type,
 		     const struct tuple *key)
 {
 	itr->stat = stat;
 	itr->tx = tx;
-	itr->index = index;
+	itr->lsm = lsm;
 	itr->iterator_type = iterator_type;
 	itr->key = key;
 	itr->version = UINT32_MAX;
@@ -904,8 +902,8 @@ vy_txw_iterator_seek(struct vy_txw_iterator *itr,
 	itr->stat->lookup++;
 	itr->version = itr->tx->write_set_version;
 	itr->curr_txv = NULL;
-	struct vy_index *index = itr->index;
-	struct write_set_key k = { index, key };
+	struct vy_lsm *lsm = itr->lsm;
+	struct write_set_key k = { lsm, key };
 	struct txv *txv;
 	if (tuple_field_count(key) > 0) {
 		if (iterator_type == ITER_EQ)
@@ -914,9 +912,9 @@ vy_txw_iterator_seek(struct vy_txw_iterator *itr,
 			txv = write_set_nsearch(&itr->tx->write_set, &k);
 		else
 			txv = write_set_psearch(&itr->tx->write_set, &k);
-		if (txv == NULL || txv->index != index)
+		if (txv == NULL || txv->lsm != lsm)
 			return;
-		if (vy_stmt_compare(key, txv->stmt, index->cmp_def) == 0) {
+		if (vy_stmt_compare(key, txv->stmt, lsm->cmp_def) == 0) {
 			while (true) {
 				struct txv *next;
 				if (iterator_type == ITER_LE ||
@@ -924,10 +922,10 @@ vy_txw_iterator_seek(struct vy_txw_iterator *itr,
 					next = write_set_next(&itr->tx->write_set, txv);
 				else
 					next = write_set_prev(&itr->tx->write_set, txv);
-				if (next == NULL || next->index != index)
+				if (next == NULL || next->lsm != lsm)
 					break;
 				if (vy_stmt_compare(key, next->stmt,
-						    index->cmp_def) != 0)
+						    lsm->cmp_def) != 0)
 					break;
 				txv = next;
 			}
@@ -942,7 +940,7 @@ vy_txw_iterator_seek(struct vy_txw_iterator *itr,
 		assert(iterator_type == ITER_GE);
 		txv = write_set_psearch(&itr->tx->write_set, &k);
 	}
-	if (txv == NULL || txv->index != index)
+	if (txv == NULL || txv->lsm != lsm)
 		return;
 	itr->curr_txv = txv;
 }
@@ -963,11 +961,11 @@ vy_txw_iterator_next(struct vy_txw_iterator *itr, struct tuple **ret)
 		itr->curr_txv = write_set_prev(&itr->tx->write_set, itr->curr_txv);
 	else
 		itr->curr_txv = write_set_next(&itr->tx->write_set, itr->curr_txv);
-	if (itr->curr_txv != NULL && itr->curr_txv->index != itr->index)
+	if (itr->curr_txv != NULL && itr->curr_txv->lsm != itr->lsm)
 		itr->curr_txv = NULL;
 	if (itr->curr_txv != NULL && itr->iterator_type == ITER_EQ &&
 	    vy_stmt_compare(itr->key, itr->curr_txv->stmt,
-			    itr->index->cmp_def) != 0)
+			    itr->lsm->cmp_def) != 0)
 		itr->curr_txv = NULL;
 out:
 	if (itr->curr_txv != NULL) {
@@ -992,7 +990,7 @@ vy_txw_iterator_skip(struct vy_txw_iterator *itr,
 	    (itr->curr_txv == NULL || last_stmt == NULL ||
 	     iterator_direction(itr->iterator_type) *
 	     vy_tuple_compare(itr->curr_txv->stmt, last_stmt,
-			      itr->index->cmp_def) > 0)) {
+			      itr->lsm->cmp_def) > 0)) {
 		if (itr->curr_txv != NULL)
 			*ret = itr->curr_txv->stmt;
 		return;
@@ -1011,7 +1009,7 @@ vy_txw_iterator_skip(struct vy_txw_iterator *itr,
 
 	if (itr->iterator_type == ITER_EQ && last_stmt != NULL &&
 	    itr->curr_txv != NULL && vy_stmt_compare(itr->key,
-			itr->curr_txv->stmt, itr->index->cmp_def) != 0)
+			itr->curr_txv->stmt, itr->lsm->cmp_def) != 0)
 		itr->curr_txv = NULL;
 
 	if (itr->curr_txv != NULL) {
@@ -1040,7 +1038,7 @@ vy_txw_iterator_restore(struct vy_txw_iterator *itr,
 
 	if (itr->iterator_type == ITER_EQ && itr->curr_txv != NULL &&
 	    vy_stmt_compare(itr->key, itr->curr_txv->stmt,
-			    itr->index->cmp_def) != 0)
+			    itr->lsm->cmp_def) != 0)
 		itr->curr_txv = NULL;
 
 	if (prev_txv == itr->curr_txv)
diff --git a/src/box/vy_tx.h b/src/box/vy_tx.h
index 33238ed7..a59145be 100644
--- a/src/box/vy_tx.h
+++ b/src/box/vy_tx.h
@@ -42,7 +42,7 @@
 #include "iterator_type.h"
 #include "salad/stailq.h"
 #include "trivia/util.h"
-#include "vy_index.h"
+#include "vy_lsm.h"
 #include "vy_stat.h"
 #include "vy_read_set.h"
 #include "vy_read_view.h"
@@ -76,8 +76,8 @@ enum tx_state {
 struct txv {
 	/** Transaction. */
 	struct vy_tx *tx;
-	/** Index this operation is for. */
-	struct vy_index *index;
+	/** LSM tree this operation is for. */
+	struct vy_lsm *lsm;
 	/** In-memory tree to insert the statement into. */
 	struct vy_mem *mem;
 	/** Statement of this operation. */
@@ -106,10 +106,10 @@ struct txv {
 
 /**
  * Index of all modifications made by a transaction.
- * Ordered by index, then by key in the index.
+ * Ordered by LSM tree, then by key.
  */
 struct write_set_key {
-	struct vy_index *index;
+	struct vy_lsm *lsm;
 	const struct tuple *stmt;
 };
 
@@ -123,10 +123,10 @@ rb_gen_ext_key(MAYBE_UNUSED static inline, write_set_, write_set_t, struct txv,
 		in_set, write_set_cmp, struct write_set_key *, write_set_key_cmp);
 
 static inline struct txv *
-write_set_search_key(write_set_t *tree, struct vy_index *index,
+write_set_search_key(write_set_t *tree, struct vy_lsm *lsm,
 		     const struct tuple *stmt)
 {
-	struct write_set_key key = { .index = index, .stmt = stmt };
+	struct write_set_key key = { .lsm = lsm, .stmt = stmt };
 	return write_set_search(tree, &key);
 }
 
@@ -141,7 +141,7 @@ struct vy_tx {
 	struct stailq log;
 	/**
 	 * Writes of the transaction segregated by the changed
-	 * vy_index object.
+	 * vy_lsm object.
 	 */
 	write_set_t write_set;
 	/**
@@ -326,7 +326,7 @@ vy_tx_rollback_to_savepoint(struct vy_tx *tx, void *svp);
  * to will be aborted.
  *
  * @param tx            Transaction that invoked the read.
- * @param index         Index that was read from.
+ * @param lsm           LSM tree that was read from.
  * @param left          Left boundary of the read interval.
  * @param left_belongs  Set if the left boundary belongs to
  *                      the interval.
@@ -338,7 +338,7 @@ vy_tx_rollback_to_savepoint(struct vy_tx *tx, void *svp);
  * @retval -1 Memory error.
  */
 int
-vy_tx_track(struct vy_tx *tx, struct vy_index *index,
+vy_tx_track(struct vy_tx *tx, struct vy_lsm *lsm,
 	    struct tuple *left, bool left_belongs,
 	    struct tuple *right, bool right_belongs);
 
@@ -346,7 +346,7 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index,
  * Remember a point read in the conflict manager index.
  *
  * @param tx    Transaction that invoked the read.
- * @param index Index that was read from.
+ * @param lsm   LSM tree that was read from.
  * @param stmt  Key that was read.
  *
  * @retval  0 Success.
@@ -359,12 +359,11 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index,
  * transaction read it from its own write set.
  */
 int
-vy_tx_track_point(struct vy_tx *tx, struct vy_index *index,
-		  struct tuple *stmt);
+vy_tx_track_point(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt);
 
 /** Add a statement to a transaction. */
 int
-vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt);
+vy_tx_set(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt);
 
 /**
  * Iterator over the write set of a transaction.
@@ -374,8 +373,8 @@ struct vy_txw_iterator {
 	struct vy_txw_iterator_stat *stat;
 	/** Transaction whose write set is iterated. */
 	struct vy_tx *tx;
-	/** Index of interest. */
-	struct vy_index *index;
+	/** LSM tree of interest. */
+	struct vy_lsm *lsm;
 	/**
 	 * Iterator type.
 	 *
@@ -399,7 +398,7 @@ struct vy_txw_iterator {
 void
 vy_txw_iterator_open(struct vy_txw_iterator *itr,
 		     struct vy_txw_iterator_stat *stat,
-		     struct vy_tx *tx, struct vy_index *index,
+		     struct vy_tx *tx, struct vy_lsm *lsm,
 		     enum iterator_type iterator_type,
 		     const struct tuple *key);
 
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
index 943788b9..7e1c95ed 100644
--- a/test/unit/CMakeLists.txt
+++ b/test/unit/CMakeLists.txt
@@ -160,7 +160,7 @@ add_executable(vy_point_lookup.test
     ${PROJECT_SOURCE_DIR}/src/box/vy_tx.c
     ${PROJECT_SOURCE_DIR}/src/box/vy_read_set.c
     ${PROJECT_SOURCE_DIR}/src/box/vy_upsert.c
-    ${PROJECT_SOURCE_DIR}/src/box/vy_index.c
+    ${PROJECT_SOURCE_DIR}/src/box/vy_lsm.c
     ${PROJECT_SOURCE_DIR}/src/box/vy_cache.c
     ${PROJECT_SOURCE_DIR}/src/box/index_def.c
     ${PROJECT_SOURCE_DIR}/src/box/schema_def.c
diff --git a/test/unit/vy_log_stub.c b/test/unit/vy_log_stub.c
index 7cfaff84..d4668408 100644
--- a/test/unit/vy_log_stub.c
+++ b/test/unit/vy_log_stub.c
@@ -51,9 +51,9 @@ vy_log_tx_commit(void)
 void
 vy_log_write(const struct vy_log_record *record) {}
 
-struct vy_index_recovery_info *
-vy_recovery_index_by_id(struct vy_recovery *recovery,
-			uint32_t space_id, uint32_t index_id)
+struct vy_lsm_recovery_info *
+vy_recovery_lsm_by_index_id(struct vy_recovery *recovery,
+			    uint32_t space_id, uint32_t index_id)
 {
 	unreachable();
 }
diff --git a/test/unit/vy_point_lookup.c b/test/unit/vy_point_lookup.c
index 30a61040..ec9b214e 100644
--- a/test/unit/vy_point_lookup.c
+++ b/test/unit/vy_point_lookup.c
@@ -1,6 +1,6 @@
 #include "trivia/util.h"
 #include "unit.h"
-#include "vy_index.h"
+#include "vy_lsm.h"
 #include "vy_cache.h"
 #include "vy_run.h"
 #include "fiber.h"
@@ -15,12 +15,12 @@ uint32_t schema_version;
 
 static int
 write_run(struct vy_run *run, const char *dir_name,
-	  struct vy_index *index, struct vy_stmt_stream *wi)
+	  struct vy_lsm *lsm, struct vy_stmt_stream *wi)
 {
 	struct vy_run_writer writer;
 	if (vy_run_writer_create(&writer, run, dir_name,
-				 index->space_id, index->index_id,
-				 index->cmp_def, index->key_def,
+				 lsm->space_id, lsm->index_id,
+				 lsm->cmp_def, lsm->key_def,
 				 4096, 0.1, 100500) != 0)
 		goto fail;
 
@@ -62,10 +62,9 @@ test_basic()
 	struct slab_cache *slab_cache = cord_slab_cache();
 
 	int rc;
-	struct vy_index_env index_env;
-	rc = vy_index_env_create(&index_env, ".", &generation,
-				 NULL, NULL);
-	is(rc, 0, "vy_index_env_create");
+	struct vy_lsm_env lsm_env;
+	rc = vy_lsm_env_create(&lsm_env, ".", &generation, NULL, NULL);
+	is(rc, 0, "vy_lsm_env_create");
 
 	struct vy_run_env run_env;
 	vy_run_env_create(&run_env);
@@ -92,14 +91,14 @@ test_basic()
 		index_def_new(512, 0, "primary", sizeof("primary") - 1, TREE,
 			      &index_opts, key_def, NULL);
 
-	struct vy_index *pk = vy_index_new(&index_env, &cache_env, &mem_env,
-					   index_def, format, NULL);
-	isnt(pk, NULL, "index is not NULL")
+	struct vy_lsm *pk = vy_lsm_new(&lsm_env, &cache_env, &mem_env,
+				       index_def, format, NULL);
+	isnt(pk, NULL, "lsm is not NULL")
 
 	struct vy_range *range = vy_range_new(1, NULL, NULL, pk->cmp_def);
 
 	isnt(pk, NULL, "range is not NULL")
-	vy_index_add_range(pk, range);
+	vy_lsm_add_range(pk, range);
 
 	struct rlist read_views = RLIST_HEAD_INITIALIZER(read_views);
 
@@ -115,7 +114,7 @@ test_basic()
 	rc = mkdir(path, 0777);
 	is(rc, 0, "temp dir create (3)");
 
-	/* Filling the index with test data */
+	/* Filling the LSM tree with test data */
 	/* Prepare variants */
 	const size_t num_of_keys = 100;
 	bool in_mem1[num_of_keys]; /* UPSERT value += 1, lsn 4 */
@@ -161,8 +160,8 @@ test_basic()
 		vy_mem_insert_template(pk->mem, &tmpl_val);
 	}
 
-	rc = vy_index_rotate_mem(pk);
-	is(rc, 0, "vy_index_rotate_mem");
+	rc = vy_lsm_rotate_mem(pk);
+	is(rc, 0, "vy_lsm_rotate_mem");
 
 	/* create first mem */
 	for (size_t i = 0; i < num_of_keys; i++) {
@@ -205,7 +204,7 @@ test_basic()
 	write_stream->iface->close(write_stream);
 	vy_mem_delete(run_mem);
 
-	vy_index_add_run(pk, run);
+	vy_lsm_add_run(pk, run);
 	struct vy_slice *slice = vy_slice_new(1, run, NULL, NULL, pk->cmp_def);
 	vy_range_add_slice(range, slice);
 	vy_run_unref(run);
@@ -240,7 +239,7 @@ test_basic()
 	write_stream->iface->close(write_stream);
 	vy_mem_delete(run_mem);
 
-	vy_index_add_run(pk, run);
+	vy_lsm_add_run(pk, run);
 	slice = vy_slice_new(1, run, NULL, NULL, pk->cmp_def);
 	vy_range_add_slice(range, slice);
 	vy_run_unref(run);
@@ -308,14 +307,14 @@ test_basic()
 	is(results_ok, true, "select results");
 	is(has_errors, false, "no errors happened");
 
-	vy_index_unref(pk);
+	vy_lsm_unref(pk);
 	index_def_delete(index_def);
 	tuple_format_unref(format);
 	vy_cache_destroy(&cache);
 	key_def_delete(key_def);
 	vy_cache_env_destroy(&cache_env);
 	vy_run_env_destroy(&run_env);
-	vy_index_env_destroy(&index_env);
+	vy_lsm_env_destroy(&lsm_env);
 
 	strcpy(path, "rm -rf ");
 	strcat(path, dir_name);
diff --git a/test/unit/vy_point_lookup.result b/test/unit/vy_point_lookup.result
index 6b8dcdef..4e68dda6 100644
--- a/test/unit/vy_point_lookup.result
+++ b/test/unit/vy_point_lookup.result
@@ -1,15 +1,15 @@
 1..1
 	*** test_basic ***
     1..15
-    ok 1 - vy_index_env_create
+    ok 1 - vy_lsm_env_create
     ok 2 - key_def is not NULL
     ok 3 - tuple_format_new is not NULL
-    ok 4 - index is not NULL
+    ok 4 - lsm is not NULL
     ok 5 - range is not NULL
     ok 6 - temp dir name is not NULL
     ok 7 - temp dir create (2)
     ok 8 - temp dir create (3)
-    ok 9 - vy_index_rotate_mem
+    ok 9 - vy_lsm_rotate_mem
     ok 10 - vy_run_new
     ok 11 - vy_run_write
     ok 12 - vy_run_new
-- 
2.11.0

^ permalink raw reply	[flat|nested] only message in thread

only message in thread, other threads:[~2018-03-23 15:50 UTC | newest]

Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-03-23 15:50 [PATCH] vinyl: rename vy_index to vy_lsm Vladimir Davydov

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox