Bug#35115909: Wrong join result when one of the join columns is compared to a temporal literal

kahatlen · kahatlen · commit 0aeb68207389 · 2023-03-03T09:50:07.000+01:00
Bug#35080094: MySQL server crash - Assertion CompatibleTypesForIndexLookup failed

This patch fixes two bugs:

1) Wrong results were seen in some case when one equality predicate
compared two string columns and another equality predicate compared
one of the string columns to a temporal constant. For example:

SELECT * FROM t WHERE a = b AND b = DATE'2023-01-01'

If a and b were VARCHAR columns with character set latin1, the
optimizer would propagate the DATE constant into the a = b predicate
and transform the query into:

SELECT * FROM t WHERE a = DATE'2023-01-01' AND b = DATE'2023-01-01'

The original a = b predicate would use string semantics for the
comparison, whereas the new a = DATE'2023-01-01' predicate uses DATE
semantics. The meaning of the query therefore changed, and wrong
results could be returned.

2) The hypergraph optimizer got an assertion failure when analyzing
which predicates were sargable. The assertion failure was seen if the
WHERE clause compared an indexed string column with a constant TIME
expression. It checked that all equality predicates that were part of
a multiple equality had arguments that were compatible for index
lookups.

Both of these issues were fixed by disabling creation of multiple
equalities from single equalities comparing a non-temporal string
column to a temporal constant.

Change-Id: Ibab64903eea83ce16ca4057154fa882a7e2b05f6
diff --git a/mysql-test/r/type_date.result b/mysql-test/r/type_date.result
@@ -697,3 +697,30 @@ d
 2021-10-11
 2021-10-11
 DROP TABLE d, dt;
+#
+# Bug#35080094: MySQL server crash -
+#               Assertion CompatibleTypesForIndexLookup failed
+#
+CREATE TABLE t(a VARCHAR(100) CHARSET latin1, KEY(a));
+INSERT INTO t VALUES ('2023-1-1'), ('2023-01-01');
+SELECT * FROM t WHERE a = DATE'2023-01-01';
+a
+2023-01-01
+2023-1-1
+DROP TABLE t;
+#
+# Bug#35115909: Wrong join result when one of the join columns
+#               is compared to a temporal literal
+#
+CREATE TABLE t (a VARCHAR(10) CHARSET latin1,
+b VARCHAR(10) CHARSET latin1);
+INSERT INTO t VALUES
+('2023-01-01', '2023-01-01'),
+('2023-01-01', '2023-1-1'),
+('2023-1-1',   '2023-01-01'),
+('2023-1-1',   '2023-1-1');
+SELECT * FROM t WHERE a = b and b = DATE'2023-01-01';
+a	b
+2023-01-01	2023-01-01
+2023-1-1	2023-1-1
+DROP TABLE t;
diff --git a/mysql-test/r/type_datetime.result b/mysql-test/r/type_datetime.result
@@ -1116,3 +1116,30 @@ SELECT * FROM t1 wHERE pk = 5 AND
 pk	col_date	col_datetime	col_varchar
 5	2022-02-25	2022-02-25 11:01:14	I
 DROP TABLE t1;
