sql: arithmetic for DATETIME and INTERVAL

After this patch, it will be possible to perform permitted arithmetic
operations on DATETIME and INTERVAL values.

Closes tarantool#6773

@TarantoolBot document
Title: Field type interval is available in SQL

The INTERVAL field type is now available in SQL. INTERVAL values cannot
be compared. INTERVAL values can be explicitly and implicitly cast to
ANY. There are currently no literals for the INTERVAL field type.

Author: ImeevMA

changelogs/unreleased/gh-6773-introduce-field-type-interval-to-sql.md

@@ -0,0 +1,3 @@
+## feature/sql
+
+* Field type INTERVAL is introduced to SQL (gh-6773).

src/box/sql/mem.c

@@ -2002,15 +2002,20 @@ check_types_numeric_arithmetic(const struct Mem *a, const struct Mem *b)
 	return 0;
 }
 
-int
-mem_add(const struct Mem *left, const struct Mem *right, struct Mem *result)
+/**
+ * Add the first MEM to the second MEM and write the result to the third MEM.
+ * The first and the second MEMs should be of numeric types. The result is of
+ * numeric type.
+ */
+static int
+mem_add_num(const struct Mem *left, const struct Mem *right, struct Mem *result)
 {
-	if (mem_is_any_null(left, right)) {
-		mem_set_null(result);
-		return 0;
-	}
-	if (check_types_numeric_arithmetic(left, right) != 0)
+	assert(mem_is_num(left) && !mem_is_metatype(left));
+	if (!mem_is_num(right) || mem_is_metatype(right)) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(right),
+			 "integer, decimal or double");
 		return -1;
+	}
 	if (((left->type | right->type) & MEM_TYPE_DOUBLE) != 0) {
 		double a;
 		double b;
@@ -2044,15 +2049,79 @@ mem_add(const struct Mem *left, const struct Mem *right, struct Mem *result)
 	return 0;
 }
 
+/**
+ * Add the first MEM to the second MEM and write the result to the third MEM.
+ * The first MEM should be of DATETIME type and the second MEMs should be of
+ * INTERVAL type. The result is of DATETIME type.
+ */
+static int
+mem_add_dt(const struct Mem *left, const struct Mem *right, struct Mem *result)
+{
+	assert(mem_is_datetime(left) && !mem_is_metatype(left));
+	if (!mem_is_interval(right) || mem_is_metatype(right)) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(right),
+			 "interval");
+		return -1;
+	}
+	mem_set_datetime(result, &left->u.dt);
+	return datetime_increment_by(&result->u.dt, 1, &right->u.itv);
+}
+
+/**
+ * Add the first MEM to the second MEM and write the result to the third MEM.
+ * The first MEM should be of INTERVAL type and the second MEMs should be of
+ * INTERVAL or DATETIME type. The result is of the same type as the second
+ * argument.
+ */
+static int
+mem_add_itv(const struct Mem *left, const struct Mem *right, struct Mem *result)
+{
+	assert(mem_is_interval(left) && !mem_is_metatype(left));
+	if (mem_is_datetime(right) && !mem_is_metatype(right))
+		return mem_add_dt(right, left, result);
+	if (!mem_is_interval(right) || mem_is_metatype(right)) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(right),
+			 "datetime or interval");
+		return -1;
+	}
+	mem_set_interval(result, &left->u.itv);
+	return interval_interval_add(&result->u.itv, &right->u.itv);
+}
+
 int
-mem_sub(const struct Mem *left, const struct Mem *right, struct Mem *result)
+mem_add(const struct Mem *left, const struct Mem *right, struct Mem *result)
 {
 	if (mem_is_any_null(left, right)) {
 		mem_set_null(result);
 		return 0;
 	}
-	if (check_types_numeric_arithmetic(left, right) != 0)
+	if (!mem_is_metatype(left)) {
+		if (mem_is_num(left))
+			return mem_add_num(left, right, result);
+		if (mem_is_datetime(left))
+			return mem_add_dt(left, right, result);
+		if (mem_is_interval(left))
+			return mem_add_itv(left, right, result);
+	}
+	diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(left),
+		 "integer, decimal, double, datetime or interval");
+	return -1;
+}
+
+/**
+ * Subtract the second MEM from the first MEM and write the result to the third
+ * MEM. The first and the second MEMs should be of numeric types. The result is
+ * of numeric type.
+ */
+static int
+mem_sub_num(const struct Mem *left, const struct Mem *right, struct Mem *result)
+{
+	assert(mem_is_num(left) && !mem_is_metatype(left));
+	if (!mem_is_num(right) || mem_is_metatype(right)) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(right),
+			 "integer, decimal or double");
 		return -1;
