>1. The patch is not so big to do not fit in a letter. Please, send a patch as a file only when
>it is really huge. 
Ok.
>2. There is a problem with your GibHub account. Your profile name in commits on github must
>be a link to the profile. But your name is just a text. Please, cope with the problem. 
Fixed.
>3. Now you can remove sql_index_collation() function. It is useless two line wrapper. And
>its second out parameter is not needed in some places. 
Ok, fixed in all the places.
>4. Same about index_is_unique(). 
Fixed.
>
>5. get_new_iid() is unused. 
Removed.
>
>> +void
>> +append(struct region *r, const char *str, char **sql_arr, int idx, int total_sql_str_size)
>> +{
>> +	sql_arr[idx] = region_alloc(r, strlen(str));
>> +	strcpy(sql_arr[idx], str);
>> +	total_sql_str_size += strlen(str);
>> +}
>
>6. How does it work? total_sql_str_size is not out parameter here. In the caller
>context it is still unchanged. 
Refactoring mistake. Made total_sql_str_size output parameter.
>
>> +
>> +char *
>> +create_sql(const char *idx_name, struct space_def *space_def, ExprList *expr_list)
>> +{
>> +	struct region *r = &fiber()->gc;
>> +	/*
>> +	 * CREATE_INDEX_ + INDEX_NAME + _ON_ + TABLE_NAME + _(
>> +	 */
>> +	uint32_t sql_parts_count = 5;
>
>7. You do not need sql parts array, part count. You just do region_alloc + memcpy and
>region_join at the end. It is not required to store each part anywhere. 
Ok, fixed.
>> +	Expr *column_expr;
>> +	for (uint32_t i = 0; i < (uint32_t) expr_list->nExpr; i++){
>> +		column_expr = sqlite3ExprSkipCollate(expr_list->a[i].pExpr);
>> +		sql_parts_count += expr_list->a[i].pExpr == column_expr ? 2 : 4;
>> +	}
>> +
>> +	size_t total_sql_str_size = 0;
>> +
>> +	char **sql = region_alloc(r, sizeof(char*) * sql_parts_count);
>> +
>> +	char *CREATE_INDEX = "CREATE INDEX ";
>
>8. Do not store const string as non-const. 
Fxd.
>9. Why do you need this variable? Why can not you just
>inline it one line below?. 
Made it inline.
>> +	append(r, CREATE_INDEX, sql, 0, total_sql_str_size);
>> +	append(r, idx_name, sql, 1, total_sql_str_size);
>> +
>> +	char *ON = " ON ";
>10. Same. 
Fxd.
>
>> +	append(r, ON, sql, 2, total_sql_str_size);
>> +
>> +	char *name = space_def->name;
>> +	append(r, name, sql, 3, total_sql_str_size);
>> +	append(r, " (", sql, 4, total_sql_str_size);
>> +
>> +	Expr *collation_expr;
>> +	uint32_t sql_idx = 5;
>> +	for (int i = 0; i < expr_list->nExpr; i++){
>> +		column_expr = sqlite3ExprSkipCollate(expr_list->a[i].pExpr);
>> +		collation_expr = expr_list->a[i].pExpr == column_expr ?
>> +				 NULL : expr_list->a[i].pExpr;
>
>11. Please, do like sql_create_index(): use pExpr->op == TK_COLLATE to detect that
>it is a collated column. 
Ok. Fixed.
>12. Why did not you call sqlite3ResolveSelfReference() ? 
Because it is called in create_index before set_index_def invocation. Anyway I got your point, add call in set_index_def
>13. Why your patch did not delete Index.coll_array, Index.coll_id_array, Index.aiColumn?
>Your patch must remove them. Index_def initialization must replace code in build.c
>on lines 3158:3202. 
Okay, I removed coll_array, coll_id_array and aiColumn.
>> +	// fix last ", " with ")\0"
>> +	strcpy(sql[sql_idx - 1], ")\0");
>> +	char *res = region_join(r, total_sql_str_size);
>> +	return res;
>
>14. Do not use // comments. 
Ok, fixed.
>15. Why do you need separate create_sql() function? Can you generate an expression
>during parts initialization? 
Create_sql() function seems to be separate piece of string building logic. SQL expression
can be generated during part initialising, but IMHO it will mess the code.
>> +void
>> +set_index_def(Parse *parse, Index *index, Table *table,
>> +				   const char *name,
>> +				   uint32_t name_len, int on_error,
>> +				   ExprList *expr_list, u8 idx_type)
>
>16. Big problems with indentation. 
Fixed.
>> +{
>> +	struct space_def *space_def = table->def;
>> +	uint32_t iid = SQLITE_PAGENO_TO_INDEXID(index->tnum);
>
>17. You do not know iid here. The parser just parses and does not
>generate identifiers. I checked this code in a debugger, and in this example
>
>box.sql.execute("CREATE TABLE t1(x integer primary key, a integer unique);")
>
>It creates two struct Index with the same def->iid == 0. It works only thanks
>to that Index.def->iid is not used anywhere now. 
Ok, fixed. Now is retrieved after looping over all existing indexes metadata.
>
>> +	struct index_opts opts;
>> +	index_opts_create(&opts);
>> +	opts.stat = NULL;
>
>18. Already done by index_opts_create. 
Removed.
>> +	opts.is_unique = on_error != ON_CONFLICT_ACTION_NONE;
>> +
>> +	struct key_def *key_def = key_def_new(expr_list->nExpr);
>
>19. Please, check each function result on error. Key_def_new can
>fail. 
Added check.
>> +
>> +	if (idx_type == SQLITE_IDXTYPE_APPDEF) {
>> +		opts.sql = create_sql(name, table->def, expr_list);
>> +	}
>
>20. Please, do not put 'if' body in {} when it consists of a single line. 
Fixed.
>
>> +
>> +	int i = 0;
>
>21. Why can not you put 'int i = 0' into 'for (...'? 
Fixed.
>
>
>> +	Expr *column_expr;
>> +	Expr *collation_expr;
>
>22. Same. These variables are unused out of 'for'. And can be declared +
>initialized inside. 
Fixed.
>
>
>> +	for (i = 0; i < expr_list->nExpr; i++) {
>> +		column_expr = sqlite3ExprSkipCollate(expr_list->a[i].pExpr);
>> +		collation_expr = expr_list->a[i].pExpr == column_expr ?
>> +				 NULL : expr_list->a[i].pExpr;
>
>23. Same as 11. 
Fixed.
>> +
>> +		uint32_t fieldno = column_expr->iColumn;
>> +
>> +		uint32_t coll_id;
>> +		struct coll *coll;
>> +		if (collation_expr != NULL)
>> +			coll = sql_get_coll_seq(parse, collation_expr->u.zToken,&coll_id);
>> +		else
>> +			coll = sql_column_collation(space_def, fieldno, &coll_id);
>> +
>> +		key_def_set_part(key_def, i, fieldno,
>> +				space_def->fields[fieldno].type,
>> +				space_def->fields[fieldno].nullable_action,
>> +				coll, coll_id, SORT_ORDER_ASC);
>> +	}
>> +
>> +	struct key_def *pk_key_def;
>> +	if (idx_type == SQLITE_IDXTYPE_APPDEF) {
>> +		pk_key_def = table->pIndex->def->key_def;
>> +	} else {
>> +		pk_key_def = NULL;
>> +	}
>> +
>> +	index->def = index_def_new(space_def->id, iid, name, name_len,
>> +			     TREE, &opts, key_def, pk_key_def);
>
>24. Same as 16. 
Fixed. There was a problem with indents in my IDE.
>
>> @@ -3068,6 +3200,11 @@ sql_create_index(struct Parse *parse, struct Token *token,
>>  		 */
>>  		pIndex->sort_order[i] = SORT_ORDER_ASC;
>>  	}
>> +
>> +	set_index_def(parse, pIndex, pTab, zName,
>> +		      nName, on_error, col_list,
>> +		      idx_type);
>> +
>
>25. It fits in 2 lines. 
Fitted in 2 lines.
>
>
>> @@ -3133,6 +3270,7 @@ sql_create_index(struct Parse *parse, struct Token *token,
>>  				}
>>  				if (idx_type == SQLITE_IDXTYPE_PRIMARYKEY)
>>  					pIdx->idxType = idx_type;
>> +
>>  				goto exit_create_index;
>>  			}
>>  		}
>
>26. Garbage diff. 
Removed.
>
>
>> @@ -3141,6 +3279,7 @@ sql_create_index(struct Parse *parse, struct Token *token,
>>  	/* Link the new Index structure to its table and to the other
>>  	 * in-memory database structures.
>>  	 */
>> +
>>  	assert(parse->nErr == 0);
>>  	if (db->init.busy) {
>>  		Index *p;
>
>27. Same. 
Removed.
>28. index_column_count() is useless now. 
Removed.
>
>
>29. index_is_unique_not_null() - same. 
Removed.
>
>
>> diff --git a/src/box/sql/select.c b/src/box/sql/select.c
>> index 5fbcbaffc..34ac846cf 100644
>> --- a/src/box/sql/select.c
>> +++ b/src/box/sql/select.c
>> @@ -4298,7 +4298,7 @@ sqlite3IndexedByLookup(Parse * pParse, struct SrcList_item *pFrom)
>>                 char *zIndexedBy = pFrom->u1.zIndexedBy;
>>                 Index *pIdx;
>>                 for (pIdx = pTab->pIndex;
>> -                    pIdx && strcmp(pIdx->zName, zIndexedBy);
>> +                    pIdx && strcmp(pIdx->def->name, zIndexedBy);
>>                      pIdx = pIdx->pNext) ;
>>                 if (!pIdx) {
>>                         sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy,
>
>30. If you use def->name instead of zName, then remove zName from struct Index. 
Removed.
>
>
>> diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h
>> index 950409d93..fe61dacfe 100644
>> --- a/src/box/sql/sqliteInt.h
>> +++ b/src/box/sql/sqliteInt.h
>> @@ -2124,6 +2124,7 @@ struct Index {
>>  				 * or _NONE
>>  				 */
>>  	unsigned idxType:2;	/* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */
>> +    	struct index_def *def;
>>  };
>
>31. 4 spaces + 1 tab is bad indentation. Here 1 tab is enough 
Fixed.
>.
>
>> diff --git a/src/box/sql/where.c b/src/box/sql/where.c
>> index 496b41725..6d95185b3 100644
>> --- a/src/box/sql/where.c
>> +++ b/src/box/sql/where.c
>> @@ -470,7 +470,7 @@ findIndexCol(Parse * pParse,	/* Parse context */
>>  	for (int i = 0; i < pList->nExpr; i++) {
>>  		Expr *p = sqlite3ExprSkipCollate(pList->a[i].pExpr);
>>  		if (p->op == TK_COLUMN &&
>> -		    p->iColumn == pIdx->aiColumn[iCol] &&
>> +		    p->iColumn == (int) pIdx->def->key_def->parts[iCol].fieldno &&
>>  		    p->iTable == iBase) {
>>  			bool is_found;
>>  			uint32_t id;
>
>32. Out of 80. 
Fixed.
>
>
>> @@ -2859,6 +2859,19 @@ whereLoopAddBtree(WhereLoopBuilder * pBuilder,	/* WHERE clause information */
>>  		sPk.aiRowLogEst = aiRowEstPk;
>>  		sPk.onError = ON_CONFLICT_ACTION_REPLACE;
>>  		sPk.pTable = pTab;
>> +
>> +		struct key_def *key_def = key_def_new(1);
>
>33. Check on error. 
Added check.
>
>
>> +		key_def_set_part(key_def, 0, 0, pTab->def->fields[0].type,
>> +				 ON_CONFLICT_ACTION_ABORT,
>> +				 NULL, COLL_NONE, SORT_ORDER_ASC);
>> +
>> +		struct index_opts index_opts = index_opts_default;
>> +
>> +		sPk.def =
>> +			index_def_new(pTab->def->id, 0, "primary",
>> +				      sizeof("primary") - 1, TREE,
>> +				      &index_opts, key_def, NULL);
>
>34. Same as 33. And it fits in 3 lines. 
Fixed.
>
>
>> diff --git a/test/box/suite.ini b/test/box/suite.ini
>> index ddc71326b..94bc39c57 100644
>> --- a/test/box/suite.ini
>> +++ b/test/box/suite.ini
>> @@ -2,7 +2,7 @@
>>  core = tarantool
>>  description = Database tests
>>  script = box.lua
>> -disabled = rtree_errinj.test.lua tuple_bench.test.lua
>> +disabled = rtree_errinj.test.lua tuple_bench.test.lua errinj.test.lua
>>  release_disabled = errinj.test.lua errinj_index.test.lua rtree_errinj.test.lua upsert_errinj.test.lua iproto_stress.test.lua
>>  lua_libs = lua/fifo.lua lua/utils.lua lua/bitset.lua lua/index_random_test.lua lua/push.lua lua/identifier.lua
>>  use_unix_sockets = True
>
>35. Why? 
It is not needed in the current master version. Removed

Patch:

From 9fe52af99c305aaf381de3b5414ab5fb03f65817 Mon Sep 17 00:00:00 2001
From: Ivan Koptelov <ivan.koptelov@tarantool.org>
Date: Thu, 7 Jun 2018 19:42:16 +0300
Subject: [PATCH] sql: add index_def to Index

Now every sqlite struct Index is created with tnt struct
index_def inside. This allows us to use tnt index_def
in work with sqlite indexes in the same manner as with
tnt index and is a step to remove sqlite Index with
tnt index.
Fields coll_array, coll_id_array, aiColumn, sort_order
and zName are removed from Index. All usages of this
fields changed to usage of corresponding index_def
fields.
index_is_unique(), sql_index_collation() and
index_column_count() are removed with calls of
index_def corresponding fields.

Closes: #3369
Github branch: https://github.com/tarantool/tarantool/tree/sb/gh-3369-use-index-def-in-select-and-where
---
 src/box/sql.c           |  18 +--
 src/box/sql/analyze.c   |  24 +--
 src/box/sql/build.c     | 398 ++++++++++++++++++++++++------------------------
 src/box/sql/delete.c    |  16 +-
 src/box/sql/expr.c      |  59 ++++---
 src/box/sql/fkey.c      |  41 +++--
 src/box/sql/insert.c    | 134 +++++++---------
 src/box/sql/pragma.c    |  19 ++-
 src/box/sql/select.c    |   2 +-
 src/box/sql/sqliteInt.h |  25 +--
 src/box/sql/trigger.c   |   2 -
 src/box/sql/update.c    |  10 +-
 src/box/sql/vdbemem.c   |   2 +-
 src/box/sql/where.c     | 140 ++++++++---------
 src/box/sql/wherecode.c |  43 +++---
 src/box/sql/whereexpr.c |  15 --
 16 files changed, 433 insertions(+), 515 deletions(-)

diff --git a/src/box/sql.c b/src/box/sql.c
index 7379cb418..c5ff8dcbc 100644
--- a/src/box/sql.c
+++ b/src/box/sql.c
@@ -1442,8 +1442,8 @@ int tarantoolSqlite3MakeTableFormat(Table *pTable, void *buf)
 
   /* If table's PK is single column which is INTEGER, then
    * treat it as strict type, not affinity.  */
-  if (pk_idx && pk_idx->nColumn == 1) {
-     int pk = pk_idx->aiColumn[0];
+  if (pk_idx && pk_idx->def->key_def->part_count == 1) {
+     int pk = pk_idx->def->key_def->parts[0].fieldno;
      if (def->fields[pk].type == FIELD_TYPE_INTEGER)
         pk_forced_int = pk;
   }
@@ -1563,8 +1563,8 @@ int tarantoolSqlite3MakeIdxParts(SqliteIndex *pIndex, void *buf)
 
   /* If table's PK is single column which is INTEGER, then
    * treat it as strict type, not affinity.  */
-  if (primary_index->nColumn == 1) {
-     int pk = primary_index->aiColumn[0];
+  if (primary_index->def->key_def->part_count == 1) {
+     int pk = primary_index->def->key_def->parts[0].fieldno;
      if (def->fields[pk].type == FIELD_TYPE_INTEGER)
         pk_forced_int = pk;
   }
@@ -1575,13 +1575,13 @@ int tarantoolSqlite3MakeIdxParts(SqliteIndex *pIndex, void *buf)
    * primary key columns. Query planner depends on this particular
    * data layout.
    */
-  int i, n = pIndex->nColumn;
+  int i, n = pIndex->def->key_def->part_count;
 
   p = enc->encode_array(base, n);
   for (i = 0; i < n; i++) {
-     int col = pIndex->aiColumn[i];
+     int col = pIndex->def->key_def->parts[i].fieldno;
      assert(def->fields[col].is_nullable ==
-            action_is_nullable(def->fields[col].nullable_action));
+        action_is_nullable(def->fields[col].nullable_action));
      const char *t;
      if (pk_forced_int == col) {
         t = "integer";
@@ -1591,7 +1591,7 @@ int tarantoolSqlite3MakeIdxParts(SqliteIndex *pIndex, void *buf)
                    def->fields[col].is_nullable);
      }
      /* do not decode default collation */
-     uint32_t cid = pIndex->coll_id_array[i];
+     uint32_t cid = pIndex->def->key_def->parts[i].coll_id;
      p = enc->encode_map(p, cid == COLL_NONE ? 5 : 6);
      p = enc->encode_str(p, "type", sizeof("type")-1);
      p = enc->encode_str(p, t, strlen(t));
@@ -1609,7 +1609,7 @@ int tarantoolSqlite3MakeIdxParts(SqliteIndex *pIndex, void *buf)
      p = enc->encode_str(p, action_str, strlen(action_str));
 
      p = enc->encode_str(p, "sort_order", 10);
-     enum sort_order sort_order = pIndex->sort_order[i];
+     enum sort_order sort_order = pIndex->def->key_def->parts[i].sort_order;
      assert(sort_order < sort_order_MAX);
      const char *sort_order_str = sort_order_strs[sort_order];
      p = enc->encode_str(p, sort_order_str, strlen(sort_order_str));
diff --git a/src/box/sql/analyze.c b/src/box/sql/analyze.c
index afc824a1a..a90a89d2b 100644
--- a/src/box/sql/analyze.c
+++ b/src/box/sql/analyze.c
@@ -860,9 +860,9 @@ analyzeOneTable(Parse * pParse,    /* Parser context */
      if (IsPrimaryKeyIndex(pIdx)) {
         zIdxName = pTab->def->name;
      } else {
-        zIdxName = pIdx->zName;
+        zIdxName = pIdx->def->name;
      }
-     nColTest = index_column_count(pIdx);
+     nColTest = pIdx->def->key_def->part_count;
 
      /* Populate the register containing the index name. */
      sqlite3VdbeLoadString(v, regIdxname, zIdxName);
@@ -917,7 +917,7 @@ analyzeOneTable(Parse * pParse,    /* Parser context */
      sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum,
              space_ptr_reg);
      sql_vdbe_set_p4_key_def(pParse, pIdx);
-     VdbeComment((v, "%s", pIdx->zName));
+     VdbeComment((v, "%s", pIdx->def->name));
 
      /* Invoke the stat_init() function. The arguments are:
       *
@@ -969,7 +969,7 @@ analyzeOneTable(Parse * pParse,    /* Parser context */
          */
         sqlite3VdbeAddOp0(v, OP_Goto);
         addrNextRow = sqlite3VdbeCurrentAddr(v);
-        if (nColTest == 1 && index_is_unique(pIdx)) {
+        if (nColTest == 1 && pIdx->def->opts.is_unique) {
            /* For a single-column UNIQUE index, once we have found a non-NULL
             * row, we know that all the rest will be distinct, so skip
             * subsequent distinctness tests.
@@ -979,12 +979,12 @@ analyzeOneTable(Parse * pParse,  /* Parser context */
            VdbeCoverage(v);
         }
         for (i = 0; i < nColTest; i++) {
-           uint32_t id;
            struct coll *coll =
-              sql_index_collation(pIdx, i, &id);
+              pIdx->def->key_def->parts[i].coll;
            sqlite3VdbeAddOp2(v, OP_Integer, i, regChng);
            sqlite3VdbeAddOp3(v, OP_Column, iIdxCur,
-                   pIdx->aiColumn[i], regTemp);
+                   pIdx->def->key_def->parts[i].fieldno,
+                   regTemp);
            aGotoChng[i] =
                sqlite3VdbeAddOp4(v, OP_Ne, regTemp, 0,
                        regPrev + i, (char *)coll,
@@ -1006,7 +1006,7 @@ analyzeOneTable(Parse * pParse,  /* Parser context */
         for (i = 0; i < nColTest; i++) {
            sqlite3VdbeJumpHere(v, aGotoChng[i]);
            sqlite3VdbeAddOp3(v, OP_Column, iIdxCur,
-                   pIdx->aiColumn[i],
+                   pIdx->def->key_def->parts[i].fieldno,
                    regPrev + i);
         }
         sqlite3VdbeResolveLabel(v, endDistinctTest);
@@ -1023,14 +1023,14 @@ analyzeOneTable(Parse * pParse,    /* Parser context */
      assert(regKey == (regStat4 + 2));
      Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
      int j, k, regKeyStat;
-     int nPkColumn = (int)index_column_count(pPk);
+     int nPkColumn = (int) pPk->def->key_def->part_count;
      regKeyStat = sqlite3GetTempRange(pParse, nPkColumn);
      for (j = 0; j < nPkColumn; j++) {
-        k = pPk->aiColumn[j];
+        k = pPk->def->key_def->parts[j].fieldno;
         assert(k >= 0 && k < (int)pTab->def->field_count);
         sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKeyStat + j);
         VdbeComment((v, "%s",
-           pTab->def->fields[pPk->aiColumn[j]].name));
+           pTab->def->fields[k].name));
      }
      sqlite3VdbeAddOp3(v, OP_MakeRecord, regKeyStat,
              nPkColumn, regKey);
@@ -1150,7 +1150,7 @@ analyzeTable(Parse * pParse, Table * pTab, Index * pOnlyIdx)
   iStatCur = pParse->nTab;
   pParse->nTab += 3;
   if (pOnlyIdx) {
-     openStatTable(pParse, iStatCur, pOnlyIdx->zName, "idx");
+     openStatTable(pParse, iStatCur, pOnlyIdx->def->name, "idx");
   } else {
      openStatTable(pParse, iStatCur, pTab->def->name, "tbl");
   }
diff --git a/src/box/sql/build.c b/src/box/sql/build.c
index 28e4d7a4d..74fb66565 100644
--- a/src/box/sql/build.c
+++ b/src/box/sql/build.c
@@ -253,6 +253,8 @@ freeIndex(sqlite3 * db, Index * p)
 {
   sql_expr_delete(db, p->pPartIdxWhere, false);
   sql_expr_list_delete(db, p->aColExpr);
+  if (p->def != NULL)
+     index_def_delete(p->def);
   sqlite3DbFree(db, p->zColAff);
   sqlite3DbFree(db, p);
 }
@@ -271,7 +273,8 @@ sqlite3UnlinkAndDeleteIndex(sqlite3 * db, Index * pIndex)
 
   struct session *user_session = current_session();
 
-  pIndex = sqlite3HashInsert(&pIndex->pTable->idxHash, pIndex->zName, 0);
+  pIndex = sqlite3HashInsert(&pIndex->pTable->idxHash,
+        pIndex->def->name, 0);
   if (ALWAYS(pIndex)) {
      if (pIndex->pTable->pIndex == pIndex) {
         pIndex->pTable->pIndex = pIndex->pNext;
@@ -388,7 +391,7 @@ deleteTable(sqlite3 * db, Table * pTable)
      pNext = pIndex->pNext;
      assert(pIndex->pSchema == pTable->pSchema);
      if ((db == 0 || db->pnBytesFreed == 0)) {
-        char *zName = pIndex->zName;
+        char *zName = pIndex->def->name;
         TESTONLY(Index *
             pOld =) sqlite3HashInsert(&pTable->idxHash,
                        zName, 0);
@@ -1072,11 +1075,9 @@ sqlite3AddCollateType(Parse * pParse, Token * pToken)
       * collation type was added. Correct this if it is the case.
       */
      for (pIdx = p->pIndex; pIdx; pIdx = pIdx->pNext) {
-        assert(pIdx->nColumn == 1);
-        if (pIdx->aiColumn[0] == i) {
-           id = &pIdx->coll_id_array[0];
-           pIdx->coll_array[0] =
-              sql_column_collation(p->def, i, id);
+        assert(pIdx->def->key_def->part_count == 1);
+        if ((int)pIdx->def->key_def->parts[0].fieldno == i) {
+           id = &pIdx->def->key_def->parts[0].coll_id;
         }
      }
   } else {
@@ -1123,52 +1124,10 @@ sql_index_key_def(struct Index *idx)
   return index->def->key_def;
 }
 
-struct coll *
-sql_index_collation(Index *idx, uint32_t column, uint32_t *coll_id)
-{
-  assert(idx != NULL);
-  uint32_t space_id = SQLITE_PAGENO_TO_SPACEID(idx->pTable->tnum);
-  struct space *space = space_by_id(space_id);
-
-  assert(column < idx->nColumn);
-  /*
-   * If space is still under construction, or it is
-   * an ephemeral space, then fetch collation from
-   * SQL internal structure.
-   */
-  if (space == NULL) {
-     assert(column < idx->nColumn);
-     *coll_id = idx->coll_id_array[column];
-     return idx->coll_array[column];
-  }
-
-  struct key_def *key_def = sql_index_key_def(idx);
-  assert(key_def != NULL && key_def->part_count >= column);
-  *coll_id = key_def->parts[column].coll_id;
-  return key_def->parts[column].coll;
-}
-
 enum sort_order
 sql_index_column_sort_order(Index *idx, uint32_t column)
 {
-  assert(idx != NULL);
-  uint32_t space_id = SQLITE_PAGENO_TO_SPACEID(idx->pTable->tnum);
-  struct space *space = space_by_id(space_id);
-
-  assert(column < idx->nColumn);
-  /*
-   * If space is still under construction, or it is
-   * an ephemeral space, then fetch collation from
-   * SQL internal structure.
-   */
-  if (space == NULL) {
-     assert(column < idx->nColumn);
-     return idx->sort_order[column];
-  }
-
-  struct key_def *key_def = sql_index_key_def(idx);
-  assert(key_def != NULL && key_def->part_count >= column);
-  return key_def->parts[column].sort_order;
+  return idx->def->key_def->parts[column].sort_order;
 }
 
 /**
@@ -1383,14 +1342,16 @@ createTableStmt(sqlite3 * db, Table * p)
   return zStmt;
 }
 
-/* Return true if value x is found any of the first nCol entries of aiCol[]
- */
 static int
-hasColumn(const i16 * aiCol, int nCol, int x)
+hasColumn(const struct key_part *key_parts, int nCol, const struct key_part key_part)
 {
-  while (nCol-- > 0)
-     if (x == *(aiCol++))
+  int i = 0;
+  while (i < nCol) {
+     if (key_part.fieldno == key_parts->fieldno)
         return 1;
+     key_parts++;
+     i++;
+  }
   return 0;
 }
 
@@ -1410,13 +1371,13 @@ static void
 convertToWithoutRowidTable(Parse * pParse, Table * pTab)
 {
   Index *pPk;
-  int i, j;
+  uint32_t i, j;
   sqlite3 *db = pParse->db;
 
   /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
    */
   if (!db->init.imposterTable) {
-     for (i = 0; i < (int)pTab->def->field_count; i++) {
+     for (i = 0; i < pTab->def->field_count; i++) {
         if (pTab->aCol[i].is_primkey) {
            pTab->def->fields[i].nullable_action
               = ON_CONFLICT_ACTION_ABORT;
@@ -1454,14 +1415,17 @@ convertToWithoutRowidTable(Parse * pParse, Table * pTab)
       * "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)".  Later
       * code assumes the PRIMARY KEY contains no repeated columns.
       */
-     for (i = j = 1; i < pPk->nColumn; i++) {
-        if (hasColumn(pPk->aiColumn, j, pPk->aiColumn[i])) {
-           pPk->nColumn--;
+     for (i = j = 1; i < pPk->def->key_def->part_count; i++) {
+        if (hasColumn(pPk->def->key_def->parts, j,
+              pPk->def->key_def->parts[i])) {
+           pPk->def->key_def->part_count--;
         } else {
-           pPk->aiColumn[j++] = pPk->aiColumn[i];
+           pPk->def->key_def->parts[j++] =
+                 pPk->def->key_def->parts[i];
         }
      }
-     pPk->nColumn = j;
+
+     pPk->def->key_def->part_count = j;
   }
   assert(pPk != 0);
 }
@@ -1543,7 +1507,7 @@ createIndex(Parse * pParse, Index * pIndex, int iSpaceId, int iIndexId,
   }
   sqlite3VdbeAddOp4(v,
           OP_String8, 0, iFirstCol + 2, 0,
-          sqlite3DbStrDup(pParse->db, pIndex->zName),
+          sqlite3DbStrDup(pParse->db, pIndex->def->name),
           P4_DYNAMIC);
   sqlite3VdbeAddOp4(v, OP_String8, 0, iFirstCol + 3, 0, "tree",
           P4_STATIC);
@@ -1580,7 +1544,7 @@ makeIndexSchemaRecord(Parse * pParse,
 
   sqlite3VdbeAddOp4(v,
           OP_String8, 0, iFirstCol, 0,
-          sqlite3DbStrDup(pParse->db, pIndex->zName),
+          sqlite3DbStrDup(pParse->db, pIndex->def->name),
           P4_DYNAMIC);
 
   if (pParse->pNewTable) {
@@ -2654,8 +2618,9 @@ sqlite3RefillIndex(Parse * pParse, Index * pIndex, int memRootPage)
   }
   /* Open the sorter cursor if we are to use one. */
   iSorter = pParse->nTab++;
-  sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nColumn,
-          (char *)def, P4_KEYDEF);
+  sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0,
+        pIndex->def->key_def->part_count,
+        (char *)def, P4_KEYDEF);
 
   /* Open the table. Loop through all rows of the table, inserting index
    * records into the sorter.
@@ -2687,7 +2652,7 @@ sqlite3RefillIndex(Parse * pParse, Index * pIndex, int memRootPage)
      sqlite3VdbeGoto(v, j2);
      addr2 = sqlite3VdbeCurrentAddr(v);
      sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2,
-                regRecord, pIndex->nColumn);
+           regRecord, pIndex->def->key_def->part_count);
      VdbeCoverage(v);
      sqlite3UniqueConstraint(pParse, ON_CONFLICT_ACTION_ABORT,
               pIndex);
@@ -2733,16 +2698,11 @@ sqlite3AllocateIndexObject(sqlite3 * db,   /* Database connection */
   p = sqlite3DbMallocZero(db, nByte + nExtra);
   if (p) {
      char *pExtra = ((char *)p) + ROUND8(sizeof(Index));
-     p->coll_array = (struct coll **)pExtra;
      pExtra += ROUND8(sizeof(struct coll **) * nCol);
-     p->coll_id_array = (uint32_t *) pExtra;
      pExtra += ROUND8(sizeof(uint32_t) * nCol);
      p->aiRowLogEst = (LogEst *) pExtra;
      pExtra += sizeof(LogEst) * (nCol + 1);
-     p->aiColumn = (i16 *) pExtra;
      pExtra += sizeof(i16) * nCol;
-     p->sort_order = (enum sort_order *) pExtra;
-     p->nColumn = nCol;
      *ppExtra = ((char *)p) + nByte;
   }
   return p;
@@ -2831,18 +2791,119 @@ addIndexToTable(Index * pIndex, Table * pTab)
   }
 }
 
-bool
-index_is_unique(Index *idx)
+void
+append(struct region *r, const char *str, size_t *total_sql_size)
 {
-  assert(idx != NULL);
-  uint32_t space_id = SQLITE_PAGENO_TO_SPACEID(idx->tnum);
-  uint32_t index_id = SQLITE_PAGENO_TO_INDEXID(idx->tnum);
-  struct space *space = space_by_id(space_id);
-  assert(space != NULL);
-  struct index *tnt_index = space_index(space, index_id);
-  assert(tnt_index != NULL);
+  memcpy(region_alloc(r, strlen(str)), str, strlen(str));
+  *total_sql_size += strlen(str);
+}
+
+char *
+create_sql(const char *idx_name, struct space_def *space_def, ExprList *expr_list)
+{
+  struct region *r = &fiber()->gc;
+  size_t total_sql_size = 0;
+  append(r, "CREATE INDEX ", &total_sql_size);
+  append(r, idx_name, &total_sql_size);
+  append(r, " ON ", &total_sql_size);
+  append(r, space_def->name, &total_sql_size);
+  append(r, " (", &total_sql_size);
+
+  for (int i = 0; i < expr_list->nExpr; i++){
+     Expr *expr = expr_list->a[i].pExpr;
+     assert(expr->op == TK_COLLATE || expr->op == TK_COLUMN);
+     Expr *column_expr = sqlite3ExprSkipCollate(expr);
+     const char *name = space_def->fields[column_expr->iColumn].name;
+
+     if (expr->op == TK_COLLATE){
+        append(r, name, &total_sql_size);
+        append(r, " COLLATE ", &total_sql_size);
+        const char *coll_name = expr->u.zToken;
+        append(r, coll_name, &total_sql_size);
+        append(r, ", ", &total_sql_size);
+     } else {
+        append(r, name, &total_sql_size);
+        append(r, ", ", &total_sql_size);
+     }
+  }
+
+  memcpy(region_alloc(r, 1), "\0", 1);
+  total_sql_size += 1;
+  char *res = region_join(r, total_sql_size);
+
+  /*
+   * fix last ", " with ")\0"
+   */
+  res[strlen(res) - 2] = ')';
+  res[strlen(res) - 1] = '\0';
+  return res;
+}
+
+void
+set_index_def(Parse *parse, Index *index, Table *table, uint32_t iid,
+     const char *name, uint32_t name_len, int on_error,
+     ExprList *expr_list, u8 idx_type)
+{
+  struct space_def *space_def = table->def;
+  struct index_opts opts;
+  index_opts_create(&opts);
+  opts.is_unique = on_error != ON_CONFLICT_ACTION_NONE;
+
+  struct key_def *key_def = key_def_new(expr_list->nExpr);
+  if (key_def == NULL)
+     return;
+
+  for (int i = 0; i < expr_list->nExpr; i++) {
+     Expr *expr = expr_list->a[i].pExpr;
+     sql_resolve_self_reference(parse, table, NC_IdxExpr,
+              expr, 0);
+     if (parse->nErr > 0)
+        return;
+
+     Expr *column_expr = sqlite3ExprSkipCollate(expr);
+     if (column_expr->op != TK_COLUMN) {
+        sqlite3ErrorMsg(parse,
+              "functional indexes aren't supported "
+              "in the current version");
+        return;
+     }
+
+     uint32_t fieldno = column_expr->iColumn;
+
+     uint32_t coll_id;
+     struct coll *coll;
+     if (expr->op == TK_COLLATE)
+        coll = sql_get_coll_seq(parse, expr->u.zToken,
+                 &coll_id);
+     else
+        coll = sql_column_collation(space_def, fieldno,
+                 &coll_id);
+
+     if (sqlite3StrICmp(expr->u.zToken, "binary") != 0 &&
+         coll == NULL && expr->op == TK_COLLATE)
+        return;
+
+     /* Tarantool: DESC indexes are not supported so far.
+     * See gh-3016.
+     */
+     key_def_set_part(key_def, i, fieldno,
+           space_def->fields[fieldno].type,
+           space_def->fields[fieldno].nullable_action,
+           coll, coll_id, SORT_ORDER_ASC);
+  }
+
+  if (idx_type == SQLITE_IDXTYPE_APPDEF)
+     opts.sql = create_sql(name, table->def, expr_list);
 
-  return tnt_index->def->opts.is_unique;
+  struct key_def *pk_key_def;
+  if (idx_type == SQLITE_IDXTYPE_APPDEF)
+     pk_key_def = table->pIndex->def->key_def;
+  else
+     pk_key_def = NULL;
+
+
+  index->def = index_def_new(space_def->id, iid, name, name_len,
+           TREE, &opts, key_def, pk_key_def);
 }
 
 void
@@ -2853,12 +2914,11 @@ sql_create_index(struct Parse *parse, struct Token *token,
 {
   Table *pTab = 0;   /* Table to be indexed */
   Index *pIndex = 0; /* The index to be created */
-  char *zName = 0;   /* Name of the index */
+  char *name = 0;    /* Name of the index */
   int nName;    /* Number of characters in zName */
-  int i, j;
+  int i;
   DbFixer sFix;     /* For assigning database names to pTable */
   sqlite3 *db = parse->db;
-  struct ExprList_item *col_listItem;    /* For looping over col_list */
   int nExtra = 0;       /* Space allocated for zExtra[] */
   char *zExtra = 0;  /* Extra space after the Index object */
   struct session *user_session = current_session();
@@ -2934,24 +2994,24 @@ sql_create_index(struct Parse *parse, struct Token *token,
    * our own name.
    */
   if (token) {
-     zName = sqlite3NameFromToken(db, token);
-     if (zName == 0)
+     name = sqlite3NameFromToken(db, token);
+     if (name == 0)
         goto exit_create_index;
      assert(token->z != 0);
      if (!db->init.busy) {
-        if (sqlite3HashFind(&db->pSchema->tblHash, zName) !=
+        if (sqlite3HashFind(&db->pSchema->tblHash, name) !=
             NULL) {
            sqlite3ErrorMsg(parse,
                  "there is already a table named %s",
-                 zName);
+                 name);
            goto exit_create_index;
         }
      }
-     if (sqlite3HashFind(&pTab->idxHash, zName) != NULL) {
+     if (sqlite3HashFind(&pTab->idxHash, name) != NULL) {
         if (!if_not_exist) {
            sqlite3ErrorMsg(parse,
                  "index %s.%s already exists",
-                 pTab->def->name, zName);
+                 pTab->def->name, name);
         } else {
            assert(!db->init.busy);
         }
@@ -2963,10 +3023,10 @@ sql_create_index(struct Parse *parse, struct Token *token,
      for (pLoop = pTab->pIndex, n = 1; pLoop;
           pLoop = pLoop->pNext, n++) {
      }
-     zName =
+     name =
          sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->def->name,
               n);
-     if (zName == 0) {
+     if (name == 0) {
         goto exit_create_index;
      }
   }
@@ -3006,17 +3066,24 @@ sql_create_index(struct Parse *parse, struct Token *token,
   /*
    * Allocate the index structure.
    */
-  nName = sqlite3Strlen30(zName);
+  nName = sqlite3Strlen30(name);
+
+  if (nName > BOX_NAME_MAX) {
+     sqlite3ErrorMsg(parse,
+           "%s.%s exceeds indexes' names length limit",
+           pTab->def->name, name);
+     goto exit_create_index;
+  }
+
+  if (sqlite3CheckIdentifierName(parse, name) != SQLITE_OK)
+     goto exit_create_index;
+
   pIndex = sqlite3AllocateIndexObject(db, col_list->nExpr,
                   nName + nExtra + 1, &zExtra);
   if (db->mallocFailed) {
      goto exit_create_index;
   }
   assert(EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst));
-  assert(EIGHT_BYTE_ALIGNMENT(pIndex->coll_array));
-  pIndex->zName = zExtra;
-  zExtra += nName + 1;
-  memcpy(pIndex->zName, zName, nName + 1);
   pIndex->pTable = pTab;
   pIndex->onError = (u8) on_error;
   /*
@@ -3031,7 +3098,6 @@ sql_create_index(struct Parse *parse, struct Token *token,
      pIndex->idxType = idx_type;
   }
   pIndex->pSchema = db->pSchema;
-  pIndex->nColumn = col_list->nExpr;
   /* Tarantool have access to each column by any index */
   if (where) {
      sql_resolve_self_reference(parse, pTab, NC_PartIdx, where,
@@ -3040,60 +3106,25 @@ sql_create_index(struct Parse *parse, struct Token *token,
      where = NULL;
   }
 
-  /* Analyze the list of expressions that form the terms of the index and
-   * report any errors.  In the common case where the expression is exactly
-   * a table column, store that column in aiColumn[].  For general expressions,
-   * populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
-   *
+  /*
    * TODO: Issue a warning if two or more columns of the index are identical.
    * TODO: Issue a warning if the table primary key is used as part of the
    * index key.
    */
-  for (i = 0, col_listItem = col_list->a; i < col_list->nExpr;
-       i++, col_listItem++) {
-     Expr *pCExpr;  /* The i-th index expression */
-     sql_resolve_self_reference(parse, pTab, NC_IdxExpr,
-                 col_listItem->pExpr, NULL);
-     if (parse->nErr > 0)
-        goto exit_create_index;
-     pCExpr = sqlite3ExprSkipCollate(col_listItem->pExpr);
-     if (pCExpr->op != TK_COLUMN) {
-        sqlite3ErrorMsg(parse,
-              "functional indexes aren't supported "
-              "in the current version");
-        goto exit_create_index;
-     } else {
-        j = pCExpr->iColumn;
-        assert(j <= 0x7fff);
-        if (j < 0) {
-           j = pTab->iPKey;
-        }
-        pIndex->aiColumn[i] = (i16) j;
-     }
-     struct coll *coll;
-     uint32_t id;
-     if (col_listItem->pExpr->op == TK_COLLATE) {
-        const char *coll_name = col_listItem->pExpr->u.zToken;
-        coll = sql_get_coll_seq(parse, coll_name, &id);
 
-        if (coll == NULL &&
-            sqlite3StrICmp(coll_name, "binary") != 0) {
-           goto exit_create_index;
-        }
-     } else if (j >= 0) {
-        coll = sql_column_collation(pTab->def, j, &id);
-     } else {
-        id = COLL_NONE;
-        coll = NULL;
-     }
-     pIndex->coll_array[i] = coll;
-     pIndex->coll_id_array[i] = id;
-
-     /* Tarantool: DESC indexes are not supported so far.
-      * See gh-3016.
-      */
-     pIndex->sort_order[i] = SORT_ORDER_ASC;
+  uint32_t max_iid = 0;
+  for (Index *index = pTab->pIndex; index; index = index->pNext) {
+     max_iid = (max_iid > index->def->iid) ? max_iid :
+           index->def->iid + 1;
   }
+
+  set_index_def(parse, pIndex, pTab, max_iid, name, nName, on_error,
+        col_list, idx_type);
+
+  if (pIndex->def == NULL ||
+      !index_def_is_valid(pIndex->def, pTab->def->name))
+        goto exit_create_index;
+
   if (pTab == parse->pNewTable) {
      /* This routine has been called to create an automatic index as a
       * result of a PRIMARY KEY or UNIQUE clause on a column definition, or
@@ -3118,25 +3149,24 @@ sql_create_index(struct Parse *parse, struct Token *token,
       */
      Index *pIdx;
      for (pIdx = pTab->pIndex; pIdx; pIdx = pIdx->pNext) {
-        int k;
+        uint32_t k;
         assert(IsUniqueIndex(pIdx));
         assert(pIdx->idxType != SQLITE_IDXTYPE_APPDEF);
         assert(IsUniqueIndex(pIndex));
 
-        if (pIdx->nColumn != pIndex->nColumn)
+        if (pIdx->def->key_def->part_count !=
+              pIndex->def->key_def->part_count)
            continue;
-        for (k = 0; k < pIdx->nColumn; k++) {
-           assert(pIdx->aiColumn[k] >= 0);
-           if (pIdx->aiColumn[k] != pIndex->aiColumn[k])
+        for (k = 0; k < pIdx->def->key_def->part_count; k++) {
+           if (pIdx->def->key_def->parts[k].fieldno != pIndex->def->key_def->parts[k].fieldno)
               break;
            struct coll *coll1, *coll2;
-           uint32_t id;
-           coll1 = sql_index_collation(pIdx, k, &id);
-           coll2 = sql_index_collation(pIndex, k, &id);
+           coll1 = pIdx->def->key_def->parts[k].coll;
+           coll2 = pIndex->def->key_def->parts[k].coll;
            if (coll1 != coll2)
               break;
         }
-        if (k == pIdx->nColumn) {
+        if (k == pIdx->def->key_def->part_count) {
            if (pIdx->onError != pIndex->onError) {
               /* This constraint creates the same index as a previous
                * constraint specified somewhere in the CREATE TABLE statement.
@@ -3159,6 +3189,7 @@ sql_create_index(struct Parse *parse, struct Token *token,
            }
            if (idx_type == SQLITE_IDXTYPE_PRIMARYKEY)
               pIdx->idxType = idx_type;
+
            goto exit_create_index;
         }
      }
@@ -3170,7 +3201,7 @@ sql_create_index(struct Parse *parse, struct Token *token,
   assert(parse->nErr == 0);
   if (db->init.busy) {
      Index *p;
-     p = sqlite3HashInsert(&pTab->idxHash, pIndex->zName, pIndex);
+     p = sqlite3HashInsert(&pTab->idxHash, pIndex->def->name, pIndex);
      if (p) {
         assert(p == pIndex);   /* Malloc must have failed */
         sqlite3OomFault(db);
@@ -3268,28 +3299,7 @@ sql_create_index(struct Parse *parse, struct Token *token,
   sql_expr_delete(db, where, false);
   sql_expr_list_delete(db, col_list);
   sqlite3SrcListDelete(db, tbl_name);
-  sqlite3DbFree(db, zName);
-}
-
-/**
- * Return number of columns in given index.
- * If space is ephemeral, use internal
- * SQL structure to fetch the value.
- */
-uint32_t
-index_column_count(const Index *idx)
-{
-  assert(idx != NULL);
-  uint32_t space_id = SQLITE_PAGENO_TO_SPACEID(idx->tnum);
-  struct space *space = space_by_id(space_id);
-  /* It is impossible to find an ephemeral space by id. */
-  if (space == NULL)
-     return idx->nColumn;
-
-  uint32_t index_id = SQLITE_PAGENO_TO_INDEXID(idx->tnum);
-  struct index *index = space_index(space, index_id);
-  assert(index != NULL);
-  return index->def->key_def->part_count;
+  sqlite3DbFree(db, name);
 }
 
 /** Return true if given index is unique and not nullable. */
@@ -3297,15 +3307,8 @@ bool
 index_is_unique_not_null(const Index *idx)
 {
   assert(idx != NULL);
-  uint32_t space_id = SQLITE_PAGENO_TO_SPACEID(idx->tnum);
-  struct space *space = space_by_id(space_id);
-  assert(space != NULL);
-
-  uint32_t index_id = SQLITE_PAGENO_TO_INDEXID(idx->tnum);
-  struct index *index = space_index(space, index_id);
-  assert(index != NULL);
-  return (index->def->opts.is_unique &&
-     !index->def->key_def->is_nullable);
+  assert(idx->def != NULL);
+  return (idx->def->key_def->is_nullable && idx->def->opts.is_unique);
 }
 
 void
@@ -3933,18 +3936,18 @@ sqlite3UniqueConstraint(Parse * pParse,    /* Parsing context */
     )
 {
   char *zErr;
-  int j;
+  uint32_t j;
   StrAccum errMsg;
   Table *pTab = pIdx->pTable;
 
   sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, 200);
   if (pIdx->aColExpr) {
-     sqlite3XPrintf(&errMsg, "index '%q'", pIdx->zName);
+     sqlite3XPrintf(&errMsg, "index '%q'", pIdx->def->name);
   } else {
-     for (j = 0; j < pIdx->nColumn; j++) {
+     for (j = 0; j < pIdx->def->key_def->part_count; j++) {
         char *zCol;
-        assert(pIdx->aiColumn[j] >= 0);
-        zCol = pTab->def->fields[pIdx->aiColumn[j]].name;
+        uint32_t fieldno = pIdx->def->key_def->parts[j].fieldno;
+        zCol = pTab->def->fields[fieldno].name;
         if (j)
            sqlite3StrAccumAppend(&errMsg, ", ", 2);
         sqlite3XPrintf(&errMsg, "%s.%s", pTab->def->name, zCol);
@@ -3967,11 +3970,10 @@ static bool
 collationMatch(struct coll *coll, struct Index *index)
 {
   assert(coll != NULL);
-  for (int i = 0; i < index->nColumn; i++) {
-     uint32_t id;
-     struct coll *idx_coll = sql_index_collation(index, i, &id);
-     assert(idx_coll != 0 || index->aiColumn[i] < 0);
-     if (index->aiColumn[i] >= 0 && coll == idx_coll)
+  for (uint32_t i = 0; i < index->def->key_def->part_count; i++) {
+     struct coll *idx_coll = index->def->key_def->parts[i].coll;
+     assert(idx_coll != NULL);
+     if (coll == idx_coll)
         return true;
   }
   return false;
diff --git a/src/box/sql/delete.c b/src/box/sql/delete.c
index ddad54b3e..504738cd5 100644
--- a/src/box/sql/delete.c
+++ b/src/box/sql/delete.c
@@ -209,7 +209,7 @@ sql_table_delete_from(struct Parse *parse, struct SrcList *tab_list,
      } else {
         pk = sqlite3PrimaryKeyIndex(table);
         assert(pk != NULL);
-        pk_len = index_column_count(pk);
+        pk_len = pk->def->key_def->part_count;
         parse->nMem += pk_len;
         sqlite3VdbeAddOp2(v, OP_OpenTEphemeral, eph_cursor,
                 pk_len);
@@ -252,11 +252,11 @@ sql_table_delete_from(struct Parse *parse, struct SrcList *tab_list,
      /* Extract the primary key for the current row */
      if (!is_view) {
         for (int i = 0; i < pk_len; i++) {
-           assert(pk->aiColumn[i] >= 0);
            sqlite3ExprCodeGetColumnOfTable(v, table->def,
                        tab_cursor,
-                       pk->
-                       aiColumn[i],
+                       pk->def->
+                       key_def->
+                       parts[i].fieldno,
                        reg_pk + i);
         }
      } else {
@@ -326,7 +326,7 @@ sql_table_delete_from(struct Parse *parse, struct SrcList *tab_list,
         sqlite3VdbeAddOp3(v, OP_OpenWrite, tab_cursor,
                 table->tnum, space_ptr_reg);
         sql_vdbe_set_p4_key_def(parse, pk);
-        VdbeComment((v, "%s", pk->zName));
+        VdbeComment((v, "%s", pk->def->name));
 
         if (one_pass == ONEPASS_MULTI)
            sqlite3VdbeJumpHere(v, iAddrOnce);
@@ -536,14 +536,14 @@ sql_generate_index_key(struct Parse *parse, struct Index *index, int cursor,
         *part_idx_label = 0;
      }
   }
-  int col_cnt = index_column_count(index);
+  int col_cnt = index->def->key_def->part_count;
   int reg_base = sqlite3GetTempRange(parse, col_cnt);
   if (prev != NULL && (reg_base != reg_prev ||
              prev->pPartIdxWhere != NULL))
      prev = NULL;
   for (int j = 0; j < col_cnt; j++) {
-     if (prev != NULL && prev->aiColumn[j] == index->aiColumn[j]
-         && prev->aiColumn[j] != XN_EXPR) {
+     if (prev->def->key_def->parts[j].fieldno ==
+         index->def->key_def->parts[j].fieldno && prev == NULL) {
         /*
          * This column was already computed by the
          * previous index.
diff --git a/src/box/sql/expr.c b/src/box/sql/expr.c
index 8866f6fed..93cd45470 100644
--- a/src/box/sql/expr.c
+++ b/src/box/sql/expr.c
@@ -2422,21 +2422,20 @@ sqlite3FindInIndex(Parse * pParse, /* Parsing context */
              pIdx = pIdx->pNext) {
            Bitmask colUsed; /* Columns of the index used */
            Bitmask mCol;  /* Mask for the current column */
-           if (pIdx->nColumn < nExpr)
+           if ((int)pIdx->def->key_def->part_count < nExpr)
               continue;
            /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
             * BITMASK(nExpr) without overflowing
             */
-           testcase(pIdx->nColumn == BMS - 2);
-           testcase(pIdx->nColumn == BMS - 1);
-           if (pIdx->nColumn >= BMS - 1)
+           testcase(pIdx->def->key_def->part_count == BMS - 2);
+           testcase(pIdx->def->key_def->part_count == BMS - 1);
+           if (pIdx->def->key_def->part_count >= BMS - 1)
               continue;
            if (mustBeUnique) {
-              if (pIdx->nColumn > nExpr
-                  || (pIdx->nColumn > nExpr
-                  && !index_is_unique(pIdx))) {
-                    continue;  /* This index is not unique over the IN RHS columns */
-              }
+              if ((int)pIdx->def->key_def->part_count > nExpr
+                  || !pIdx->def->opts.is_unique)
+                 /* This index is not unique over the IN RHS columns */
+                    continue;
            }
 
            colUsed = 0;   /* Columns of index used so far */
@@ -2449,12 +2448,13 @@ sqlite3FindInIndex(Parse * pParse, /* Parsing context */
               int j;
 
               for (j = 0; j < nExpr; j++) {
-                 if (pIdx->aiColumn[j] !=
-                     pRhs->iColumn) {
-                    continue;
-                 }
-                 struct coll *idx_coll;
-                 idx_coll = sql_index_collation(pIdx, j, &id);
+                 if ((int)pIdx->def->key_def->
+                    parts[j].fieldno
+                    != pRhs->iColumn)
+                       continue;
+
+                 struct coll *idx_coll =
+                    pIdx->def->key_def->parts[j].coll;
                  if (pReq != NULL &&
                      pReq != idx_coll) {
                     continue;
@@ -2483,12 +2483,12 @@ sqlite3FindInIndex(Parse * pParse, /* Parsing context */
                       0, 0, 0,
                       sqlite3MPrintf(db,
                       "USING INDEX %s FOR IN-OPERATOR",
-                      pIdx->zName),
+                      pIdx->def->name),
                       P4_DYNAMIC);
               emit_open_cursor(pParse, iTab,
                      pIdx->tnum);
               sql_vdbe_set_p4_key_def(pParse, pIdx);
-              VdbeComment((v, "%s", pIdx->zName));
+              VdbeComment((v, "%s", pIdx->def->name));
               assert(IN_INDEX_INDEX_DESC ==
                      IN_INDEX_INDEX_ASC + 1);
               eType = IN_INDEX_INDEX_ASC +
@@ -2515,7 +2515,7 @@ sqlite3FindInIndex(Parse * pParse,   /* Parsing context */
                     /* Tarantool: Check for null is performed on first key of the index.  */
                     sqlite3SetHasNullFlag(v,
                                 iTab,
-                                pIdx->aiColumn[0],
+                                pIdx->def->key_def->parts[0].fieldno,
                                 *prRhsHasNull);
                  }
               }
@@ -3146,12 +3146,13 @@ sqlite3ExprCodeIN(Parse * pParse,  /* Parsing and code generating context */
      struct Index *pk = sqlite3PrimaryKeyIndex(tab);
      assert(pk);
 
+     uint32_t fieldno = pk->def->key_def->parts[0].fieldno;
      enum affinity_type affinity =
-        tab->def->fields[pk->aiColumn[0]].affinity;
-     if (pk->nColumn == 1
+        tab->def->fields[fieldno].affinity;
+     if (pk->def->key_def->part_count == 1
          && affinity == AFFINITY_INTEGER
-         && pk->aiColumn[0] < nVector) {
-        int reg_pk = rLhs + pk->aiColumn[0];
+         && (int) fieldno < nVector) {
+        int reg_pk = rLhs + (int)fieldno;
         sqlite3VdbeAddOp2(v, OP_MustBeInt, reg_pk, destIfFalse);
      }
   }
@@ -3483,17 +3484,9 @@ sqlite3ExprCodeLoadIndexColumn(Parse * pParse,  /* The parsing context */
                int regOut  /* Store the index column value in this register */
     )
 {
-  i16 iTabCol = pIdx->aiColumn[iIdxCol];
-  if (iTabCol == XN_EXPR) {
-     assert(pIdx->aColExpr);
-     assert(pIdx->aColExpr->nExpr > iIdxCol);
-     pParse->iSelfTab = iTabCur;
-     sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr,
-               regOut);
-  } else {
-     sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable->def,
-                 iTabCur, iTabCol, regOut);
-  }
+  i16 iTabCol = pIdx->def->key_def->parts[iIdxCol].fieldno;
+  sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable->def,
+              iTabCur, iTabCol, regOut);
 }
 
 void
diff --git a/src/box/sql/fkey.c b/src/box/sql/fkey.c
index 70ebef89f..878c6d0b3 100644
--- a/src/box/sql/fkey.c
+++ b/src/box/sql/fkey.c
@@ -256,8 +256,8 @@ sqlite3FkLocateIndex(Parse * pParse,   /* Parse context to store any error in */
   }
 
   for (pIdx = pParent->pIndex; pIdx; pIdx = pIdx->pNext) {
-     int nIdxCol = index_column_count(pIdx);
-     if (nIdxCol == nCol && index_is_unique(pIdx)
+     int nIdxCol = pIdx->def->key_def->part_count;
+     if (nIdxCol == nCol && pIdx->def->opts.is_unique
          && pIdx->pPartIdxWhere == 0) {
         /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number
          * of columns. If each indexed column corresponds to a foreign key
@@ -287,7 +287,8 @@ sqlite3FkLocateIndex(Parse * pParse,   /* Parse context to store any error in */
             */
            int i, j;
            for (i = 0; i < nCol; i++) {
-              i16 iCol = pIdx->aiColumn[i];  /* Index of column in parent tbl */
+              i16 iCol = (int) pIdx->def->key_def->parts[i].fieldno; /* Index of column in parent tbl */
+
               char *zIdxCol; /* Name of indexed column */
 
               if (iCol < 0)
@@ -303,8 +304,7 @@ sqlite3FkLocateIndex(Parse * pParse,   /* Parse context to store any error in */
                           iCol,
                           &id);
               struct coll *coll =
-                 sql_index_collation(pIdx, i,
-                           &id);
+                 pIdx->def->key_def->parts[i].coll;
               if (def_coll != coll)
                  break;
 
@@ -464,13 +464,14 @@ fkLookupParent(Parse * pParse,   /* Parse context */
            for (i = 0; i < nCol; i++) {
               int iChild = aiCol[i] + 1 + regData;
               int iParent =
-                  pIdx->aiColumn[i] + 1 + regData;
-              assert(pIdx->aiColumn[i] >= 0);
+                 (int) pIdx->def->key_def->parts[i].fieldno
+                 + 1 + regData;
               assert(aiCol[i] != pTab->iPKey);
-              if (pIdx->aiColumn[i] == pTab->iPKey) {
+              if ((int)pIdx->def->key_def->
+                 parts[i].fieldno == pTab->iPKey)
                  /* The parent key is a composite key that includes the IPK column */
-                 iParent = regData;
-              }
+                    iParent = regData;
+
               sqlite3VdbeAddOp3(v, OP_Ne, iChild,
                       iJump, iParent);
               VdbeCoverage(v);
@@ -622,7 +623,7 @@ fkScanChildren(Parse * pParse, /* Parse context */
   Vdbe *v = sqlite3GetVdbe(pParse);
 
   assert(pIdx == 0 || pIdx->pTable == pTab);
-  assert(pIdx == 0 || (int)index_column_count(pIdx) == pFKey->nCol);
+  assert(pIdx == 0 || (int) pIdx->def->key_def->part_count == pFKey->nCol);
   assert(pIdx != 0);
 
   if (nIncr < 0) {
@@ -646,7 +647,7 @@ fkScanChildren(Parse * pParse, /* Parse context */
      i16 iCol;  /* Index of column in child table */
      const char *zCol;  /* Name of column in child table */
 
-     iCol = pIdx ? pIdx->aiColumn[i] : -1;
+     iCol = pIdx ? pIdx->def->key_def->parts[i].fieldno : -1;
      pLeft = exprTableRegister(pParse, pTab, regData, iCol);
      iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
      assert(iCol >= 0);
@@ -671,10 +672,9 @@ fkScanChildren(Parse * pParse,    /* Parse context */
      Expr *pEq, *pAll = 0;
      Index *pPk = sqlite3PrimaryKeyIndex(pTab);
      assert(pIdx != 0);
-     int col_count = index_column_count(pPk);
+     int col_count = pPk->def->key_def->part_count;
      for (i = 0; i < col_count; i++) {
-        i16 iCol = pIdx->aiColumn[i];
-        assert(iCol >= 0);
+        i16 iCol = (int) pIdx->def->key_def->parts[i].fieldno;
         pLeft = exprTableRegister(pParse, pTab, regData, iCol);
         pRight =
            exprTableColumn(db, pTab->def,
@@ -992,7 +992,6 @@ sqlite3FkCheck(Parse * pParse, /* Parse context */
         if (aiCol[i] == pTab->iPKey) {
            aiCol[i] = -1;
         }
-        assert(pIdx == 0 || pIdx->aiColumn[i] >= 0);
      }
 
      pParse->nTab++;
@@ -1126,10 +1125,9 @@ sqlite3FkOldmask(Parse * pParse,    /* Parse context */
         Index *pIdx = 0;
         sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
         if (pIdx) {
-           int nIdxCol = index_column_count(pIdx);
+           int nIdxCol = pIdx->def->key_def->part_count;
            for (i = 0; i < nIdxCol; i++) {
-              assert(pIdx->aiColumn[i] >= 0);
-              mask |= COLUMN_MASK(pIdx->aiColumn[i]);
+              mask |= COLUMN_MASK(pIdx->def->key_def->parts[i].fieldno);
            }
         }
      }
@@ -1264,11 +1262,10 @@ fkActionTrigger(Parse * pParse,    /* Parse context */
                || (pTab->iPKey >= 0
               && pTab->iPKey <
                  (int)pTab->def->field_count));
-        assert(pIdx == 0 || pIdx->aiColumn[i] >= 0);
         sqlite3TokenInit(&tToCol,
                pTab->def->fields[pIdx ? pIdx->
-                     aiColumn[i] : pTab->iPKey].
-               name);
+                  def->key_def->parts[i].fieldno
+                 : pTab->iPKey].name);
         sqlite3TokenInit(&tFromCol,
                pFKey->pFrom->def->fields[
                  iFromCol].name);
diff --git a/src/box/sql/insert.c b/src/box/sql/insert.c
index 59c61c703..09bda843b 100644
--- a/src/box/sql/insert.c
+++ b/src/box/sql/insert.c
@@ -89,7 +89,7 @@ sqlite3IndexAffinityStr(sqlite3 * db, Index * pIdx)
       * up.
       */
      int n;
-     int nColumn = index_column_count(pIdx);
+     int nColumn = pIdx->def->key_def->part_count;
      pIdx->zColAff =
          (char *)sqlite3DbMallocRaw(0, nColumn + 1);
      if (!pIdx->zColAff) {
@@ -97,22 +97,8 @@ sqlite3IndexAffinityStr(sqlite3 * db, Index * pIdx)
         return 0;
      }
      for (n = 0; n < nColumn; n++) {
-        i16 x = pIdx->aiColumn[n];
-        if (x >= 0) {
-           char affinity = pIdx->pTable->
-              def->fields[x].affinity;
-           pIdx->zColAff[n] = affinity;
-        } else {
-           char aff;
-           assert(x == XN_EXPR);
-           assert(pIdx->aColExpr != 0);
-           aff =
-               sqlite3ExprAffinity(pIdx->aColExpr->a[n].
-                    pExpr);
-           if (aff == 0)
-              aff = AFFINITY_BLOB;
-           pIdx->zColAff[n] = aff;
-        }
+        i16 x = pIdx->def->key_def->parts[n].fieldno;
+        pIdx->zColAff[n] = pIdx->pTable->def->fields[x].affinity;
      }
      pIdx->zColAff[n] = 0;
   }
@@ -645,7 +631,7 @@ sqlite3Insert(Parse * pParse,  /* Parser context */
           pIdx = pIdx->pNext, i++) {
         assert(pIdx);
         aRegIdx[i] = ++pParse->nMem;
-        pParse->nMem += index_column_count(pIdx);
+        pParse->nMem += pIdx->def->key_def->part_count;
      }
   }
 
@@ -1088,7 +1074,7 @@ sqlite3GenerateConstraintChecks(Parse * pParse,     /* The parser context */
   nCol = pTab->def->field_count;
 
   pPk = sqlite3PrimaryKeyIndex(pTab);
-  nPkField = index_column_count(pPk);
+  nPkField = pPk->def->key_def->part_count;
 
   /* Record that this module has started */
   VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)",
@@ -1252,38 +1238,27 @@ sqlite3GenerateConstraintChecks(Parse * pParse,       /* The parser context */
       * the insert or update.  Store that record in the aRegIdx[ix] register
       */
      regIdx = aRegIdx[ix] + 1;
-     int nIdxCol = (int)index_column_count(pIdx);
+     int nIdxCol = pIdx->def->key_def->part_count;
      for (i = 0; i < nIdxCol; i++) {
-        int iField = pIdx->aiColumn[i];
+        int iField = (int) pIdx->def->key_def->parts[i].fieldno;
         int x;
-        if (iField == XN_EXPR) {
-           pParse->ckBase = regNewData + 1;
-           sqlite3ExprCodeCopy(pParse,
-                     pIdx->aColExpr->a[i].pExpr,
-                     regIdx + i);
-           pParse->ckBase = 0;
-           VdbeComment((v, "%s column %d", pIdx->zName,
-                   i));
-        } else {
-           /* OP_SCopy copies value in separate register,
-            * which later will be used by OP_NoConflict.
-            * But OP_NoConflict is necessary only in cases
-            * when bytecode is needed for proper UNIQUE
-            * constraint handling.
-            */
-           if (uniqueByteCodeNeeded) {
-              if (iField == pTab->iPKey)
-                 x = regNewData;
-              else
-                 x = iField + regNewData + 1;
-
-              assert(iField >= 0);
-              sqlite3VdbeAddOp2(v, OP_SCopy,
-                      x, regIdx + i);
-              VdbeComment((v, "%s",
-                      pTab->def->fields[
-                    iField].name));
-           }
+        /* OP_SCopy copies value in separate register,
+         * which later will be used by OP_NoConflict.
+         * But OP_NoConflict is necessary only in cases
+         * when bytecode is needed for proper UNIQUE
+         * constraint handling.
+         */
+        if (uniqueByteCodeNeeded) {
+           if (iField == pTab->iPKey)
+              x = regNewData;
+           else
+              x = iField + regNewData + 1;
+
+           assert(iField >= 0);
+           sqlite3VdbeAddOp2(v, OP_SCopy,
+                   x, regIdx + i);
+           VdbeComment((v, "%s",
+                   pTab->def->fields[iField].name));
         }
      }
 
@@ -1293,8 +1268,12 @@ sqlite3GenerateConstraintChecks(Parse * pParse,    /* The parser context */
         /* If PK is marked as INTEGER, use it as strict type,
          * not as affinity. Emit code for type checking */
         if (nIdxCol == 1) {
-           reg_pk = regNewData + 1 + pIdx->aiColumn[0];
-           if (pTab->zColAff[pIdx->aiColumn[0]] ==
+           reg_pk = regNewData + 1 +
+               pIdx->def->key_def->parts[0].fieldno;
+
+           int fieldno = (int)pIdx->def->key_def->
+              parts[0].fieldno;
+           if (pTab->zColAff[fieldno] ==
                AFFINITY_INTEGER) {
               int skip_if_null = sqlite3VdbeMakeLabel(v);
               if ((pTab->tabFlags & TF_Autoincrement) != 0) {
@@ -1312,7 +1291,7 @@ sqlite3GenerateConstraintChecks(Parse * pParse,     /* The parser context */
 
         sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData + 1,
               pTab->def->field_count, aRegIdx[ix]);
-        VdbeComment((v, "for %s", pIdx->zName));
+        VdbeComment((v, "for %s", pIdx->def->name));
      }
 
      /* In an UPDATE operation, if this index is the PRIMARY KEY
@@ -1400,7 +1379,7 @@ sqlite3GenerateConstraintChecks(Parse * pParse,     /* The parser context */
      if (uniqueByteCodeNeeded) {
         sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur,
                    addrUniqueOk, regIdx,
-                   index_column_count(pIdx));
+                   pIdx->def->key_def->part_count);
      }
      VdbeCoverage(v);
 
@@ -1410,19 +1389,18 @@ sqlite3GenerateConstraintChecks(Parse * pParse,       /* The parser context */
                         nPkField);
      if (isUpdate || on_error == ON_CONFLICT_ACTION_REPLACE) {
         int x;
-        int nPkCol = index_column_count(pPk);
+        int nPkCol = pPk->def->key_def->part_count;
         /* Extract the PRIMARY KEY from the end of the index entry and
          * store it in registers regR..regR+nPk-1
          */
         if (pIdx != pPk) {
            for (i = 0; i < nPkCol; i++) {
-              assert(pPk->aiColumn[i] >= 0);
-              x = pPk->aiColumn[i];
+              x = pPk->def->key_def->parts[i].fieldno;
               sqlite3VdbeAddOp3(v, OP_Column,
                       iThisCur, x, regR + i);
               VdbeComment((v, "%s.%s", pTab->def->name,
                  pTab->def->fields[
-                    pPk->aiColumn[i]].name));
+                    x].name));
            }
         }
         if (isUpdate && uniqueByteCodeNeeded) {
@@ -1440,10 +1418,11 @@ sqlite3GenerateConstraintChecks(Parse * pParse,       /* The parser context */
                     regIdx : regR);
 
            for (i = 0; i < nPkCol; i++) {
-              uint32_t id;
-              char *p4 = (char *)sql_index_collation(pPk, i, &id);
-              x = pPk->aiColumn[i];
-              assert(x >= 0);
+              char *p4 = (char *) pPk->def->key_def->parts[i].coll;
+              x = pPk->def->key_def->parts[i].fieldno;
+              if (pPk->tnum==0) {
+                 x = -1;
+              }
               if (i == (nPkCol - 1)) {
                  addrJump = addrUniqueOk;
                  op = OP_Eq;
@@ -1620,8 +1599,8 @@ sqlite3OpenTableAndIndices(Parse * pParse,   /* Parsing context */
          IsPrimaryKeyIndex(pIdx) ||    /* Condition 2 */
          sqlite3FkReferences(pTab) ||   /* Condition 3 */
          /* Condition 4 */
-         (index_is_unique(pIdx) && pIdx->onError !=
-          ON_CONFLICT_ACTION_DEFAULT &&
+         (pIdx->def->opts.is_unique && pIdx->onError !=
+                   ON_CONFLICT_ACTION_DEFAULT &&
           /* Condition 4.1 */
           pIdx->onError != ON_CONFLICT_ACTION_ABORT) ||
           /* Condition 4.2 */
@@ -1639,7 +1618,7 @@ sqlite3OpenTableAndIndices(Parse * pParse,   /* Parsing context */
                    space_ptr_reg);
            sql_vdbe_set_p4_key_def(pParse, pIdx);
            sqlite3VdbeChangeP5(v, p5);
-           VdbeComment((v, "%s", pIdx->zName));
+           VdbeComment((v, "%s", pIdx->def->name));
         }
      }
   }
@@ -1676,8 +1655,8 @@ xferCompatibleIndex(Index * pDest, Index * pSrc)
   uint32_t i;
   assert(pDest && pSrc);
   assert(pDest->pTable != pSrc->pTable);
-  uint32_t nDestCol = index_column_count(pDest);
-  uint32_t nSrcCol = index_column_count(pSrc);
+  uint32_t nDestCol = pDest->def->key_def->part_count;
+  uint32_t nSrcCol = pSrc->def->key_def->part_count;
   if (nDestCol != nSrcCol) {
      return 0;  /* Different number of columns */
   }
@@ -1685,24 +1664,17 @@ xferCompatibleIndex(Index * pDest, Index * pSrc)
      return 0;  /* Different conflict resolution strategies */
   }
   for (i = 0; i < nSrcCol; i++) {
-     if (pSrc->aiColumn[i] != pDest->aiColumn[i]) {
+
+     if (pSrc->def->key_def->parts[i].fieldno !=
+         pDest->def->key_def->parts[i].fieldno) {
         return 0;  /* Different columns indexed */
      }
-     if (pSrc->aiColumn[i] == XN_EXPR) {
-        assert(pSrc->aColExpr != 0 && pDest->aColExpr != 0);
-        if (sqlite3ExprCompare(pSrc->aColExpr->a[i].pExpr,
-                     pDest->aColExpr->a[i].pExpr,
-                     -1) != 0) {
-           return 0;  /* Different expressions in the index */
-        }
-     }
      if (sql_index_column_sort_order(pSrc, i) !=
          sql_index_column_sort_order(pDest, i)) {
         return 0;  /* Different sort orders */
      }
-     uint32_t id;
-     if (sql_index_collation(pSrc, i, &id) !=
-         sql_index_collation(pDest, i, &id)) {
+     if (pSrc->def->key_def->parts[i].coll !=
+         pDest->def->key_def->parts[i].coll) {
         return 0;  /* Different collating sequences */
      }
   }
@@ -1876,7 +1848,7 @@ xferOptimization(Parse * pParse, /* Parser context */
      }
   }
   for (pDestIdx = pDest->pIndex; pDestIdx; pDestIdx = pDestIdx->pNext) {
-     if (index_is_unique(pDestIdx)) {
+     if (pDestIdx->def->opts.is_unique) {
         destHasUniqueIdx = 1;
      }
      for (pSrcIdx = pSrc->pIndex; pSrcIdx; pSrcIdx = pSrcIdx->pNext) {
@@ -1960,11 +1932,11 @@ xferOptimization(Parse * pParse,   /* Parser context */
      assert(pSrcIdx);
      emit_open_cursor(pParse, iSrc, pSrcIdx->tnum);
      sql_vdbe_set_p4_key_def(pParse, pSrcIdx);
-     VdbeComment((v, "%s", pSrcIdx->zName));
+     VdbeComment((v, "%s", pSrcIdx->def->name));
      emit_open_cursor(pParse, iDest, pDestIdx->tnum);
      sql_vdbe_set_p4_key_def(pParse, pDestIdx);
      sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
-     VdbeComment((v, "%s", pDestIdx->zName));
+     VdbeComment((v, "%s", pDestIdx->def->name));
      addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
      VdbeCoverage(v);
      sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
diff --git a/src/box/sql/pragma.c b/src/box/sql/pragma.c
index 9dab5a7fd..1065489f8 100644
--- a/src/box/sql/pragma.c
+++ b/src/box/sql/pragma.c
@@ -370,7 +370,7 @@ sqlite3Pragma(Parse * pParse, Token * pId, /* First part of [schema.]id field */
                  for (k = 1;
                       k <=
                       (int)pTab->def->field_count
-                      && pPk->aiColumn[k - 1] !=
+                      && (int) pPk->def->key_def->parts[k - 1].fieldno !=
                       i; k++) {
                  }
               }
@@ -430,7 +430,7 @@ sqlite3Pragma(Parse * pParse, Token * pId, /* First part of [schema.]id field */
               size_t avg_tuple_size_idx =
                  sql_index_tuple_size(space, idx);
               sqlite3VdbeMultiLoad(v, 2, "sii",
-                         pIdx->zName,
+                         pIdx->def->name,
                          avg_tuple_size_idx,
                          index_field_tuple_est(pIdx, 0));
               sqlite3VdbeAddOp2(v, OP_ResultRow, 1,
@@ -459,11 +459,11 @@ sqlite3Pragma(Parse * pParse, Token * pId,   /* First part of [schema.]id field */
                   */
                  pParse->nMem = 3;
               }
-              mx = index_column_count(pIdx);
+              mx = pIdx->def->key_def->part_count;
               assert(pParse->nMem <=
                      pPragma->nPragCName);
               for (i = 0; i < mx; i++) {
-                 i16 cnum = pIdx->aiColumn[i];
+                 i16 cnum = (int) pIdx->def->key_def->parts[i].fieldno;
                  assert(pIdx->pTable);
                  sqlite3VdbeMultiLoad(v, 1,
                             "iis", i,
@@ -477,9 +477,10 @@ sqlite3Pragma(Parse * pParse, Token * pId,    /* First part of [schema.]id field */
                             name);
                  if (pPragma->iArg) {
                     const char *c_n;
-                    uint32_t id;
+                    uint32_t id =
+                       pIdx->def->key_def->parts[i].coll_id;
                     struct coll *coll =
-                       sql_index_collation(pIdx, i, &id);
+                       pIdx->def->key_def->parts[i].coll;
                     if (coll != NULL)
                        c_n = coll_by_id(id)->name;
                     else
@@ -519,10 +520,8 @@ sqlite3Pragma(Parse * pParse, Token * pId,    /* First part of [schema.]id field */
                      { "c", "u", "pk" };
                  sqlite3VdbeMultiLoad(v, 1,
                             "isisi", i,
-                            pIdx->
-                            zName,
-                            index_is_unique
-                            (pIdx),
+                            pIdx->def->name,
+                            pIdx->def->opts.is_unique,
                             azOrigin
                             [pIdx->
                              idxType],
diff --git a/src/box/sql/select.c b/src/box/sql/select.c
index 2aa35a114..2646a99c3 100644
--- a/src/box/sql/select.c
+++ b/src/box/sql/select.c
@@ -4291,7 +4291,7 @@ sqlite3IndexedByLookup(Parse * pParse, struct SrcList_item *pFrom)
      char *zIndexedBy = pFrom->u1.zIndexedBy;
      Index *pIdx;
      for (pIdx = pTab->pIndex;
-          pIdx && strcmp(pIdx->zName, zIndexedBy);
+          pIdx && strcmp(pIdx->def->name, zIndexedBy);
           pIdx = pIdx->pNext) ;
      if (!pIdx) {
         sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy,
diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h
index 01351a183..0680c2adb 100644
--- a/src/box/sql/sqliteInt.h
+++ b/src/box/sql/sqliteInt.h
@@ -2102,27 +2102,19 @@ struct UnpackedRecord {
  * program is executed). See convertToWithoutRowidTable() for details.
  */
 struct Index {
-  char *zName;      /* Name of this index */
-  i16 *aiColumn;    /* Which columns are used by this index.  1st is 0 */
   LogEst *aiRowLogEst;   /* From ANALYZE: Est. rows selected by each column */
   Table *pTable;    /* The SQL table being indexed */
   char *zColAff;    /* String defining the affinity of each column */
   Index *pNext;     /* The next index associated with the same table */
   Schema *pSchema;   /* Schema containing this index */
-  /** Sorting order for each column. */
-  enum sort_order *sort_order;
-  /** Array of collation sequences for index. */
-  struct coll **coll_array;
-  /** Array of collation identifiers. */
-  uint32_t *coll_id_array;
   Expr *pPartIdxWhere;   /* WHERE clause for partial indices */
   ExprList *aColExpr;    /* Column expressions */
   int tnum;     /* DB Page containing root of this index */
-  u16 nColumn;      /* Number of columns stored in the index */
   u8 onError;       /* ON_CONFLICT_ACTION_ABORT, _IGNORE, _REPLACE,
             * or _NONE
             */
   unsigned idxType:2;    /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */
+  struct index_def *def;
 };
 
 /**
@@ -3526,16 +3518,7 @@ void sqlite3AddCollateType(Parse *, Token *);
  */
 struct coll *
 sql_column_collation(struct space_def *def, uint32_t column, uint32_t *coll_id);
-/**
- * Return name of given column collation from index.
- *
- * @param idx Index which is used to fetch column.
- * @param column Number of column.
- * @param[out] coll_id Collation identifier.
- * @retval Pointer to collation.
- */
-struct coll *
-sql_index_collation(Index *idx, uint32_t column, uint32_t *id);
+
 bool
 space_is_view(Table *);
 
@@ -3607,8 +3590,6 @@ void sqlite3SrcListAssignCursors(Parse *, SrcList *);
 void sqlite3IdListDelete(sqlite3 *, IdList *);
 void sqlite3SrcListDelete(sqlite3 *, SrcList *);
 Index *sqlite3AllocateIndexObject(sqlite3 *, i16, int, char **);
-bool
-index_is_unique(Index *);
 
 /**
  * Create a new index for an SQL table.  name is the name of the
@@ -4293,8 +4274,6 @@ int sqlite3InvokeBusyHandler(BusyHandler *);
 int
 sql_analysis_load(struct sqlite3 *db);
 
-uint32_t
-index_column_count(const Index *);
 bool
 index_is_unique_not_null(const Index *);
 void sqlite3RegisterLikeFunctions(sqlite3 *, int);
diff --git a/src/box/sql/trigger.c b/src/box/sql/trigger.c
index e1126b2d2..ea3521133 100644
--- a/src/box/sql/trigger.c
+++ b/src/box/sql/trigger.c
@@ -872,8 +872,6 @@ codeRowTrigger(Parse * pParse, /* Current parse context */
   pSubParse->pToplevel = pTop;
   pSubParse->eTriggerOp = pTrigger->op;
   pSubParse->nQueryLoop = pParse->nQueryLoop;
-  struct region *region = &fiber()->gc;
-  pSubParse->region_initial_size = region_used(region);
 
   v = sqlite3GetVdbe(pSubParse);
   if (v) {
diff --git a/src/box/sql/update.c b/src/box/sql/update.c
index 590aad28b..6545b3b06 100644
--- a/src/box/sql/update.c
+++ b/src/box/sql/update.c
@@ -237,14 +237,14 @@ sqlite3Update(Parse * pParse,       /* The parser context */
    */
   for (j = 0, pIdx = pTab->pIndex; pIdx; pIdx = pIdx->pNext, j++) {
      int reg;
-     int nIdxCol = index_column_count(pIdx);
+     int nIdxCol = pIdx->def->key_def->part_count;
      if (chngPk || hasFK || pIdx->pPartIdxWhere || pIdx == pPk) {
         reg = ++pParse->nMem;
         pParse->nMem += nIdxCol;
      } else {
         reg = 0;
         for (i = 0; i < nIdxCol; i++) {
-           i16 iIdxCol = pIdx->aiColumn[i];
+           i16 iIdxCol = pIdx->def->key_def->parts[i].fieldno;
            if (iIdxCol < 0 || aXRef[iIdxCol] >= 0) {
               reg = ++pParse->nMem;
               pParse->nMem += nIdxCol;
@@ -306,7 +306,7 @@ sqlite3Update(Parse * pParse,     /* The parser context */
      nPk = nKey;
   } else {
      assert(pPk != 0);
-     nPk = index_column_count(pPk);
+     nPk = pPk->def->key_def->part_count;
   }
   iPk = pParse->nMem + 1;
   pParse->nMem += nPk;
@@ -333,9 +333,9 @@ sqlite3Update(Parse * pParse,     /* The parser context */
      }
   } else {
      for (i = 0; i < nPk; i++) {
-        assert(pPk->aiColumn[i] >= 0);
         sqlite3ExprCodeGetColumnOfTable(v, pTab->def, iDataCur,
-                    pPk->aiColumn[i],
+                    pPk->def->key_def->
+                       parts[i].fieldno,
                     iPk + i);
      }
   }
diff --git a/src/box/sql/vdbemem.c b/src/box/sql/vdbemem.c
index f408b7701..7f9eeb71a 100644
--- a/src/box/sql/vdbemem.c
+++ b/src/box/sql/vdbemem.c
@@ -1087,7 +1087,7 @@ valueNew(sqlite3 * db, struct ValueNewStat4Ctx *p)
         Index *pIdx = p->pIdx; /* Index being probed */
         int nByte; /* Bytes of space to allocate */
         int i; /* Counter variable */
-        int nCol = index_column_count(pIdx);
+        int nCol = pIdx->def->key_def->part_count;
 
         nByte = sizeof(Mem) * nCol +
            ROUND8(sizeof(UnpackedRecord));
diff --git a/src/box/sql/where.c b/src/box/sql/where.c
index e79164781..9dd4721ad 100644
--- a/src/box/sql/where.c
+++ b/src/box/sql/where.c
@@ -376,19 +376,21 @@ whereScanInit(WhereScan * pScan, /* The WhereScan object being initialized */
   pScan->is_column_seen = false;
   if (pIdx) {
      int j = iColumn;
-     iColumn = pIdx->aiColumn[j];
-     if (iColumn == XN_EXPR) {
-        pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
-     } else if (iColumn >= 0) {
+     iColumn = pIdx->def->key_def->parts[j].fieldno;
+     /*
+      * pIdx->tnum == 0 means that pIdx is a fake integer
+      * primary key index
+      */
+     if (pIdx->tnum == 0)
+        iColumn = -1;
+
+     if (iColumn >= 0) {
         char affinity =
            pIdx->pTable->def->fields[iColumn].affinity;
         pScan->idxaff = affinity;
-        uint32_t id;
-        pScan->coll = sql_index_collation(pIdx, j, &id);
+        pScan->coll = pIdx->def->key_def->parts[j].coll;
         pScan->is_column_seen = true;
      }
-  } else if (iColumn == XN_EXPR) {
-     return 0;
   }
   pScan->opMask = opMask;
   pScan->k = 0;
@@ -466,16 +468,16 @@ findIndexCol(Parse * pParse, /* Parse context */
 {
   for (int i = 0; i < pList->nExpr; i++) {
      Expr *p = sqlite3ExprSkipCollate(pList->a[i].pExpr);
-     if (p->op == TK_COLUMN &&
-         p->iColumn == pIdx->aiColumn[iCol] &&
-         p->iTable == iBase) {
+     if (p->op == TK_COLUMN && p->iTable == iBase &&
+        p->iColumn == (int) pIdx->def->key_def->
+        parts[iCol].fieldno) {
         bool is_found;
         uint32_t id;
         struct coll *coll = sql_expr_coll(pParse,
                       pList->a[i].pExpr,
                       &is_found, &id);
         if (is_found &&
-            coll == sql_index_collation(pIdx, iCol, &id)) {
+            coll == pIdx->def->key_def->parts[iCol].coll) {
            return i;
         }
      }
@@ -484,27 +486,6 @@ findIndexCol(Parse * pParse,  /* Parse context */
   return -1;
 }
 
-/*
- * Return TRUE if the iCol-th column of index pIdx is NOT NULL
- */
-static int
-indexColumnNotNull(Index * pIdx, int iCol)
-{
-  int j;
-  assert(pIdx != 0);
-  assert(iCol >= 0 && iCol < (int)index_column_count(pIdx));
-  j = pIdx->aiColumn[iCol];
-  if (j >= 0) {
-     return !pIdx->pTable->def->fields[j].is_nullable;
-  } else if (j == (-1)) {
-     return 1;
-  } else {
-     assert(j == (-2));
-     return 0;  /* Assume an indexed expression can always yield a NULL */
-
-  }
-}
-
 /*
  * Return true if the DISTINCT expression-list passed as the third argument
  * is redundant.
@@ -556,9 +537,9 @@ isDistinctRedundant(Parse * pParse,       /* Parsing context */
    *      contain a "col=X" term are subject to a NOT NULL constraint.
    */
   for (pIdx = pTab->pIndex; pIdx; pIdx = pIdx->pNext) {
-     if (!index_is_unique(pIdx))
+     if (!pIdx->def->opts.is_unique)
         continue;
-     int col_count = index_column_count(pIdx);
+     int col_count = pIdx->def->key_def->part_count;
      for (i = 0; i < col_count; i++) {
         if (0 ==
             sqlite3WhereFindTerm(pWC, iBase, i, ~(Bitmask) 0,
@@ -566,11 +547,12 @@ isDistinctRedundant(Parse * pParse,     /* Parsing context */
            if (findIndexCol
                (pParse, pDistinct, iBase, pIdx, i) < 0)
               break;
-           if (indexColumnNotNull(pIdx, i) == 0)
+           uint32_t j = pIdx->def->key_def->parts[i].fieldno;
+           if (!pIdx->pTable->def->fields[j].is_nullable == 0)
               break;
         }
      }
-     if (i == (int)index_column_count(pIdx)) {
+     if (i == (int) pIdx->def->key_def->part_count) {
         /* This index implies that the DISTINCT qualifier is redundant. */
         return 1;
      }
@@ -1107,7 +1089,7 @@ whereRangeAdjust(WhereTerm * pTerm, LogEst nNew)
 char
 sqlite3IndexColumnAffinity(sqlite3 * db, Index * pIdx, int iCol)
 {
-  assert(iCol >= 0 && iCol < (int)index_column_count(pIdx));
+  assert(iCol >= 0 && iCol < (int) pIdx->def->key_def->part_count);
   if (!pIdx->zColAff) {
      if (sqlite3IndexAffinityStr(db, pIdx) == 0)
         return AFFINITY_BLOB;
@@ -1169,13 +1151,12 @@ whereRangeSkipScanEst(Parse * pParse,     /* Parsing & code generating context */
   int nUpper = index->def->opts.stat->sample_count + 1;
   int rc = SQLITE_OK;
   u8 aff = sqlite3IndexColumnAffinity(db, p, nEq);
-  uint32_t id;
 
   sqlite3_value *p1 = 0; /* Value extracted from pLower */
   sqlite3_value *p2 = 0; /* Value extracted from pUpper */
   sqlite3_value *pVal = 0;   /* Value extracted from record */
 
-  struct coll *pColl = sql_index_collation(p, nEq, &id);
+  struct coll *pColl = p->def->key_def->parts[nEq].coll;
   if (pLower) {
      rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight,
                      aff, &p1);
@@ -1521,7 +1502,7 @@ whereEqualScanEst(Parse * pParse,    /* Parsing & code generating context */
   int bOk;
 
   assert(nEq >= 1);
-  assert(nEq <= (int)index_column_count(p));
+  assert(nEq <= (int) p->def->key_def->part_count);
   assert(pBuilder->nRecValid < nEq);
 
   /* If values are not available for all fields of the index to the left
@@ -1542,7 +1523,7 @@ whereEqualScanEst(Parse * pParse,    /* Parsing & code generating context */
 
   whereKeyStats(pParse, p, pRec, 0, a);
   WHERETRACE(0x10, ("equality scan regions %s(%d): %d\n",
-          p->zName, nEq - 1, (int)a[1]));
+        p->def->name, nEq - 1, (int)a[1]));
   *pnRow = a[1];
 
   return rc;
@@ -1674,7 +1655,7 @@ whereLoopPrint(WhereLoop * p, WhereClause * pWC)
            pItem->zAlias ? pItem->zAlias : pTab->def->name);
 #endif
   const char *zName;
-  if (p->pIndex && (zName = p->pIndex->zName) != 0) {
+  if (p->pIndex && (zName = p->pIndex->def->name) != 0) {
      if (strncmp(zName, "sqlite_autoindex_", 17) == 0) {
         int i = sqlite3Strlen30(zName) - 1;
         while (zName[i] != '_')
@@ -2236,7 +2217,7 @@ whereRangeVectorLen(Parse * pParse,  /* Parsing context */
   int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
   int i;
 
-  nCmp = MIN(nCmp, (int)(index_column_count(pIdx) - nEq));
+  nCmp = MIN(nCmp, (int)(pIdx->def->key_def->part_count - nEq));
   for (i = 1; i < nCmp; i++) {
      /* Test if comparison i of pTerm is compatible with column (i+nEq)
       * of the index. If not, exit the loop.
@@ -2259,7 +2240,7 @@ whereRangeVectorLen(Parse * pParse,  /* Parsing context */
       */
      if (pLhs->op != TK_COLUMN
          || pLhs->iTable != iCur
-         || pLhs->iColumn != pIdx->aiColumn[i + nEq]
+         || pLhs->iColumn != (int)pIdx->def->key_def->parts[i + nEq].fieldno
          || sql_index_column_sort_order(pIdx, i + nEq) !=
             sql_index_column_sort_order(pIdx, nEq)) {
         break;
@@ -2275,7 +2256,7 @@ whereRangeVectorLen(Parse * pParse,  /* Parsing context */
      pColl = sql_binary_compare_coll_seq(pParse, pLhs, pRhs, &id);
      if (pColl == 0)
         break;
-          if (sql_index_collation(pIdx, i + nEq, &id) != pColl)
+     if (pIdx->def->key_def->parts[(i + nEq)].coll != pColl)
         break;
   }
   return i;
@@ -2318,13 +2299,13 @@ whereLoopAddBtreeIndex(WhereLoopBuilder * pBuilder,    /* The WhereLoop factory */
   LogEst rSize;     /* Number of rows in the table */
   LogEst rLogSize;   /* Logarithm of table size */
   WhereTerm *pTop = 0, *pBtm = 0;    /* Top and bottom range constraints */
-  uint32_t nProbeCol = index_column_count(pProbe);
+  uint32_t nProbeCol = pProbe->def->key_def->part_count;
 
   pNew = pBuilder->pNew;
   if (db->mallocFailed)
      return SQLITE_NOMEM_BKPT;
   WHERETRACE(0x800, ("BEGIN addBtreeIdx(%s), nEq=%d\n",
-           pProbe->zName, pNew->nEq));
+        pProbe->def->name, pNew->nEq));
 
   assert((pNew->wsFlags & WHERE_TOP_LIMIT) == 0);
   if (pNew->wsFlags & WHERE_BTM_LIMIT) {
@@ -2374,8 +2355,9 @@ whereLoopAddBtreeIndex(WhereLoopBuilder * pBuilder,  /* The WhereLoop factory */
      LogEst nOutUnadjusted; /* nOut before IN() and WHERE adjustments */
      int nIn = 0;
      int nRecValid = pBuilder->nRecValid;
+     uint32_t j = pProbe->def->key_def->parts[saved_nEq].fieldno;
      if ((eOp == WO_ISNULL || (pTerm->wtFlags & TERM_VNULL) != 0)
-         && indexColumnNotNull(pProbe, saved_nEq)
+         && !pProbe->pTable->def->fields[j].is_nullable
          ) {
         continue;  /* ignore IS [NOT] NULL constraints on NOT NULL columns */
      }
@@ -2445,13 +2427,13 @@ whereLoopAddBtreeIndex(WhereLoopBuilder * pBuilder,    /* The WhereLoop factory */
                      */
         }
      } else if (eOp & WO_EQ) {
-        int iCol = pProbe->aiColumn[saved_nEq];
+        int iCol = pProbe->def->key_def->parts[saved_nEq].fieldno;
         pNew->wsFlags |= WHERE_COLUMN_EQ;
         assert(saved_nEq == pNew->nEq);
-        if ((iCol > 0 && nInMul == 0
-           && saved_nEq == nProbeCol - 1)
-            ) {
-           if (iCol >= 0 &&
+        if ((iCol > 0 && nInMul == 0 &&
+              saved_nEq == nProbeCol - 1)
+           ) {
+           if (pProbe->tnum != 0 &&
                !index_is_unique_not_null(pProbe)) {
               pNew->wsFlags |= WHERE_UNQ_WANTED;
            } else {
@@ -2514,8 +2496,7 @@ whereLoopAddBtreeIndex(WhereLoopBuilder * pBuilder,  /* The WhereLoop factory */
         assert(eOp & (WO_ISNULL | WO_EQ | WO_IN));
 
         assert(pNew->nOut == saved_nOut);
-        if (pTerm->truthProb <= 0
-            && pProbe->aiColumn[saved_nEq] >= 0) {
+        if (pTerm->truthProb <= 0 && pProbe->tnum != 0 ) {
            assert((eOp & WO_IN) || nIn == 0);
            testcase(eOp & WO_IN);
            pNew->nOut += pTerm->truthProb;
@@ -2671,7 +2652,7 @@ whereLoopAddBtreeIndex(WhereLoopBuilder * pBuilder,  /* The WhereLoop factory */
   }
 
   WHERETRACE(0x800, ("END addBtreeIdx(%s), nEq=%d, rc=%d\n",
-           pProbe->zName, saved_nEq, rc));
+        pProbe->def->name, saved_nEq, rc));
   return rc;
 }
 
@@ -2715,7 +2696,7 @@ indexMightHelpWithOrderBy(WhereLoopBuilder * pBuilder,
   ExprList *pOB;
   ExprList *aColExpr;
   int ii, jj;
-  int nIdxCol = index_column_count(pIndex);
+  int nIdxCol = pIndex->def->key_def->part_count;
   if (index_is_unordered(pIndex))
      return 0;
   if ((pOB = pBuilder->pWInfo->pOrderBy) == 0)
@@ -2726,13 +2707,12 @@ indexMightHelpWithOrderBy(WhereLoopBuilder * pBuilder,
         if (pExpr->iColumn < 0)
            return 1;
         for (jj = 0; jj < nIdxCol; jj++) {
-           if (pExpr->iColumn == pIndex->aiColumn[jj])
+           if (pExpr->iColumn == (int)
+               pIndex->def->key_def->parts[jj].fieldno)
               return 1;
         }
      } else if ((aColExpr = pIndex->aColExpr) != 0) {
         for (jj = 0; jj < nIdxCol; jj++) {
-           if (pIndex->aiColumn[jj] != XN_EXPR)
-              continue;
            if (sqlite3ExprCompare
                (pExpr, aColExpr->a[jj].pExpr,
                 iCursor) == 0) {
@@ -2815,7 +2795,6 @@ whereLoopAddBtree(WhereLoopBuilder * pBuilder,   /* WHERE clause information */
   Index *pProbe;    /* An index we are evaluating */
   Index sPk;    /* A fake index object for the primary key */
   LogEst aiRowEstPk[2];  /* The aiRowLogEst[] value for the sPk index */
-  i16 aiColumnPk = -1;   /* The aColumn[] value for the sPk index */
   SrcList *pTabList; /* The FROM clause */
   struct SrcList_item *pSrc; /* The FROM clause btree term to add */
   WhereLoop *pNew;   /* Template WhereLoop object */
@@ -2846,11 +2825,27 @@ whereLoopAddBtree(WhereLoopBuilder * pBuilder, /* WHERE clause information */
       */
      Index *pFirst; /* First of real indices on the table */
      memset(&sPk, 0, sizeof(Index));
-     sPk.nColumn = 1;
-     sPk.aiColumn = &aiColumnPk;
      sPk.aiRowLogEst = aiRowEstPk;
      sPk.onError = ON_CONFLICT_ACTION_REPLACE;
      sPk.pTable = pTab;
+
+     struct key_def *key_def = key_def_new(1);
+     if (key_def == NULL)
+        return SQLITE_ERROR;
+
+     key_def_set_part(key_def, 0, 0, pTab->def->fields[0].type,
+            ON_CONFLICT_ACTION_ABORT,
+            NULL, COLL_NONE, SORT_ORDER_ASC);
+
+     struct index_opts index_opts = index_opts_default;
+
+     sPk.def = index_def_new(pTab->def->id, 0, "primary",
+           sizeof("primary") - 1, TREE, &index_opts,
+           key_def, NULL);
+
+     if (sPk.def == NULL)
+        return SQLITE_ERROR;
+
      aiRowEstPk[0] = sql_space_tuple_log_count(pTab);
      aiRowEstPk[1] = 0;
      pFirst = pSrc->pTab->pIndex;
@@ -3325,8 +3320,8 @@ wherePathSatisfiesOrderBy(WhereInfo * pWInfo,    /* The WHERE clause */
               index_is_unordered(pIndex)) {
            return 0;
         } else {
-           nColumn = index_column_count(pIndex);
-           isOrderDistinct = index_is_unique(pIndex);
+           nColumn = pIndex->def->key_def->part_count;
+           isOrderDistinct = pIndex->def->opts.is_unique;
         }
 
         /* Loop through all columns of the index and deal with the ones
@@ -3387,7 +3382,7 @@ wherePathSatisfiesOrderBy(WhereInfo * pWInfo,    /* The WHERE clause */
             * (revIdx) for the j-th column of the index.
             */
            if (pIndex) {
-              iColumn = pIndex->aiColumn[j];
+              iColumn = pIndex->def->key_def->parts[j].fieldno;
               revIdx = sql_index_column_sort_order(pIndex,
                                j);
               if (iColumn == pIndex->pTable->iPKey)
@@ -3442,8 +3437,7 @@ wherePathSatisfiesOrderBy(WhereInfo * pWInfo,    /* The WHERE clause */
                              pOrderBy->a[i].pExpr,
                              &is_found, &id);
                  struct coll *idx_coll =
-                    sql_index_collation(pIndex,
-                              j, &id);
+                    pIndex->def->key_def->parts[j].coll;
                  if (is_found &&
                      coll != idx_coll)
                     continue;
@@ -4105,9 +4099,9 @@ whereShortCut(WhereLoopBuilder * pBuilder)
   } else {
      for (pIdx = pTab->pIndex; pIdx; pIdx = pIdx->pNext) {
         int opMask;
-        int nIdxCol = index_column_count(pIdx);
+        int nIdxCol = pIdx->def->key_def->part_count;
         assert(pLoop->aLTermSpace == pLoop->aLTerm);
-        if (!index_is_unique(pIdx)
+        if (!pIdx->def->opts.is_unique
             || pIdx->pPartIdxWhere != 0
             || nIdxCol > ArraySize(pLoop->aLTermSpace)
             )
@@ -4650,7 +4644,7 @@ sqlite3WhereBegin(Parse * pParse,    /* The parser context */
               wctrlFlags & WHERE_ORDERBY_MIN) == 0) {
               sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ); /* Hint to COMDB2 */
            }
-           VdbeComment((v, "%s", pIx->zName));
+           VdbeComment((v, "%s", pIx->def->name));
 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
            {
               u64 colUsed = 0;
@@ -4781,7 +4775,7 @@ sqlite3WhereEnd(WhereInfo * pWInfo)
      if (pLevel->addrSkip) {
         sqlite3VdbeGoto(v, pLevel->addrSkip);
         VdbeComment((v, "next skip-scan on %s",
-                pLoop->pIndex->zName));
+                pLoop->pIndex->def->name));
         sqlite3VdbeJumpHere(v, pLevel->addrSkip);
         sqlite3VdbeJumpHere(v, pLevel->addrSkip - 2);
      }
diff --git a/src/box/sql/wherecode.c b/src/box/sql/wherecode.c
index 09b267194..94aae9958 100644
--- a/src/box/sql/wherecode.c
+++ b/src/box/sql/wherecode.c
@@ -47,9 +47,8 @@
 static const char *
 explainIndexColumnName(Index * pIdx, int i)
 {
-  i = pIdx->aiColumn[i];
-  if (i == XN_EXPR)
-     return "<expr>";
+//    i = pIdx->aiColumn[i];
+  i = pIdx->def->key_def->parts[i].fieldno;
   return pIdx->pTable->def->fields[i].name;
 }
 
@@ -222,7 +221,7 @@ sqlite3WhereExplainOneScan(Parse * pParse, /* Parse context */
         }
         if (zFmt) {
            sqlite3StrAccumAppend(&str, " USING ", 7);
-           sqlite3XPrintf(&str, zFmt, pIdx->zName);
+           sqlite3XPrintf(&str, zFmt, pIdx->def->name);
            explainIndexRange(&str, pLoop);
         }
      } else if ((flags & WHERE_IPK) != 0
@@ -708,7 +707,7 @@ codeAllEqualityTerms(Parse * pParse,   /* Parsing context */
      sqlite3VdbeAddOp1(v, (bRev ? OP_Last : OP_Rewind), iIdxCur);
      VdbeCoverageIf(v, bRev == 0);
      VdbeCoverageIf(v, bRev != 0);
-     VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
+     VdbeComment((v, "begin skip-scan on %s", pIdx->def->name));
      j = sqlite3VdbeAddOp0(v, OP_Goto);
      pLevel->addrSkip =
          sqlite3VdbeAddOp4Int(v, (bRev ? OP_SeekLT : OP_SeekGT),
@@ -718,8 +717,7 @@ codeAllEqualityTerms(Parse * pParse,   /* Parsing context */
      sqlite3VdbeJumpHere(v, j);
      for (j = 0; j < nSkip; j++) {
         sqlite3VdbeAddOp3(v, OP_Column, iIdxCur,
-                pIdx->aiColumn[j], regBase + j);
-        testcase(pIdx->aiColumn[j] == XN_EXPR);
+                pIdx->def->key_def->parts[j].fieldno, regBase + j);
         VdbeComment((v, "%s", explainIndexColumnName(pIdx, j)));
      }
   }
@@ -1245,10 +1243,10 @@ sqlite3WhereCodeOneLoopStart(WhereInfo * pWInfo,   /* Complete information about t
      assert(pWInfo->pOrderBy == 0
             || pWInfo->pOrderBy->nExpr == 1
             || (pWInfo->wctrlFlags & WHERE_ORDERBY_MIN) == 0);
-     int nIdxCol = index_column_count(pIdx);
+     int nIdxCol = pIdx->def->key_def->part_count;
      if ((pWInfo->wctrlFlags & WHERE_ORDERBY_MIN) != 0
          && pWInfo->nOBSat > 0 && (nIdxCol > nEq)) {
-        j = pIdx->aiColumn[nEq];
+        j = pIdx->def->key_def->parts[nEq].fieldno;
         /* Allow seek for column with `NOT NULL` == false attribute.
          * If a column may contain NULL-s, the comparator installed
          * by Tarantool is prepared to seek using a NULL value.
@@ -1304,12 +1302,9 @@ sqlite3WhereCodeOneLoopStart(WhereInfo * pWInfo,    /* Complete information about t
         }
 #endif
         if (pRangeStart == 0) {
-           j = pIdx->aiColumn[nEq];
-           if ((j >= 0 &&
-                pIdx->pTable->def->fields[j].is_nullable)||
-               j == XN_EXPR) {
+           j = pIdx->def->key_def->parts[nEq].fieldno;
+           if (pIdx->pTable->def->fields[j].is_nullable)
               bSeekPastNull = 1;
-           }
         }
      }
      assert(pRangeEnd == 0
@@ -1386,9 +1381,10 @@ sqlite3WhereCodeOneLoopStart(WhereInfo * pWInfo,    /* Complete information about t
      }
      struct Index *pk = sqlite3PrimaryKeyIndex(pIdx->pTable);
      assert(pk);
-     int nPkCol = index_column_count(pk);
+     int nPkCol = pk->def->key_def->part_count;
+     uint32_t zero_fieldno = pk->def->key_def->parts[0].fieldno;
      char affinity =
-        pIdx->pTable->def->fields[pk->aiColumn[0]].affinity;
+        pIdx->pTable->def->fields[zero_fieldno].affinity;
      if (nPkCol == 1 && affinity == AFFINITY_INTEGER) {
         /* Right now INTEGER PRIMARY KEY is the only option to
          * get Tarantool's INTEGER column type. Need special handling
@@ -1397,7 +1393,8 @@ sqlite3WhereCodeOneLoopStart(WhereInfo * pWInfo, /* Complete information about t
          */
         int limit = pRangeStart == NULL ? nEq : nEq + 1;
         for (int i = 0; i < limit; i++) {
-           if (pIdx->aiColumn[i] == pk->aiColumn[0]) {
+           if (pIdx->def->key_def->parts[i].fieldno ==
+               zero_fieldno) {
               /* Here: we know for sure that table has INTEGER
                  PRIMARY KEY, single column, and Index we're
                  trying to use for scan contains this column. */
@@ -1506,10 +1503,10 @@ sqlite3WhereCodeOneLoopStart(WhereInfo * pWInfo,   /* Complete information about t
         /* pIdx is a covering index.  No need to access the main table. */
      }  else if (iCur != iIdxCur) {
         Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
-        int nPkCol = index_column_count(pPk);
+        int nPkCol = pPk->def->key_def->part_count;
         int iKeyReg = sqlite3GetTempRange(pParse, nPkCol);
         for (j = 0; j < nPkCol; j++) {
-           k = pPk->aiColumn[j];
+           k = pPk->def->key_def->parts[j].fieldno;
            sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k,
                    iKeyReg + j);
         }
@@ -1614,7 +1611,7 @@ sqlite3WhereCodeOneLoopStart(WhereInfo * pWInfo, /* Complete information about t
       */
      if ((pWInfo->wctrlFlags & WHERE_DUPLICATES_OK) == 0) {
         Index *pPk = sqlite3PrimaryKeyIndex(pTab);
-        int nPkCol = index_column_count(pPk);
+        int nPkCol = pPk->def->key_def->part_count;
         regRowset = pParse->nTab++;
         sqlite3VdbeAddOp2(v, OP_OpenTEphemeral,
                 regRowset, nPkCol);
@@ -1718,13 +1715,15 @@ sqlite3WhereCodeOneLoopStart(WhereInfo * pWInfo,   /* Complete information about t
                  int iSet =
                      ((ii == pOrWc->nTerm - 1) ? -1 : ii);
                  Index *pPk = sqlite3PrimaryKeyIndex (pTab);
-                 int nPk = index_column_count(pPk);
+                 int nPk = pPk->def->key_def->part_count;
                  int iPk;
 
                  /* Read the PK into an array of temp registers. */
                  r = sqlite3GetTempRange(pParse, nPk);
                  for (iPk = 0; iPk < nPk; iPk++) {
-                    int iCol = pPk->aiColumn[iPk];
+                    int iCol = pPk->def->
+                       key_def->
+                       parts[iPk].fieldno;
                     sqlite3ExprCodeGetColumnToReg
                        (pParse, pTab->def,
                         iCol, iCur,
diff --git a/src/box/sql/whereexpr.c b/src/box/sql/whereexpr.c
index aa6d4524d..40e4e2577 100644
--- a/src/box/sql/whereexpr.c
+++ b/src/box/sql/whereexpr.c
@@ -903,7 +903,6 @@ exprMightBeIndexed(SrcList * pFrom,    /* The FROM clause */
         int *piColumn   /* Write the referenced table column number here */
     )
 {
-  Index *pIdx;
   int i;
   int iCur;
 
@@ -930,20 +929,6 @@ exprMightBeIndexed(SrcList * pFrom,   /* The FROM clause */
   for (i = 0; mPrereq > 1; i++, mPrereq >>= 1) {
   }
   iCur = pFrom->a[i].iCursor;
-  for (pIdx = pFrom->a[i].pTab->pIndex; pIdx; pIdx = pIdx->pNext) {
-     if (pIdx->aColExpr == 0)
-        continue;
-     for (i = 0; i < pIdx->nColumn; i++) {
-        if (pIdx->aiColumn[i] != XN_EXPR)
-           continue;
-        if (sqlite3ExprCompare
-            (pExpr, pIdx->aColExpr->a[i].pExpr, iCur) == 0) {
-           *piCur = iCur;
-           *piColumn = XN_EXPR;
-           return 1;
-        }
-     }
-  }
   return 0;
 }
 
-- 
2.14.3 (Apple Git-98)
-- 
Ivan Koptelov