+#
+# Bug#35080094: MySQL server crash -
+#               Assertion CompatibleTypesForIndexLookup failed
+#
+CREATE TABLE t(a VARCHAR(100) CHARSET latin1, KEY(a));
+INSERT INTO t VALUES ('2023-1-1 1:2:3'), ('2023-01-01 01:02:03');
+SELECT * FROM t WHERE a = TIMESTAMP'2023-01-01 01:02:03';
+a
+2023-01-01 01:02:03
+2023-1-1 1:2:3
+DROP TABLE t;
+#
+# Bug#35115909: Wrong join result when one of the join columns
+#               is compared to a temporal literal
+#
+CREATE TABLE t (a VARCHAR(30) CHARSET latin1,
+b VARCHAR(30) CHARSET latin1);
+INSERT INTO t VALUES
+('2023-01-01 01:02:03', '2023-01-01 01:02:03'),
+('2023-01-01 01:02:03', '2023-1-1 1:2:3'),
+('2023-1-1 1:2:3',      '2023-01-01 01:02:03'),
+('2023-1-1 1:2:3',      '2023-1-1 1:2:3');
+SELECT * FROM t WHERE a = b and b = TIMESTAMP'2023-01-01 01:02:03';
+a	b
+2023-01-01 01:02:03	2023-01-01 01:02:03
+2023-1-1 1:2:3	2023-1-1 1:2:3
+DROP TABLE t;
diff --git a/mysql-test/r/type_time.result b/mysql-test/r/type_time.result
@@ -2858,3 +2858,27 @@ t
 02:00:00
 02:00:00
 DROP TABLE t, dt;
+#
+# Bug#35080094: MySQL server crash -
+#               Assertion CompatibleTypesForIndexLookup failed
+#
+CREATE TABLE t(a VARCHAR(100), KEY(a));
+INSERT INTO t VALUES ('1:2:3'), ('01:02:03');
+SELECT * FROM t WHERE a = TIME'01:02:03';
+a
+01:02:03
+DROP TABLE t;
+#
+# Bug#35115909: Wrong join result when one of the join columns
+#               is compared to a temporal literal
+#
+CREATE TABLE t (a VARCHAR(10), b VARCHAR(10));
+INSERT INTO t VALUES
+('01:02:03', '01:02:03'),
+('01:02:03', '1:2:3'),
+('1:2:3',    '01:02:03'),
+('1:2:3',    '1:2:3');
+SELECT * FROM t WHERE a = b and b = TIME'01:02:03';
+a	b
+01:02:03	01:02:03
+DROP TABLE t;
diff --git a/mysql-test/t/type_date.test b/mysql-test/t/type_date.test
@@ -575,3 +575,31 @@ SELECT * FROM d;
 
 DROP TABLE d, dt;
 
+--echo #
+--echo # Bug#35080094: MySQL server crash -
+--echo #               Assertion CompatibleTypesForIndexLookup failed
+--echo #
+
+CREATE TABLE t(a VARCHAR(100) CHARSET latin1, KEY(a));
+INSERT INTO t VALUES ('2023-1-1'), ('2023-01-01');
+--sorted_result
+SELECT * FROM t WHERE a = DATE'2023-01-01';
+DROP TABLE t;
+
+--echo #
+--echo # Bug#35115909: Wrong join result when one of the join columns
+--echo #               is compared to a temporal literal
+--echo #
+
+CREATE TABLE t (a VARCHAR(10) CHARSET latin1,
+                b VARCHAR(10) CHARSET latin1);
+INSERT INTO t VALUES
+  ('2023-01-01', '2023-01-01'),
+  ('2023-01-01', '2023-1-1'),
+  ('2023-1-1',   '2023-01-01'),
+  ('2023-1-1',   '2023-1-1');
+# Used to return four rows. Should return only those two rows that
+# satisfy the a=b predicate.
+--sorted_result
+SELECT * FROM t WHERE a = b and b = DATE'2023-01-01';
+DROP TABLE t;
diff --git a/mysql-test/t/type_datetime.test b/mysql-test/t/type_datetime.test
@@ -834,3 +834,32 @@ SELECT * FROM t1 wHERE pk = 5 AND
 (col_varchar, col_date) IN (('I','2022-02-25'), ('I', '2022-02-25'));
 
 DROP TABLE t1;