+	}
 	if (((left->type | right->type) & MEM_TYPE_DOUBLE) != 0) {
 		double a;
 		double b;
@@ -2086,6 +2155,72 @@ mem_sub(const struct Mem *left, const struct Mem *right, struct Mem *result)
 	return 0;
 }
 
+/**
+ * Subtract the second MEM from the first MEM and write the result to the third
+ * MEM. The first MEM should be of DATETIME type and the second MEMs should be
+ * of INTERVAL or DATETIME type. The result is of INTERVAL type if the second
+ * MEM is of DATETIME type and the result if of DATETIME type if the second
+ * argument if of INTERVAL type.
+ */
+static int
+mem_sub_dt(const struct Mem *left, const struct Mem *right, struct Mem *result)
+{
+	assert(mem_is_datetime(left) && !mem_is_metatype(left));
+	if (mem_is_datetime(right) && !mem_is_metatype(right)) {
+		struct interval res;
+		memset(&res, 0, sizeof(res));
+		mem_set_interval(result, &res);
+		return datetime_datetime_sub(&result->u.itv, &left->u.dt,
+					     &right->u.dt);
+	}
+
+	if (!mem_is_interval(right) || mem_is_metatype(right)) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(right),
+			 "datetime or interval");
+		return -1;
+	}
+	mem_set_datetime(result, &left->u.dt);
+	return datetime_increment_by(&result->u.dt, -1, &right->u.itv);
+}
+
+/**
+ * Subtract the second MEM from the first MEM and write the result to the third
+ * MEM. The first and the second MEMs should be of INTERVAL types. The result is
+ * of INTERVAL type.
+ */
+static int
+mem_sub_itv(const struct Mem *left, const struct Mem *right, struct Mem *result)
+{
+	assert(mem_is_interval(left) && !mem_is_metatype(left));
+	if (!mem_is_interval(right) || mem_is_metatype(right)) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(right),
+			 "interval");
+		return -1;
+	}
+	mem_set_interval(result, &left->u.itv);
+	return interval_interval_sub(&result->u.itv, &right->u.itv);
+}
+
+int
+mem_sub(const struct Mem *left, const struct Mem *right, struct Mem *result)
+{
+	if (mem_is_any_null(left, right)) {
+		mem_set_null(result);
+		return 0;
+	}
+	if (!mem_is_metatype(left)) {
+		if (mem_is_num(left))
+			return mem_sub_num(left, right, result);
+		if (mem_is_datetime(left))
+			return mem_sub_dt(left, right, result);
+		if (mem_is_interval(left))
+			return mem_sub_itv(left, right, result);
+	}
+	diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(left),
+		 "integer, decimal, double, datetime or interval");
+	return -1;
+}
+
 int
 mem_mul(const struct Mem *left, const struct Mem *right, struct Mem *result)
 {

src/box/sql/mem.h

@@ -196,6 +196,12 @@ mem_is_datetime(const struct Mem *mem)
 	return mem->type == MEM_TYPE_DATETIME;
 }
 
