sql: replace BLOB as column type with SCALAR

BLOB column type is represented by SCALAR field type in terms of NoSQL.
We attempted at emulating BLOB behaviour, but such efforts turn out to
be not decent enough. For this reason, we've decided to abandon these
attempts and fairly replace it with SCALAR column type.
SCALAR column type acts in the same way as it does in NoSQL: it is
aggregator-type for INTEGER, NUMBER and STRING types. So, column
declared with this type can contain values of these three (available in
SQL) types. For instance:

CREATE TABLE t1 (a SCALAR PRIMARY KEY);
INSERT INTO t1 VALUES ('1');
SELECT * FROM t1 WHERE a = 1;
[] -- Result is empty set since column "a" contains string literal value
'1', not integer value 1.

It is worth noting that CAST operator in this case does nothing:

CAST(123 AS SCALAR); -- Returns 123 (integer)
CAST('abc' AS SCALAR); -- Returns 'abc' (string)

Still, we consider BLOB values as entries encoded in msgpack
with MP_BIN format. To make this happen, values to be operated should be
represented in BLOB form x'...' (e.g. x'000000'). What is more, there
are two built-in functions returning BLOBs: randomblob() and zeroblob().

Closes #4019

Author: Korablev77

extra/mkkeywordhash.c

@@ -109,7 +109,6 @@ static Keyword aKeywordTable[] = {
   { "BEFORE",                 "TK_BEFORE",      TRIGGER,          false },
   { "BEGIN",                  "TK_BEGIN",       TRIGGER,          true  },
   { "BETWEEN",                "TK_BETWEEN",     ALWAYS,           true  },
-  { "BLOB",                   "TK_BLOB_KW",     RESERVED,         true  },
   { "BY",                     "TK_BY",          ALWAYS,           true  },
   { "CASCADE",                "TK_CASCADE",     FKEY,             false },
   { "CASE",                   "TK_CASE",        ALWAYS,           true  },
@@ -193,6 +192,7 @@ static Keyword aKeywordTable[] = {
   { "ROLLBACK",               "TK_ROLLBACK",    ALWAYS,           true  },
   { "ROW",                    "TK_ROW",         TRIGGER,          true  },
   { "SAVEPOINT",              "TK_SAVEPOINT",   ALWAYS,           true  },
+  { "SCALAR",                 "TK_SCALAR",      ALWAYS,           true  },
   { "SELECT",                 "TK_SELECT",      ALWAYS,           true  },
   { "SET",                    "TK_SET",         ALWAYS,           true  },
   { "SIMPLE",                 "TK_SIMPLE",      ALWAYS,           true  },

src/box/sql/parse.y

@@ -1477,7 +1477,7 @@ wqlist(A) ::= wqlist(A) COMMA nm(X) eidlist_opt(Y) AS LP select(Z) RP. {
 ////////////////////////////// TYPE DECLARATION ///////////////////////////////
 %type typedef {struct type_def}
 typedef(A) ::= TEXT . { A.type = FIELD_TYPE_STRING; }
-typedef(A) ::= BLOB_KW . { A.type = FIELD_TYPE_SCALAR; }
+typedef(A) ::= SCALAR . { A.type = FIELD_TYPE_SCALAR; }
 /**
  * Time-like types are temporary disabled, until they are
  * implemented as a native Tarantool types (gh-3694).

src/box/sql/vdbe.c

@@ -364,8 +364,6 @@ mem_apply_type(struct Mem *record, enum field_type type)
 		record->flags &= ~(MEM_Real | MEM_Int);
 		return 0;
 	case FIELD_TYPE_SCALAR:
-		if (record->flags & (MEM_Str | MEM_Blob))
-			record->flags |= MEM_Blob;
 		return 0;
 	default:
 		return -1;

src/box/sql/vdbemem.c

@@ -617,19 +617,7 @@ sqlVdbeMemCast(Mem * pMem, enum field_type type)
 	}
 	switch (type) {
 	case FIELD_TYPE_SCALAR:
-		if (pMem->flags & MEM_Blob)
-			return SQL_OK;
-		if (pMem->flags & MEM_Str) {
-			MemSetTypeFlag(pMem, MEM_Blob);
-			return SQL_OK;
-		}
-		if (pMem->flags & MEM_Int || pMem->flags & MEM_Real) {
-			if (sqlVdbeMemStringify(pMem, 1) != 0)
-				return -1;
-			MemSetTypeFlag(pMem, MEM_Blob);
-			return 0;
-		}
-		return SQL_ERROR;
+		return 0;
 	case FIELD_TYPE_INTEGER:
 		if ((pMem->flags & MEM_Blob) != 0) {
 			if (sql_atoi64(pMem->z, (int64_t *) &pMem->u.i,

test/sql-tap/analyze9.test.lua

@@ -391,7 +391,7 @@ test:do_execsql_test(
         INSERT INTO t1 VALUES(null, 4, 4);
         INSERT INTO t1 VALUES(null, 5, 5);
         ANALYZE;
-        CREATE TABLE x1(tbl TEXT, idx TEXT , neq TEXT, nlt TEXT, ndlt TEXT, sample BLOB, PRIMARY KEY(tbl, idx, sample));
+        CREATE TABLE x1(tbl TEXT, idx TEXT , neq TEXT, nlt TEXT, ndlt TEXT, sample SCALAR, PRIMARY KEY(tbl, idx, sample));
         INSERT INTO x1 SELECT * FROM "_sql_stat4";
         DELETE FROM "_sql_stat4";
         INSERT INTO "_sql_stat4" SELECT * FROM x1;

test/sql-tap/blob.test.lua

@@ -170,7 +170,7 @@ test:do_test(
     "blob-2.0",
     function()
         test:execsql [[
-            CREATE TABLE t1(a BLOB primary key, b BLOB);
+            CREATE TABLE t1(a SCALAR primary key, b SCALAR);
             INSERT INTO t1 VALUES(X'123456', x'7890ab');
             INSERT INTO t1 VALUES(X'CDEF12', x'345678');
         ]]
@@ -186,7 +186,7 @@ test:do_test(
         -- </blob-2.0>
     })
 
--- An index on a blob column
+-- An index on a SCALAR column
 test:do_test(
     "blob-2.1",
     function()

test/sql-tap/boundary1.test.lua

@@ -26,7 +26,7 @@ test:do_test(
     "boundary1-1.1",
     function()
         return test:execsql([[
-            CREATE TABLE t1(rowid  INT primary key, a INT ,x BLOB);
+            CREATE TABLE t1(rowid  INT primary key, a INT ,x SCALAR);
             INSERT INTO t1(rowid,a,x) VALUES(-8388609,1,'ffffffffff7fffff');
             INSERT INTO t1(rowid,a,x) VALUES(-36028797018963969,2,'ff7fffffffffffff');
             INSERT INTO t1(rowid,a,x) VALUES(9223372036854775807,3,'7fffffffffffffff');

test/sql-tap/boundary3.test.lua

@@ -26,7 +26,7 @@ test:do_test(
     "boundary3-1.1",
     function()
         return test:execsql([[
-            CREATE TABLE t1(rowid  INT primary key, a FLOAT ,x BLOB);
+            CREATE TABLE t1(rowid  INT primary key, a FLOAT ,x SCALAR);
             INSERT INTO t1(rowid,a,x) VALUES(-8388609,1,'ffffffffff7fffff');
             INSERT INTO t1(rowid,a,x) VALUES(-36028797018963969,2,'ff7fffffffffffff');
             INSERT INTO t1(rowid,a,x) VALUES(9223372036854775806,3,'7fffffffffffffff');

test/sql-tap/cast.test.lua

@@ -22,7 +22,7 @@ test:plan(82)
 -- Only run these tests if the build includes the CAST operator
 
 
--- Tests for the CAST( AS blob), CAST( AS text) and CAST( AS numeric) built-ins
+-- Tests for the CAST( AS SCALAR), CAST( AS text) and CAST( AS numeric) built-ins
 --
 test:do_execsql_test(
     "cast-1.1",
@@ -77,7 +77,7 @@ test:do_catchsql_test(
 test:do_execsql_test(
     "cast-1.7",
     [[
-        SELECT CAST(x'616263' AS blob)
+        SELECT CAST(x'616263' AS SCALAR)
     ]], {
         -- <cast-1.7>
         "abc"
@@ -87,7 +87,7 @@ test:do_execsql_test(
 test:do_execsql_test(
     "cast-1.8",
     [[
-        SELECT typeof(CAST(x'616263' AS blob))
+        SELECT typeof(CAST(x'616263' AS SCALAR))
     ]], {
         -- <cast-1.8>
         "blob"
@@ -167,7 +167,7 @@ test:do_execsql_test(
 test:do_execsql_test(
     "cast-1.17",
     [[
-        SELECT CAST(NULL AS blob)
+        SELECT CAST(NULL AS SCALAR)
     ]], {
         -- <cast-1.17>
         ""
@@ -177,7 +177,7 @@ test:do_execsql_test(
 test:do_execsql_test(
     "cast-1.18",
     [[
-        SELECT typeof(CAST(NULL AS blob))
+        SELECT typeof(CAST(NULL AS SCALAR))
     ]], {
         -- <cast-1.18>
         "null"
@@ -267,20 +267,20 @@ test:do_execsql_test(
 test:do_execsql_test(
     "cast-1.27",
     [[
-        SELECT CAST(123 AS blob)
+        SELECT CAST(123 AS SCALAR)
     ]], {
         -- <cast-1.27>
-        "123"
+        123
         -- </cast-1.27>
     })
 
 test:do_execsql_test(
     "cast-1.28",
     [[
-        SELECT typeof(CAST(123 AS blob))
+        SELECT typeof(CAST(123 AS SCALAR))
     ]], {
         -- <cast-1.28>
-        "blob"
+        "integer"
         -- </cast-1.28>
     })
 
@@ -367,20 +367,20 @@ test:do_execsql_test(
 test:do_execsql_test(
     "cast-1.37",
     [[
-        SELECT CAST(123.456 AS blob)
+        SELECT CAST(123.456 AS SCALAR)
     ]], {
         -- <cast-1.37>
-        "123.456"
+        123.456
         -- </cast-1.37>
     })
 
 test:do_execsql_test(
     "cast-1.38",
     [[
-        SELECT typeof(CAST(123.456 AS blob))
+        SELECT typeof(CAST(123.456 AS SCALAR))
     ]], {
         -- <cast-1.38>
-        "blob"
+        "real"
         -- </cast-1.38>
     })
 
@@ -457,10 +457,10 @@ test:do_catchsql_test(
 test:do_execsql_test(
     "cast-1.48",
     [[
-        SELECT typeof(CAST('123abc' AS blob))
+        SELECT typeof(CAST('123abc' AS SCALAR))
     ]], {
         -- <cast-1.48>
-        "blob"
+        "text"
         -- </cast-1.48>
     })
 

test/sql-tap/default.test.lua

@@ -28,7 +28,7 @@ test:do_execsql_test(
 		CREATE TABLE t1(
 		rowid INTEGER PRIMARY KEY AUTOINCREMENT, 
 		a INTEGER,
-		b BLOB DEFAULT x'6869'
+		b SCALAR DEFAULT x'6869'
 		);
 		INSERT INTO t1(a) VALUES(1);
 		SELECT a, b from t1;

test/sql-tap/delete4.test.lua

@@ -56,7 +56,7 @@ test:do_execsql_test(
     2.1,
     [[
         DROP TABLE IF EXISTS t1;
-        CREATE TABLE t1(x INTEGER PRIMARY KEY, y INT , z BLOB);
+        CREATE TABLE t1(x INTEGER PRIMARY KEY, y INT , z SCALAR);
         INSERT INTO t1 VALUES(1, 0, randomblob(200));
         INSERT INTO t1 VALUES(2, 1, randomblob(200));
         INSERT INTO t1 VALUES(3, 0, randomblob(200));

test/sql-tap/distinct.test.lua

@@ -222,7 +222,7 @@ if (1 > 0) then
     ---------------------------------------------------------------------------
     -- Ticket  [fccbde530a6583bf2748400919f1603d5425995c] (2014-01-08)
     -- The logic that computes DISTINCT sometimes thinks that a zeroblob()
-    -- and a blob of all zeros are different when they should be the same. 
+    -- and a blob of all zeros are different when they should be the same.
     --
     test:do_execsql_test(
         4.1,
@@ -236,13 +236,8 @@ if (1 > 0) then
             INSERT INTO t1 VALUES(4,2);
             INSERT INTO t1 VALUES(5,3);
             INSERT INTO t1 VALUES(6,1);
-            CREATE TABLE t2(x BLOB primary key);
-            INSERT INTO t2
-              SELECT DISTINCT
-                CASE a WHEN 1 THEN x'0000000000'
-                       WHEN 2 THEN zeroblob(5)
-                       ELSE 'xyzzy' END
-                FROM t1;
+            CREATE TABLE t2(x SCALAR primary key);
+            INSERT INTO t2 SELECT DISTINCT CASE a WHEN 1 THEN x'0000000000' WHEN 2 THEN zeroblob(5) ELSE 'xyzzy' END FROM t1;
             SELECT quote(x) FROM t2 ORDER BY 1;
         ]], {
             -- <4.1>

test/sql-tap/e_expr.test.lua

@@ -3034,15 +3034,13 @@ test:do_execsql_test(
 --
 do_expr_test("e_expr-27.2.1", " CAST(NULL AS integer) ", "null", "")
 do_expr_test("e_expr-27.2.2", " CAST(NULL AS text) ", "null", "")
-do_expr_test("e_expr-27.2.3", " CAST(NULL AS blob) ", "null", "")
+do_expr_test("e_expr-27.2.3", " CAST(NULL AS SCALAR) ", "null", "")
 do_expr_test("e_expr-27.2.4", " CAST(NULL AS numeric) ", "null", "")
--- EVIDENCE-OF: R-22956-37754 Casting to a BLOB consists of first casting
--- the value to TEXT in the encoding of the database connection, then
--- interpreting the resulting byte sequence as a BLOB instead of as TEXT.
+-- Casting to a SCALAR doesn't affect original value.
 --
-do_qexpr_test("e_expr-27.4.1", " CAST('ghi' AS blob) ", "X'676869'")
-do_qexpr_test("e_expr-27.4.2", " CAST(456 AS blob) ", "X'343536'")
-do_qexpr_test("e_expr-27.4.3", " CAST(1.78 AS blob) ", "X'312E3738'")
+do_qexpr_test("e_expr-27.4.1", " CAST('ghi' AS SCALAR) ", "X'676869'")
+do_qexpr_test("e_expr-27.4.2", " CAST(456 AS SCALAR) ", "X'343536'")
+do_qexpr_test("e_expr-27.4.3", " CAST(1.78 AS SCALAR) ", "X'312E3738'")
 
 -- EVIDENCE-OF: R-22235-47006 Casting an INTEGER or REAL value into TEXT
 -- renders the value as if via sql_snprintf() except that the
@@ -3170,7 +3168,7 @@ do_expr_test("e_expr-32.2.4", [[
   CAST(9223372036854775807 AS NUMERIC)
 ]], "real", 9223372036854775807)
 -- EVIDENCE-OF: R-64550-29191 Note that the result from casting any
--- non-BLOB value into a BLOB and the result from casting any BLOB value
+-- non-BLOB value into a SCALAR and the result from casting any SCALAR value
 -- into a non-BLOB value may be different depending on whether the
 -- database encoding is UTF-8
 --

test/sql-tap/in3.test.lua

@@ -271,12 +271,12 @@ test:do_test(
             DROP TABLE IF EXISTS t1;
             DROP TABLE IF EXISTS t1;
 
-            CREATE TABLE t1(id  INT primary key, a BLOB, b FLOAT ,c TEXT);
+            CREATE TABLE t1(id  INT primary key, a SCALAR, b FLOAT ,c TEXT);
             CREATE UNIQUE INDEX t1_i1 ON t1(a);        /* no affinity */
             CREATE UNIQUE INDEX t1_i2 ON t1(b);        /* numeric affinity */
             CREATE UNIQUE INDEX t1_i3 ON t1(c);        /* text affinity */
 
-            CREATE TABLE t2(id  INT primary key, x BLOB, y FLOAT, z TEXT);
+            CREATE TABLE t2(id  INT primary key, x SCALAR, y FLOAT, z TEXT);
             CREATE UNIQUE INDEX t2_i1 ON t2(x);        /* no affinity */
             CREATE UNIQUE INDEX t2_i2 ON t2(y);        /* numeric affinity */
             CREATE UNIQUE INDEX t2_i3 ON t2(z);        /* text affinity */
@@ -318,9 +318,8 @@ test:do_test(
 test:do_test(
     "in3-3.4",
     function()
-        -- BLOB is compatible with TEXT, however index can't
-        -- be used since under the hood BLOB is SCALAR (which
-        -- can contain not only STRING values) and TEXT is STRING.
+        -- SCALAR is compatible with TEXT, however index can't
+        -- be used since SCALAR can accept not only string values.
         return exec_neph(" SELECT x IN (SELECT c FROM t1) FROM t2 ")
     end, {
         -- <in3-3.4>

test/sql-tap/index4.test.lua

@@ -22,7 +22,7 @@ testprefix = "index4"
 test:do_execsql_test(
     1.1,
     [[
-        CREATE TABLE t1(x BLOB primary key);
+        CREATE TABLE t1(x SCALAR primary key);
         START TRANSACTION;
           INSERT INTO t1 VALUES(randomblob(102));
           INSERT INTO t1 SELECT randomblob(102) FROM t1;     --     2
@@ -78,7 +78,7 @@ test:do_execsql_test(
     1.6,
     [[
           DROP TABLE t1;
-          CREATE TABLE t1(x BLOB primary key);
+          CREATE TABLE t1(x SCALAR primary key);
         START TRANSACTION;
           INSERT INTO t1 VALUES('a');
           INSERT INTO t1 VALUES('b');

test/sql-tap/substr.test.lua

@@ -25,7 +25,7 @@ test:plan(93)
 --
 test:execsql [[
     CREATE TABLE t1(id integer primary key --autoincrement
-    , t text, b blob)
+    , t text, b SCALAR)
 ]]
 
 local function substr_test(id, string, i1, i2, result)

test/sql-tap/table.test.lua

@@ -495,8 +495,8 @@ test:do_catchsql_test(
           key int,
           "14_vac" int,
           fuzzy_dog_12 varchar(10),
-          beginn blob,
-          endd blob
+          beginn SCALAR,
+          endd SCALAR
         )
     ]=], {
         -- <table-7.1>
@@ -551,8 +551,8 @@ test:do_execsql2_test(
           key int,
           "14_vac" int,
           fuzzy_dog_12 varchar(10),
-          beginn blob,
-          endd blob
+          beginn SCALAR,
+          endd SCALAR
         );
         INSERT INTO t2 SELECT * from weird;
         SELECT * FROM t2;
@@ -704,7 +704,7 @@ test:do_catchsql_test(
 test:do_catchsql_test(
     "table-9.2",
     [[
-        CREATE TABLE t6(a varchar(100) primary key, b blob, a integer);
+        CREATE TABLE t6(a varchar(100) primary key, b SCALAR, a integer);
     ]], {
         -- <table-9.2>
         1, "Space field 'A' is duplicate"
@@ -895,8 +895,8 @@ test:do_execsql_test(
            b FLOAT,
            c VARCHAR(8),
            d VARCHAR(9),
-           e blob,
-           f BLOB,
+           e SCALAR,
+           f SCALAR,
            g Text,
            h text
         );
@@ -1142,7 +1142,7 @@ test:do_test(
 --   DROP TABLE IF EXISTS t1;
 --   BEGIN;
 --   CREATE TABLE t1 AS SELECT zeroblob(2e20);
--- } {1 {string or blob too big}}
+-- } {1 {string or SCALAR too big}}
 -- do_execsql_test table-18.2 {
 --   COMMIT;
 --   PRAGMA integrity_check;

test/sql-tap/tkt1443.test.lua

@@ -85,7 +85,7 @@ test:do_test(
             CREATE TABLE Users (
                 userId INTEGER PRIMARY KEY,
                 "user" TEXT UNIQUE,
-                salt  BLOB,
+                salt  SCALAR,
                 password  TEXT
             );
             INSERT INTO Users VALUES(1, 'test', 'Šæ%s',