+
+--echo #
+--echo # Bug#35080094: MySQL server crash -
+--echo #               Assertion CompatibleTypesForIndexLookup failed
+--echo #
+
+CREATE TABLE t(a VARCHAR(100) CHARSET latin1, KEY(a));
+INSERT INTO t VALUES ('2023-1-1 1:2:3'), ('2023-01-01 01:02:03');
+--sorted_result
+SELECT * FROM t WHERE a = TIMESTAMP'2023-01-01 01:02:03';
+DROP TABLE t;
+
+--echo #
+--echo # Bug#35115909: Wrong join result when one of the join columns
+--echo #               is compared to a temporal literal
+--echo #
+
+CREATE TABLE t (a VARCHAR(30) CHARSET latin1,
+                b VARCHAR(30) CHARSET latin1);
+INSERT INTO t VALUES
+  ('2023-01-01 01:02:03', '2023-01-01 01:02:03'),
+  ('2023-01-01 01:02:03', '2023-1-1 1:2:3'),
+  ('2023-1-1 1:2:3',      '2023-01-01 01:02:03'),
+  ('2023-1-1 1:2:3',      '2023-1-1 1:2:3');
+# Used to return four rows. Should return only those two rows that
+# satisfy the a=b predicate.
+--sorted_result
+SELECT * FROM t WHERE a = b and b = TIMESTAMP'2023-01-01 01:02:03';
+DROP TABLE t;
diff --git a/mysql-test/t/type_time.test b/mysql-test/t/type_time.test
@@ -540,3 +540,36 @@ execute s using @dt;
 SELECT * FROM t;
 
 DROP TABLE t, dt;
+
+--echo #
+--echo # Bug#35080094: MySQL server crash -
+--echo #               Assertion CompatibleTypesForIndexLookup failed
+--echo #
+
+CREATE TABLE t(a VARCHAR(100), KEY(a));
+INSERT INTO t VALUES ('1:2:3'), ('01:02:03');
+SELECT * FROM t WHERE a = TIME'01:02:03';
+DROP TABLE t;
+
+--echo #
+--echo # Bug#35115909: Wrong join result when one of the join columns
+--echo #               is compared to a temporal literal
+--echo #
+
+# This test case is provided for completeness, based on the test cases
+# for the same bug number in type_date and type_datetime, even though
+# the bug that was seen with DATE and DATETIME was not seen with TIME.
+CREATE TABLE t (a VARCHAR(10), b VARCHAR(10));
+INSERT INTO t VALUES
+  ('01:02:03', '01:02:03'),
+  ('01:02:03', '1:2:3'),
+  ('1:2:3',    '01:02:03'),
+  ('1:2:3',    '1:2:3');
+# The main point of this test case is to verify that the a=b predicate
+# uses string comparison and excludes the second and third row from
+# the result. The query currently returns the first row only. It would
+# have been more consistent with DATE and DATETIME if it had returned
+# both the first and the fourth row (see the test cases for the same
+# bug number in type_date and type_datetime).
+SELECT * FROM t WHERE a = b and b = TIME'01:02:03';
+DROP TABLE t;
diff --git a/sql/sql_optimizer.cc b/sql/sql_optimizer.cc
@@ -3949,6 +3949,11 @@ static bool check_simple_equality(THD *thd, Item *left_item, Item *right_item,
             (const_item->data_type() == MYSQL_TYPE_JSON)) {
           return false;
         }
+        // Similarly, strings and temporal types have different semantics for
+        // equality comparison.
+        if (const_item->is_temporal() && !field_item->is_temporal()) {
+          return false;
+        }
       }
 
       bool copyfl;

Original file line number	Diff line number	Diff line change
`@@ -3949,6 +3949,11 @@ static bool check_simple_equality(THD thd, Item left_item, Item *right_item,`
`3949`	`3949`	`(const_item->data_type() == MYSQL_TYPE_JSON)) {`
`3950`	`3950`	`return false;`
`3951`	`3951`	`}`
	`3952`	`+ // Similarly, strings and temporal types have different semantics for`
	`3953`	`+ // equality comparison.`
	`3954`	`+ if (const_item->is_temporal() && !field_item->is_temporal()) {`
	`3955`	`+ return false;`
	`3956`	`+ }`
`3952`	`3957`	`}`
`3953`	`3958`
`3954`	`3959`	`bool copyfl;`