sql: check left operand before right in arithmetic

Prior to this patch, the right operand was checked before the left. This
can lead to some complications when arithmetic operations are added for
the DATETIME and INTERVAL values. To avoid this, let's check the left
operand before the right one. This will cause the description of the
error to change, but nothing else.

Needed for tarantool#6773

NO_DOC=Not documented feature.

Author: ImeevMA

changelogs/unreleased/gh-6773-arithmetic-operands.md

@@ -0,0 +1,4 @@
+## feature/sql
+
+* The left operand is now checked before the right operand in an arithmetic
+  operation. (gh-6773).

src/box/sql/mem.c

@@ -2009,7 +2009,7 @@ mem_add(const struct Mem *left, const struct Mem *right, struct Mem *result)
 		mem_set_null(result);
 		return 0;
 	}
-	if (check_types_numeric_arithmetic(right, left) != 0)
+	if (check_types_numeric_arithmetic(left, right) != 0)
 		return -1;
 	if (((left->type | right->type) & MEM_TYPE_DOUBLE) != 0) {
 		double a;
@@ -2051,7 +2051,7 @@ mem_sub(const struct Mem *left, const struct Mem *right, struct Mem *result)
 		mem_set_null(result);
 		return 0;
 	}
-	if (check_types_numeric_arithmetic(right, left) != 0)
+	if (check_types_numeric_arithmetic(left, right) != 0)
 		return -1;
 	if (((left->type | right->type) & MEM_TYPE_DOUBLE) != 0) {
 		double a;
@@ -2093,7 +2093,7 @@ mem_mul(const struct Mem *left, const struct Mem *right, struct Mem *result)
 		mem_set_null(result);
 		return 0;
 	}
-	if (check_types_numeric_arithmetic(right, left) != 0)
+	if (check_types_numeric_arithmetic(left, right) != 0)
 		return -1;
 	if (((left->type | right->type) & MEM_TYPE_DOUBLE) != 0) {
 		double a;
@@ -2135,7 +2135,7 @@ mem_div(const struct Mem *left, const struct Mem *right, struct Mem *result)
 		mem_set_null(result);
 		return 0;
 	}
-	if (check_types_numeric_arithmetic(right, left) != 0)
+	if (check_types_numeric_arithmetic(left, right) != 0)
 		return -1;
 	if (((left->type | right->type) & MEM_TYPE_DOUBLE) != 0) {
 		double a;
@@ -2193,13 +2193,13 @@ mem_rem(const struct Mem *left, const struct Mem *right, struct Mem *result)
 		mem_set_null(result);
 		return 0;
 	}
-	if (!mem_is_int(right) || mem_is_metatype(right)) {
-		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(right),
+	if (!mem_is_int(left) || mem_is_metatype(left)) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(left),
 			 "integer");
 		return -1;
 	}
-	if (!mem_is_int(left) || mem_is_metatype(left)) {
-		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(left),
+	if (!mem_is_int(right) || mem_is_metatype(right)) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH, mem_str(right),
 			 "integer");
 		return -1;
 	}

test/sql-luatest/gh_6773_arithmetic_operands_test.lua

@@ -0,0 +1,80 @@
+local server = require('test.luatest_helpers.server')
+local t = require('luatest')
+local g = t.group()
+
+g.before_all(function()
+    g.server = server:new({alias = 'arithmetic_operands'})
+    g.server:start()
+end)
+
+g.after_all(function()
+    g.server:stop()
+end)
+
+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]]
+        local _, err = box.execute([[SELECT '1' + '2';]])
+        t.assert_equals(err.message, res)
+        _, err = box.execute([[SELECT 1 + '2';]])
+        res = [[Type mismatch: can not convert string('2') to integer, ]]..
+              [[decimal or double]]
+        t.assert_equals(err.message, res)
+    end)
+end
+
+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]]
+        local _, err = box.execute([[SELECT '1' - '2';]])
+        t.assert_equals(err.message, res)
+        _, err = box.execute([[SELECT 1 - '2';]])
+        res = [[Type mismatch: can not convert string('2') to integer, ]]..
+              [[decimal or double]]
+        t.assert_equals(err.message, res)
+    end)
+end
+
+g.test_mul = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local res = [[Type mismatch: can not convert string('1') to ]]..
+                    [[integer, decimal or double]]
+        local _, err = box.execute([[SELECT '1' * '2';]])
+        t.assert_equals(err.message, res)
+        _, err = box.execute([[SELECT 1 * '2';]])
+        res = [[Type mismatch: can not convert string('2') to integer, ]]..
+              [[decimal or double]]
+        t.assert_equals(err.message, res)
+    end)
+end
+
+g.test_div = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local res = [[Type mismatch: can not convert string('1') to ]]..
+                    [[integer, decimal or double]]
+        local _, err = box.execute([[SELECT '1' / '2';]])
+        t.assert_equals(err.message, res)
+        _, err = box.execute([[SELECT 1 / '2';]])
+        res = [[Type mismatch: can not convert string('2') to integer, ]]..
+              [[decimal or double]]
+        t.assert_equals(err.message, res)
+    end)
+end
+
+g.test_rem = function()
+    g.server:exec(function()
+        local t = require('luatest')
+        local res = [[Type mismatch: can not convert string('1') to integer]]
+        local _, err = box.execute([[SELECT '1' % '2';]])
+        t.assert_equals(err.message, res)
+        _, err = box.execute([[SELECT 1 % '2';]])
+        res = [[Type mismatch: can not convert string('2') to integer]]
+        t.assert_equals(err.message, res)
+    end)
+end

test/sql-tap/tkt-a8a0d2996a.test.lua

@@ -138,7 +138,8 @@ test:do_catchsql_test(
         SELECT '1.23e64'/'1.0000e+62';
     ]], {
         -- <4.1>
-        1, "Type mismatch: can not convert string('1.0000e+62') to integer, decimal or double"
+        1, "Type mismatch: can not convert string('1.23e64') to integer, "..
+           "decimal or double"
         -- </4.1>
     })