+static inline bool
+mem_is_interval(const struct Mem *mem)
+{
+	return mem->type == MEM_TYPE_INTERVAL;
+}
+
 static inline bool
 mem_is_bytes(const struct Mem *mem)
 {

test/sql-luatest/datetime_test.lua

@@ -1321,9 +1321,7 @@ g.test_datetime_23_2 = function()
     g.server:exec(function()
         local t = require('luatest')
         local sql = [[SELECT dt + 1 FROM t2;]]
-        local res = [[Type mismatch: can not convert ]]..
-                    [[datetime(2001-01-01T01:00:00Z) ]]..
-                    [[to integer, decimal or double]]
+        local res = [[Type mismatch: can not convert integer(1) to interval]]
         local _, err = box.execute(sql)
         t.assert_equals(err.message, res)
     end)
@@ -1333,9 +1331,8 @@ g.test_datetime_23_3 = function()
     g.server:exec(function()
         local t = require('luatest')
         local sql = [[SELECT dt - 1 FROM t2;]]
-        local res = [[Type mismatch: can not convert ]]..
-                    [[datetime(2001-01-01T01:00:00Z) ]]..
-                    [[to integer, decimal or double]]
+        local res = [[Type mismatch: can not convert integer(1) to ]]..
+                    [[datetime or interval]]
         local _, err = box.execute(sql)
         t.assert_equals(err.message, res)
     end)
@@ -2259,3 +2256,109 @@ g.test_datetime_30_18 = function()
         t.assert_equals(rows, res)
     end)
 end
+
+-- Make sure that arithmetic for datetime works as intended.
+g.test_datetime_31_1 = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local dt = require('datetime')
+        local itv = dt.interval
+        local dt1 = dt.new({year = 2001, month = 1, day = 1, hour = 1})
+        local dt2 = dt.new({year = 2002, month = 2, day = 2, hour = 2})
+        local itv1 = itv.new({year = 1, month = 1, day = 1, hour = 1})
+        t.assert_equals(dt2 - dt1, itv1)
+
+        local rows = box.execute([[SELECT $1 - $2;]], {dt2, dt1}).rows
+        t.assert_equals(rows, {{itv1}})
+    end)
+end
+
+g.test_datetime_31_2 = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local dt = require('datetime')
+        local dt1 = dt.new({year = 2001, month = 1, day = 1, hour = 1})
+        local dt2 = dt.new({year = 2002, month = 2, day = 2, hour = 2})
+        local _, err = box.execute([[SELECT $1 + $2;]], {dt1, dt2})
+        t.assert_equals(err.message, [[Type mismatch: can not convert ]]..
+                                     [[datetime(2002-02-02T02:00:00Z) to ]]..
+                                     [[interval]])
+    end)
+end
+
+g.test_datetime_31_3 = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local dt = require('datetime')
+        local itv = dt.interval
+        local dt1 = dt.new({year = 2001, month = 1, day = 1, hour = 1})
+        local dt2 = dt.new({year = 2002, month = 2, day = 2, hour = 2})
+        local itv1 = itv.new({year = 1, month = 1, day = 1, hour = 1})
+        local rows = box.execute([[SELECT $1 + $2;]], {dt1, itv1}).rows
+        t.assert_equals(rows, {{dt2}})
+    end)
+end
+
+g.test_datetime_31_4 = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local dt = require('datetime')
+        local itv = dt.interval
+        local dt1 = dt.new({year = 2001, month = 1, day = 1, hour = 1})
+        local dt2 = dt.new({year = 2002, month = 2, day = 2, hour = 2})
+        local itv1 = itv.new({year = 1, month = 1, day = 1, hour = 1})
+        local rows = box.execute([[SELECT $1 - $2;]], {dt2, itv1}).rows
+        t.assert_equals(rows, {{dt1}})
+    end)
+end
+
+g.test_datetime_31_5 = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local dt = require('datetime')
+        local itv = dt.interval
+        local dt1 = dt.new({year = 2001, month = 1, day = 1, hour = 1})
+        local dt2 = dt.new({year = 2002, month = 2, day = 2, hour = 2})
+        local itv1 = itv.new({year = 1, month = 1, day = 1, hour = 1})
+        local rows = box.execute([[SELECT $1 + $2;]], {itv1, dt1}).rows
+        t.assert_equals(rows, {{dt2}})
+    end)
+end
+
+g.test_datetime_31_6 = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local dt = require('datetime')
+        local itv = dt.interval
+        local dt1 = dt.new({year = 2001, month = 1, day = 1, hour = 1})
+        local itv1 = itv.new({year = 1, month = 1, day = 1, hour = 1})
+        local _, err = box.execute([[SELECT $1 - $2;]], {itv1, dt1})
+        t.assert_equals(err.message, [[Type mismatch: can not convert ]]..
+                                     [[datetime(2001-01-01T01:00:00Z) to ]]..
+                                     [[interval]])
+    end)
+end
+
+g.test_datetime_31_7 = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local itv = require('datetime').interval
+        local itv1 = itv.new({year = 1, month = 1, day = 1, hour = 1})
+        local itv2 = itv.new({year = 2, month = 3, day = 4, hour = 5})
+        local itv3 = itv.new({year = 3, month = 4, day = 5, hour = 6})
+        local rows = box.execute([[SELECT $1 - $2;]], {itv3, itv1}).rows
+        t.assert_equals(rows, {{itv2}})
+    end)
+end
+
+g.test_datetime_31_8 = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local itv = require('datetime').interval
+        local itv1 = itv.new({year = 1, month = 1, day = 1, hour = 1})
+        local itv2 = itv.new({year = 2, month = 3, day = 4, hour = 5})
+        local itv3 = itv.new({year = 3, month = 4, day = 5, hour = 6})
+        local rows = box.execute([[SELECT $1 + $2;]], {itv2, itv1}).rows
+        t.assert_equals(rows, {{itv3}})
+    end)
+end

