[tarantool-patches] [PATCH 3/9] sql: use msgpack types instead of custom ones

[Nikita Pettik <korablev@tarantool.org>]

This patch provides straightforward refactoring replacing enum sql_type
with enum mp_type. Note that we use msgpack format instead of field_type
since it is more suitable when dealing with NULLs.
---
 src/box/bind.c          |  37 ++++++------------
 src/box/execute.c       |  12 +++---
 src/box/lua/execute.c   |   7 +---
 src/box/lua/lua_sql.c   |  12 +++---
 src/box/sql/date.c      |   2 +-
 src/box/sql/func.c      | 100 ++++++++++++++++++++++++------------------------
 src/box/sql/legacy.c    |   2 +-
 src/box/sql/sqlInt.h    |  16 ++------
 src/box/sql/vdbeapi.c   |  66 ++++++++++----------------------
 src/box/sql/whereexpr.c |   2 +-
 10 files changed, 102 insertions(+), 154 deletions(-)

diff --git a/src/box/bind.c b/src/box/bind.c
index 4b57e23c8..5aa79751a 100644
--- a/src/box/bind.c
+++ b/src/box/bind.c
@@ -35,15 +35,6 @@
 #include "sql/sqlLimit.h"
 #include "sql/vdbe.h"
 
-const char *sql_type_strs[] = {
-	NULL,
-	"INTEGER",
-	"FLOAT",
-	"TEXT",
-	"BLOB",
-	"NULL",
-};
-
 const char *
 sql_bind_name(const struct sql_bind *bind)
 {
@@ -74,7 +65,8 @@ sql_bind_decode(struct sql_bind *bind, int i, const char **packet)
 		bind->name = NULL;
 		bind->name_len = 0;
 	}
-	switch (mp_typeof(**packet)) {
+	enum mp_type type = mp_typeof(**packet);
+	switch (type) {
 	case MP_UINT: {
 		uint64_t n = mp_decode_uint(packet);
 		if (n > INT64_MAX) {
@@ -83,49 +75,40 @@ sql_bind_decode(struct sql_bind *bind, int i, const char **packet)
 			return -1;
 		}
 		bind->i64 = (int64_t) n;
-		bind->type = SQL_INTEGER;
 		bind->bytes = sizeof(bind->i64);
 		break;
 	}
 	case MP_INT:
 		bind->i64 = mp_decode_int(packet);
-		bind->type = SQL_INTEGER;
 		bind->bytes = sizeof(bind->i64);
 		break;
 	case MP_STR:
 		bind->s = mp_decode_str(packet, &bind->bytes);
-		bind->type = SQL_TEXT;
 		break;
 	case MP_DOUBLE:
 		bind->d = mp_decode_double(packet);
-		bind->type = SQL_FLOAT;
 		bind->bytes = sizeof(bind->d);
 		break;
 	case MP_FLOAT:
 		bind->d = mp_decode_float(packet);
-		bind->type = SQL_FLOAT;
 		bind->bytes = sizeof(bind->d);
 		break;
 	case MP_NIL:
 		mp_decode_nil(packet);
-		bind->type = SQL_NULL;
 		bind->bytes = 1;
 		break;
 	case MP_BOOL:
 		/* sql doesn't support boolean. Use int instead. */
 		bind->i64 = mp_decode_bool(packet) ? 1 : 0;
-		bind->type = SQL_INTEGER;
 		bind->bytes = sizeof(bind->i64);
 		break;
 	case MP_BIN:
 		bind->s = mp_decode_bin(packet, &bind->bytes);
-		bind->type = SQL_BLOB;
 		break;
 	case MP_EXT:
 		bind->s = *packet;
 		mp_next(packet);
 		bind->bytes = *packet - bind->s;
-		bind->type = SQL_BLOB;
 		break;
 	case MP_ARRAY:
 		diag_set(ClientError, ER_SQL_BIND_TYPE, "ARRAY",
@@ -138,6 +121,7 @@ sql_bind_decode(struct sql_bind *bind, int i, const char **packet)
 	default:
 		unreachable();
 	}
+	bind->type = type;
 	return 0;
 }
 
@@ -189,13 +173,16 @@ sql_bind_column(struct sql_stmt *stmt, const struct sql_bind *p,
 		}
 	}
 	switch (p->type) {
-	case SQL_INTEGER:
+	case MP_INT:
+	case MP_UINT:
+	case MP_BOOL:
 		rc = sql_bind_int64(stmt, pos, p->i64);
 		break;
-	case SQL_FLOAT:
+	case MP_DOUBLE:
+	case MP_FLOAT:
 		rc = sql_bind_double(stmt, pos, p->d);
 		break;
-	case SQL_TEXT:
+	case MP_STR:
 		/*
 		 * Parameters are allocated within message pack,
 		 * received from the iproto thread. IProto thread
@@ -207,10 +194,10 @@ sql_bind_column(struct sql_stmt *stmt, const struct sql_bind *p,
 		rc = sql_bind_text64(stmt, pos, p->s, p->bytes,
 					 SQL_STATIC);
 		break;
-	case SQL_NULL:
+	case MP_NIL:
 		rc = sql_bind_null(stmt, pos);
 		break;
-	case SQL_BLOB:
+	case MP_BIN:
 		rc = sql_bind_blob64(stmt, pos, (const void *) p->s,
 					 p->bytes, SQL_STATIC);
 		break;
@@ -227,7 +214,7 @@ sql_bind_column(struct sql_stmt *stmt, const struct sql_bind *p,
 	case SQL_TOOBIG:
 	default:
 		diag_set(ClientError, ER_SQL_BIND_VALUE, sql_bind_name(p),
-			 sql_type_strs[p->type]);
+			 mp_type_strs[p->type]);
 		break;
 	}
 	return -1;
diff --git a/src/box/execute.c b/src/box/execute.c
index af2182867..2da2bc88b 100644
--- a/src/box/execute.c
+++ b/src/box/execute.c
@@ -133,9 +133,9 @@ sql_column_to_messagepack(struct sql_stmt *stmt, int i,
 			  struct region *region)
 {
 	size_t size;
-	int type = sql_column_type(stmt, i);
+	enum mp_type type = sql_column_type(stmt, i);
 	switch (type) {
-	case SQL_INTEGER: {
+	case MP_INT: {
 		int64_t n = sql_column_int64(stmt, i);
 		if (n >= 0)
 			size = mp_sizeof_uint(n);
@@ -150,7 +150,7 @@ sql_column_to_messagepack(struct sql_stmt *stmt, int i,
 			mp_encode_int(pos, n);
 		break;
 	}
-	case SQL_FLOAT: {
+	case MP_DOUBLE: {
 		double d = sql_column_double(stmt, i);
 		size = mp_sizeof_double(d);
 		char *pos = (char *) region_alloc(region, size);
@@ -159,7 +159,7 @@ sql_column_to_messagepack(struct sql_stmt *stmt, int i,
 		mp_encode_double(pos, d);
 		break;
 	}
-	case SQL_TEXT: {
+	case MP_STR: {
 		uint32_t len = sql_column_bytes(stmt, i);
 		size = mp_sizeof_str(len);
 		char *pos = (char *) region_alloc(region, size);
@@ -170,7 +170,7 @@ sql_column_to_messagepack(struct sql_stmt *stmt, int i,
 		mp_encode_str(pos, s, len);
 		break;
 	}
-	case SQL_BLOB: {
+	case MP_BIN: {
 		uint32_t len = sql_column_bytes(stmt, i);
 		const char *s =
 			(const char *)sql_column_blob(stmt, i);
@@ -189,7 +189,7 @@ sql_column_to_messagepack(struct sql_stmt *stmt, int i,
 		}
 		break;
 	}
-	case SQL_NULL: {
+	case MP_NIL: {
 		size = mp_sizeof_nil();
 		char *pos = (char *) region_alloc(region, size);
 		if (pos == NULL)
diff --git a/src/box/lua/execute.c b/src/box/lua/execute.c
index 71d64bc27..45d3fc949 100644
--- a/src/box/lua/execute.c
+++ b/src/box/lua/execute.c
@@ -146,7 +146,6 @@ lua_sql_bind_decode(struct lua_State *L, struct sql_bind *bind, int idx, int i)
 		FALLTHROUGH;
 	case MP_INT:
 		bind->i64 = field.ival;
-		bind->type = SQL_INTEGER;
 		bind->bytes = sizeof(bind->i64);
 		break;
 	case MP_STR:
@@ -162,28 +161,23 @@ lua_sql_bind_decode(struct lua_State *L, struct sql_bind *bind, int idx, int i)
 		}
 		memcpy(buf, field.sval.data, field.sval.len + 1);
 		bind->s = buf;
-		bind->type = SQL_TEXT;
 		bind->bytes = field.sval.len;
 		break;
 	case MP_DOUBLE:
 	case MP_FLOAT:
 		bind->d = field.dval;
-		bind->type = SQL_FLOAT;
 		bind->bytes = sizeof(bind->d);
 		break;
 	case MP_NIL:
-		bind->type = SQL_NULL;
 		bind->bytes = 1;
 		break;
 	case MP_BOOL:
 		/* SQLite doesn't support boolean. Use int instead. */
 		bind->i64 = field.bval ? 1 : 0;
-		bind->type = SQL_INTEGER;
 		bind->bytes = sizeof(bind->i64);
 		break;
 	case MP_BIN:
 		bind->s = mp_decode_bin(&field.sval.data, &bind->bytes);
-		bind->type = SQL_BLOB;
 		break;
 	case MP_EXT:
 		diag_set(ClientError, ER_SQL_BIND_TYPE, "USERDATA",
@@ -200,6 +194,7 @@ lua_sql_bind_decode(struct lua_State *L, struct sql_bind *bind, int idx, int i)
 	default:
 		unreachable();
 	}
+	bind->type = field.type;
 	lua_pop(L, lua_gettop(L) - idx);
 	return 0;
 }