test/sql-luatest/gh_6773_arithmetic_operands_test.lua

@@ -15,7 +15,7 @@ g.test_add = function()
     g.server:exec(function()
         local t = require('luatest')
         local res = [[Type mismatch: can not convert string('1') to ]]..
-                    [[integer, decimal or double]]
+                    [[integer, decimal, double, datetime or interval]]
         local _, err = box.execute([[SELECT '1' + '2';]])
         t.assert_equals(err.message, res)
         _, err = box.execute([[SELECT 1 + '2';]])
@@ -29,7 +29,7 @@ g.test_sub = function()
     g.server:exec(function()
         local t = require('luatest')
         local res = [[Type mismatch: can not convert string('1') to ]]..
-                    [[integer, decimal or double]]
+                    [[integer, decimal, double, datetime or interval]]
         local _, err = box.execute([[SELECT '1' - '2';]])
         t.assert_equals(err.message, res)
         _, err = box.execute([[SELECT 1 - '2';]])

test/sql-luatest/interval_test.lua

@@ -1242,9 +1242,8 @@ g.test_interval_23_2 = function()
     g.server:exec(function()
         local t = require('luatest')
         local sql = [[SELECT itv + 1 FROM t0;]]
-        local res = [[Type mismatch: can not convert ]]..
-                    [[interval(+1 years, 2 months, 3 days, 4 hours) to ]]..
-                    [[integer, decimal or double]]
+        local res = [[Type mismatch: can not convert integer(1) to datetime ]]..
+                    [[or interval]]
         local _, err = box.execute(sql)
         t.assert_equals(err.message, res)
     end)
@@ -1254,9 +1253,7 @@ g.test_interval_23_3 = function()
     g.server:exec(function()
         local t = require('luatest')
         local sql = [[SELECT itv - 1 FROM t0;]]
-        local res = [[Type mismatch: can not convert ]]..
-                    [[interval(+1 years, 2 months, 3 days, 4 hours) to ]]..
-                    [[integer, decimal or double]]
+        local res = [[Type mismatch: can not convert integer(1) to interval]]
         local _, err = box.execute(sql)
         t.assert_equals(err.message, res)
     end)

test/sql-tap/array.test.lua

@@ -473,7 +473,7 @@ test:do_catchsql_test(
         SELECT a3(1, 2, 3) + 1;
     ]], {
         1, "Type mismatch: can not convert array([1, 2, 3]) to integer, "..
-           "decimal or double"
+           "decimal, double, datetime or interval"
     })
 
 test:do_catchsql_test(
@@ -482,7 +482,7 @@ test:do_catchsql_test(
         SELECT a3(1, 2, 3) - 1;
     ]], {
         1, "Type mismatch: can not convert array([1, 2, 3]) to integer, "..
-           "decimal or double"
+           "decimal, double, datetime or interval"
     })
 
 test:do_catchsql_test(