diff --git a/src/box/lua/lua_sql.c b/src/box/lua/lua_sql.c
index 3d0047e16..239ed1b2f 100644
--- a/src/box/lua/lua_sql.c
+++ b/src/box/lua/lua_sql.c
@@ -56,21 +56,21 @@ lua_sql_call(sql_context *pCtx, int nVal, sql_value **apVal) {
 	lua_rawgeti(L, LUA_REGISTRYINDEX, func_info->func_ref);
 	for (int i = 0; i < nVal; i++) {
 		sql_value *param = apVal[i];
-		switch (sql_value_type(param)) {
-		case SQL_INTEGER:
+		switch (sql_value_mp_type(param)) {
+		case MP_INT:
 			luaL_pushint64(L, sql_value_int64(param));
 			break;
-		case SQL_FLOAT:
+		case MP_DOUBLE:
 			lua_pushnumber(L, sql_value_double(param));
 			break;
-		case SQL_TEXT:
+		case MP_STR:
 			lua_pushstring(L, (const char *) sql_value_text(param));
 			break;
-		case SQL_BLOB:
+		case MP_BIN:
 			lua_pushlstring(L, sql_value_blob(param),
 					(size_t) sql_value_bytes(param));
 			break;
-		case SQL_NULL:
+		case MP_NIL:
 			lua_rawgeti(L, LUA_REGISTRYINDEX, luaL_nil_ref);
 			break;
 		default:
diff --git a/src/box/sql/date.c b/src/box/sql/date.c
index 5f5272ea3..ead0c01d0 100644
--- a/src/box/sql/date.c
+++ b/src/box/sql/date.c
@@ -937,7 +937,7 @@ isDate(sql_context * context, int argc, sql_value ** argv, DateTime * p)
 	if (argc == 0) {
 		return setDateTimeToCurrent(context, p);
 	}
-	if ((eType = sql_value_type(argv[0])) == SQL_FLOAT
+	if ((eType = sql_value_type(argv[0])) == MP_DOUBLE
 	    || eType == SQL_INTEGER) {
 		setRawDateNumber(p, sql_value_double(argv[0]));
 	} else {
diff --git a/src/box/sql/func.c b/src/box/sql/func.c
index 9adfeec67..3cdb119c8 100644
--- a/src/box/sql/func.c
+++ b/src/box/sql/func.c
@@ -87,10 +87,10 @@ minmaxFunc(sql_context * context, int argc, sql_value ** argv)
 	pColl = sqlGetFuncCollSeq(context);
 	assert(mask == -1 || mask == 0);
 	iBest = 0;
-	if (sql_value_type(argv[0]) == SQL_NULL)
+	if (sql_value_mp_type(argv[0]) == MP_NIL)
 		return;
 	for (i = 1; i < argc; i++) {
-		if (sql_value_type(argv[i]) == SQL_NULL)
+		if (sql_value_mp_type(argv[i]) == MP_NIL)
 			return;
 		if ((sqlMemCompare(argv[iBest], argv[i], pColl) ^ mask) >=
 		    0) {
@@ -109,17 +109,17 @@ typeofFunc(sql_context * context, int NotUsed, sql_value ** argv)
 {
 	const char *z = 0;
 	UNUSED_PARAMETER(NotUsed);
-	switch (sql_value_type(argv[0])) {
-	case SQL_INTEGER:
+	switch (sql_value_mp_type(argv[0])) {
+	case MP_INT:
 		z = "integer";
 		break;
-	case SQL_TEXT:
+	case MP_STR:
 		z = "text";
 		break;
-	case SQL_FLOAT:
+	case MP_DOUBLE:
 		z = "real";
 		break;
-	case SQL_BLOB:
+	case MP_BIN:
 		z = "blob";
 		break;
 	default:
@@ -139,15 +139,15 @@ lengthFunc(sql_context * context, int argc, sql_value ** argv)
 
 	assert(argc == 1);
 	UNUSED_PARAMETER(argc);
-	switch (sql_value_type(argv[0])) {
-	case SQL_BLOB:
-	case SQL_INTEGER:
-	case SQL_FLOAT:{
+	switch (sql_value_mp_type(argv[0])) {
+	case MP_BIN:
+	case MP_INT:
+	case MP_DOUBLE:{
 			sql_result_int(context,
 					   sql_value_bytes(argv[0]));
 			break;
 		}
-	case SQL_TEXT:{
+	case MP_STR:{
 			const unsigned char *z = sql_value_text(argv[0]);
 			if (z == 0)
 				return;
@@ -173,8 +173,8 @@ absFunc(sql_context * context, int argc, sql_value ** argv)
 {
 	assert(argc == 1);
 	UNUSED_PARAMETER(argc);
-	switch (sql_value_type(argv[0])) {
-	case SQL_INTEGER:{
+	switch (sql_value_mp_type(argv[0])) {
+	case MP_INT:{
 			i64 iVal = sql_value_int64(argv[0]);
 			if (iVal < 0) {
 				if (iVal == SMALLEST_INT64) {
@@ -192,7 +192,7 @@ absFunc(sql_context * context, int argc, sql_value ** argv)
 			sql_result_int64(context, iVal);
 			break;
 		}
-	case SQL_NULL:{
+	case MP_NIL:{
 			/* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
 			sql_result_null(context);
 			break;
@@ -229,19 +229,19 @@ position_func(struct sql_context *context, int argc, struct Mem **argv)
 	UNUSED_PARAMETER(argc);
 	struct Mem *needle = argv[0];
 	struct Mem *haystack = argv[1];
-	int needle_type = sql_value_type(needle);
-	int haystack_type = sql_value_type(haystack);
+	enum mp_type needle_type = sql_value_mp_type(needle);
+	enum mp_type haystack_type = sql_value_mp_type(haystack);
 
-	if (haystack_type == SQL_NULL || needle_type == SQL_NULL)
+	if (haystack_type == MP_NIL || needle_type == MP_NIL)
 		return;
 	/*
 	 * Position function can be called only with string
 	 * or blob params.
 	 */
 	struct Mem *inconsistent_type_arg = NULL;
-	if (needle_type != SQL_TEXT && needle_type != SQL_BLOB)
+	if (needle_type != MP_STR && needle_type != MP_BIN)
 		inconsistent_type_arg = needle;
-	if (haystack_type != SQL_TEXT && haystack_type != SQL_BLOB)
+	if (haystack_type != MP_STR && haystack_type != MP_BIN)
 		inconsistent_type_arg = haystack;
 	if (inconsistent_type_arg != NULL) {
 		diag_set(ClientError, ER_INCONSISTENT_TYPES, "TEXT or BLOB",
@@ -268,7 +268,7 @@ position_func(struct sql_context *context, int argc, struct Mem **argv)
 	if (n_needle_bytes > 0) {
 		const unsigned char *haystack_str;
 		const unsigned char *needle_str;
-		if (haystack_type == SQL_BLOB) {
+		if (haystack_type == MP_BIN) {
 			needle_str = sql_value_blob(needle);
 			haystack_str = sql_value_blob(haystack);
 			assert(needle_str != NULL);
@@ -398,14 +398,14 @@ substrFunc(sql_context * context, int argc, sql_value ** argv)
 	int negP2 = 0;
 
 	assert(argc == 3 || argc == 2);
-	if (sql_value_type(argv[1]) == SQL_NULL
-	    || (argc == 3 && sql_value_type(argv[2]) == SQL_NULL)
+	if (sql_value_mp_type(argv[1]) == MP_NIL
+	    || (argc == 3 && sql_value_mp_type(argv[2]) == MP_NIL)
 	    ) {
 		return;
 	}
-	p0type = sql_value_type(argv[0]);
+	p0type = sql_value_mp_type(argv[0]);
 	p1 = sql_value_int(argv[1]);
-	if (p0type == SQL_BLOB) {
+	if (p0type == MP_BIN) {
 		len = sql_value_bytes(argv[0]);
 		z = sql_value_blob(argv[0]);
 		if (z == 0)
@@ -460,7 +460,7 @@ substrFunc(sql_context * context, int argc, sql_value ** argv)
 		}
 	}
 	assert(p1 >= 0 && p2 >= 0);
-	if (p0type != SQL_BLOB) {
+	if (p0type != MP_BIN) {
 		/*
 		 * In the code below 'cnt' and 'n_chars' is
 		 * used because '\0' is not supposed to be
@@ -507,13 +507,13 @@ roundFunc(sql_context * context, int argc, sql_value ** argv)
 	char *zBuf;
 	assert(argc == 1 || argc == 2);
 	if (argc == 2) {
-		if (SQL_NULL == sql_value_type(argv[1]))
+		if (MP_NIL == sql_value_mp_type(argv[1]))
 			return;
 		n = sql_value_int(argv[1]);
 		if (n < 0)
 			n = 0;
 	}
-	if (sql_value_type(argv[0]) == SQL_NULL)
+	if (sql_value_mp_type(argv[0]) == MP_NIL)
 		return;
 	r = sql_value_double(argv[0]);
 	/* If Y==0 and X will fit in a 64-bit int,
@@ -900,13 +900,13 @@ likeFunc(sql_context *context, int argc, sql_value **argv)
 	int nPat;
 	sql *db = sql_context_db_handle(context);
 	int is_like_ci = SQL_PTR_TO_INT(sql_user_data(context));
-	int rhs_type = sql_value_type(argv[0]);
-	int lhs_type = sql_value_type(argv[1]);
+	int rhs_type = sql_value_mp_type(argv[0]);
+	int lhs_type = sql_value_mp_type(argv[1]);
 
-	if (lhs_type != SQL_TEXT || rhs_type != SQL_TEXT) {
-		if (lhs_type == SQL_NULL || rhs_type == SQL_NULL)
+	if (lhs_type != MP_STR || rhs_type != MP_STR) {
+		if (lhs_type == MP_NIL || rhs_type == MP_NIL)
 			return;
-		char *inconsistent_type = rhs_type != SQL_TEXT ?
+		char *inconsistent_type = rhs_type != MP_STR ?
 					  mem_type_to_str(argv[0]) :
 					  mem_type_to_str(argv[1]);
 		diag_set(ClientError, ER_INCONSISTENT_TYPES, "TEXT",
@@ -1018,8 +1018,8 @@ quoteFunc(sql_context * context, int argc, sql_value ** argv)
 {
 	assert(argc == 1);
 	UNUSED_PARAMETER(argc);
-	switch (sql_value_type(argv[0])) {
-	case SQL_FLOAT:{
+	switch (sql_value_mp_type(argv[0])) {
+	case MP_DOUBLE:{
 			double r1, r2;
 			char zBuf[50];
 			r1 = sql_value_double(argv[0]);
@@ -1033,11 +1033,11 @@ quoteFunc(sql_context * context, int argc, sql_value ** argv)
 					    SQL_TRANSIENT);
 			break;
 		}
-	case SQL_INTEGER:{
+	case MP_INT:{
 			sql_result_value(context, argv[0]);
 			break;
 		}
-	case SQL_BLOB:{
+	case MP_BIN:{
 			char *zText = 0;
 			char const *zBlob = sql_value_blob(argv[0]);
 			int nBlob = sql_value_bytes(argv[0]);
@@ -1063,7 +1063,7 @@ quoteFunc(sql_context * context, int argc, sql_value ** argv)
 			}
 			break;
 		}
-	case SQL_TEXT:{
+	case MP_STR:{
 			int i, j;
 			u64 n;
 			const unsigned char *zArg = sql_value_text(argv[0]);
@@ -1092,7 +1092,7 @@ quoteFunc(sql_context * context, int argc, sql_value ** argv)
 			break;
 		}
 	default:{
-			assert(sql_value_type(argv[0]) == SQL_NULL);
+			assert(sql_value_mp_type(argv[0]) == MP_NIL);
 			sql_result_text(context, "NULL", 4, SQL_STATIC);
 			break;
 		}
@@ -1228,13 +1228,13 @@ replaceFunc(sql_context * context, int argc, sql_value ** argv)
 	assert(zStr == sql_value_text(argv[0]));	/* No encoding change */
 	zPattern = sql_value_text(argv[1]);
 	if (zPattern == 0) {
-		assert(sql_value_type(argv[1]) == SQL_NULL
+		assert(sql_value_mp_type(argv[1]) == MP_NIL
 		       || sql_context_db_handle(context)->mallocFailed);
 		return;
 	}
 	nPattern = sql_value_bytes(argv[1]);
 	if (nPattern == 0) {
-		assert(sql_value_type(argv[1]) != SQL_NULL);
+		assert(sql_value_mp_type(argv[1]) != MP_NIL);
 		sql_result_value(context, argv[0]);
 		return;
 	}
@@ -1302,7 +1302,7 @@ trimFunc(sql_context * context, int argc, sql_value ** argv)
 	unsigned char **azChar = 0;	/* Individual characters in zCharSet */
 	int nChar;		/* Number of characters in zCharSet */
 
-	if (sql_value_type(argv[0]) == SQL_NULL) {
+	if (sql_value_mp_type(argv[0]) == MP_NIL) {
 		return;
 	}
 	zIn = sql_value_text(argv[0]);
@@ -1499,10 +1499,10 @@ sumStep(sql_context * context, int argc, sql_value ** argv)
 	UNUSED_PARAMETER(argc);
 	p = sql_aggregate_context(context, sizeof(*p));
 	assert(p != NULL);
-	int type = sql_value_type(argv[0]);
-	if (type == SQL_NULL)
+	enum mp_type type = sql_value_mp_type(argv[0]);
+	if (type == MP_NIL)
 		return;
-	if (type != SQL_FLOAT && type != SQL_INTEGER) {
+	if (type != MP_DOUBLE && type != MP_INT) {
 		if (mem_apply_numeric_type(argv[0]) != 0) {
 			diag_set(ClientError, ER_SQL_TYPE_MISMATCH,
 				 sql_value_text(argv[0]), "number");
@@ -1510,10 +1510,10 @@ sumStep(sql_context * context, int argc, sql_value ** argv)
 			context->isError = SQL_TARANTOOL_ERROR;
 			return;
 		}
-		type = sql_value_type(argv[0]);
+		type = sql_value_mp_type(argv[0]);
 	}
 	p->cnt++;
-	if (type == SQL_INTEGER) {
+	if (type == MP_INT) {
 		i64 v = sql_value_int64(argv[0]);
 		p->rSum += v;
 		if ((p->approx | p->overflow) == 0 &&
@@ -1578,7 +1578,7 @@ countStep(sql_context * context, int argc, sql_value ** argv)
 {
 	CountCtx *p;
 	p = sql_aggregate_context(context, sizeof(*p));
-	if ((argc == 0 || SQL_NULL != sql_value_type(argv[0])) && p) {
+	if ((argc == 0 || MP_NIL != sql_value_mp_type(argv[0])) && p) {
 		p->n++;
 	}
 }
@@ -1605,7 +1605,7 @@ minmaxStep(sql_context * context, int NotUsed, sql_value ** argv)
 	if (!pBest)
 		return;
 
-	if (sql_value_type(argv[0]) == SQL_NULL) {
+	if (sql_value_mp_type(argv[0]) == MP_NIL) {
 		if (pBest->flags)
 			sqlSkipAccumulatorLoad(context);
 	} else if (pBest->flags) {
@@ -1657,7 +1657,7 @@ groupConcatStep(sql_context * context, int argc, sql_value ** argv)
 	const char *zSep;
 	int nVal, nSep;
 	assert(argc == 1 || argc == 2);
-	if (sql_value_type(argv[0]) == SQL_NULL)
+	if (sql_value_mp_type(argv[0]) == MP_NIL)
 		return;
 	pAccum =
 	    (StrAccum *) sql_aggregate_context(context, sizeof(*pAccum));
diff --git a/src/box/sql/legacy.c b/src/box/sql/legacy.c
index 599fba0be..64b1564ee 100644
--- a/src/box/sql/legacy.c
+++ b/src/box/sql/legacy.c
@@ -130,7 +130,7 @@ sql_exec(sql * db,	/* The database on which the SQL executes */
 						    &&
 						    sql_column_type(pStmt,
 									i) !=
-						    SQL_NULL) {
+						    MP_NIL) {
 							sqlOomFault(db);
 							goto exec_out;
 						}
diff --git a/src/box/sql/sqlInt.h b/src/box/sql/sqlInt.h
index b5c596d2f..9134f767d 100644
--- a/src/box/sql/sqlInt.h
+++ b/src/box/sql/sqlInt.h
@@ -455,8 +455,8 @@ sql_value_int64(sql_value *);
 const unsigned char *
 sql_value_text(sql_value *);
 
-int
-sql_value_type(sql_value *);
+enum mp_type
+sql_value_mp_type(sql_value *);
 
 sql *
 sql_context_db_handle(sql_context *);
@@ -580,8 +580,8 @@ const unsigned char *
 sql_column_text(sql_stmt *,
 		    int iCol);
 
-int
-sql_column_type(sql_stmt *, int iCol);
+enum mp_type
+sql_column_type(sql_stmt *stmt, int field_no);
 
 sql_value *
 sql_column_value(sql_stmt *,
@@ -632,14 +632,6 @@ sql_exec(sql *,	/* An open database */
 #define SQL_CONSTRAINT_TRIGGER      (SQL_CONSTRAINT | (7<<8))
 #define SQL_CONSTRAINT_UNIQUE       (SQL_CONSTRAINT | (8<<8))
 
-enum sql_type {
-	SQL_INTEGER = 1,
-	SQL_FLOAT = 2,
-	SQL_TEXT = 3,
-	SQL_BLOB = 4,
-	SQL_NULL = 5,
-};
-
 /**
  * Subtype of a main type. Allows to do some subtype specific
  * things: serialization, unpacking etc.
diff --git a/src/box/sql/vdbeapi.c b/src/box/sql/vdbeapi.c
index be5c9dff9..6e867ca84 100644
--- a/src/box/sql/vdbeapi.c
+++ b/src/box/sql/vdbeapi.c
@@ -243,44 +243,18 @@ sql_value_text(sql_value * pVal)
  * fundamental datatypes: 64-bit signed integer 64-bit IEEE floating
  * point number string BLOB NULL
  */
-int
-sql_value_type(sql_value * pVal)
-{
-	static const u8 aType[] = {
-		SQL_BLOB,	/* 0x00 */
-		SQL_NULL,	/* 0x01 */
-		SQL_TEXT,	/* 0x02 */
-		SQL_NULL,	/* 0x03 */
-		SQL_INTEGER,	/* 0x04 */
-		SQL_NULL,	/* 0x05 */
-		SQL_INTEGER,	/* 0x06 */
-		SQL_NULL,	/* 0x07 */
-		SQL_FLOAT,	/* 0x08 */
-		SQL_NULL,	/* 0x09 */
-		SQL_FLOAT,	/* 0x0a */
-		SQL_NULL,	/* 0x0b */
-		SQL_INTEGER,	/* 0x0c */
-		SQL_NULL,	/* 0x0d */
-		SQL_INTEGER,	/* 0x0e */
-		SQL_NULL,	/* 0x0f */
-		SQL_BLOB,	/* 0x10 */
-		SQL_NULL,	/* 0x11 */
-		SQL_TEXT,	/* 0x12 */
-		SQL_NULL,	/* 0x13 */
-		SQL_INTEGER,	/* 0x14 */
-		SQL_NULL,	/* 0x15 */
-		SQL_INTEGER,	/* 0x16 */
-		SQL_NULL,	/* 0x17 */
-		SQL_FLOAT,	/* 0x18 */
-		SQL_NULL,	/* 0x19 */
-		SQL_FLOAT,	/* 0x1a */
-		SQL_NULL,	/* 0x1b */
-		SQL_INTEGER,	/* 0x1c */
-		SQL_NULL,	/* 0x1d */
-		SQL_INTEGER,	/* 0x1e */
-		SQL_NULL,	/* 0x1f */
-	};
-	return aType[pVal->flags & MEM_PURE_TYPE_MASK];
+enum mp_type
+sql_value_mp_type(sql_value *pVal)
+{
+	switch (pVal->flags & MEM_PURE_TYPE_MASK) {
+	case MEM_Int: return MP_INT;
+	case MEM_Real: return MP_DOUBLE;
+	case MEM_Str: return MP_STR;
+	case MEM_Blob: return MP_BIN;
+	case MEM_Bool: return MP_BOOL;
+	case MEM_Null: return MP_NIL;
+	default: unreachable();
+	}
 }
 
 /* Make a copy of an sql_value object
@@ -1036,12 +1010,12 @@ sql_column_value(sql_stmt * pStmt, int i)
 	return (sql_value *) pOut;
 }
 
-int
+enum mp_type
 sql_column_type(sql_stmt * pStmt, int i)
 {
-	int iType = sql_value_type(columnMem(pStmt, i));
+	enum mp_type type = sql_value_mp_type(columnMem(pStmt, i));
 	columnMallocFailure(pStmt);
-	return iType;
+	return type;
 }
 
 enum sql_subtype
@@ -1414,16 +1388,16 @@ int
 sql_bind_value(sql_stmt * pStmt, int i, const sql_value * pValue)
 {
 	int rc;
-	switch (sql_value_type((sql_value *) pValue)) {
-	case SQL_INTEGER:{
+	switch (sql_value_mp_type((sql_value *) pValue)) {
+	case MP_INT:{
 			rc = sql_bind_int64(pStmt, i, pValue->u.i);
 			break;
 		}
-	case SQL_FLOAT:{
+	case MP_DOUBLE:{
 			rc = sql_bind_double(pStmt, i, pValue->u.r);
 			break;
 		}
-	case SQL_BLOB:{
+	case MP_BIN:{
 			if (pValue->flags & MEM_Zero) {
 				rc = sql_bind_zeroblob(pStmt, i,
 							   pValue->u.nZero);
@@ -1434,7 +1408,7 @@ sql_bind_value(sql_stmt * pStmt, int i, const sql_value * pValue)
 			}
 			break;
 		}
-	case SQL_TEXT:{
+	case MP_STR:{
 			rc = bindText(pStmt, i, pValue->z, pValue->n,
 				      SQL_TRANSIENT);
 			break;
diff --git a/src/box/sql/whereexpr.c b/src/box/sql/whereexpr.c
index 1fb8fd29f..a80c7a0ab 100644
--- a/src/box/sql/whereexpr.c
+++ b/src/box/sql/whereexpr.c
@@ -290,7 +290,7 @@ like_optimization_is_valid(Parse *pParse, Expr *pExpr, Expr **ppPrefix,
 		pVal =
 		    sqlVdbeGetBoundValue(pReprepare, iCol,
 					     FIELD_TYPE_SCALAR);
-		if (pVal && sql_value_type(pVal) == SQL_TEXT) {
+		if (pVal && sql_value_mp_type(pVal) == MP_STR) {
 			z = (char *)sql_value_text(pVal);
 		}
 		sqlVdbeSetVarmask(pParse->pVdbe, iCol);
-- 
2.15.1