Bug#32552332 - CAN'T WRITE; DUPLICATE KEY IN TABLE '/TMP/#SQL...'

In the case of a query that uses temporary table for aggregation,
the group-by Item is used as the unique constraint of the temporary
table.

If the group-by Item value is already present, the row is updated.
Otherwise, a new row is inserted into the temporary table.

If the group-by Item is an Item with a result field(like Item_func)
or a reference Item, it gets evaluated twice. Once to check if the
result exists in the temporary table and if not, again while
constructing the row to insert.

If the group-by item is non-deterministic, the result value used to
check for existence would be different from the value with which an
insert is tried. This causes the insert to fail if the value already
exists in the table.

Fix:

If any of the group-by Items are non-deterministic, use the hash of
the group-by Items as the unique constraint of the temporary table as
the hash gets evaluated only once.

Change-Id: I7004f298dc0ea84d760903c30af8f08e072a3f2d

Author: Maheedhar PV

mysql-test/r/func_group.result

@@ -1941,3 +1941,38 @@ FROM t1 t GROUP BY t1.a)
 0
 0
 DROP TABLE t1;
+#
+# Bug#32552332 - CAN'T WRITE; DUPLICATE KEY IN TABLE '/TMP/#SQL...'
+#
+CREATE TABLE tr (c1 INT);
+INSERT INTO tr VALUES (1);
+CREATE FUNCTION seq_1_to_2() RETURNS INT
+BEGIN
+DECLARE limit_value, return_value INT;
+SET limit_value = 2;
+SELECT c1 INTO return_value FROM tr;
+IF (return_value < limit_value) THEN
+UPDATE tr SET c1 = c1 + 1;
+ELSE
+UPDATE tr SET c1 = 1;
+END IF;
+RETURN (return_value);
+END|
+CREATE TABLE t1 (c1 INT);
+INSERT INTO t1 VALUES (10);
+INSERT INTO t1 VALUES (11);
+SELECT seq_1_to_2() as seq, COUNT(*) FROM t1 GROUP BY seq;
+seq	COUNT(*)
+1	1
+2	1
+SELECT FLOOR(seq_1_to_2() * 2) AS val, COUNT(*) FROM t1 GROUP BY val;
+val	COUNT(*)
+2	1
+4	1
+SELECT val, COUNT(*) FROM (SELECT FLOOR(seq_1_to_2())+1 val FROM t1) x
+GROUP BY x.val;
+val	COUNT(*)
+2	1
+3	1
+DROP TABLE t1, tr;
+DROP FUNCTION seq_1_to_2;

mysql-test/t/func_group.test

@@ -1240,3 +1240,38 @@ WHERE 0 = (SELECT group_concat(b)
            FROM t1 t GROUP BY t1.a)
 ;
 DROP TABLE t1;
+
+--echo #
+--echo # Bug#32552332 - CAN'T WRITE; DUPLICATE KEY IN TABLE '/TMP/#SQL...'
+--echo #
+
+CREATE TABLE tr (c1 INT);
+INSERT INTO tr VALUES (1);
+
+# Generates a integer sequence from 1 to 2 and repeats
+DELIMITER |;
+CREATE FUNCTION seq_1_to_2() RETURNS INT
+BEGIN
+  DECLARE limit_value, return_value INT;
+  SET limit_value = 2;
+  SELECT c1 INTO return_value FROM tr;
+  IF (return_value < limit_value) THEN
+     UPDATE tr SET c1 = c1 + 1;
+  ELSE
+     UPDATE tr SET c1 = 1;
+  END IF;
+  RETURN (return_value);
+END|
+DELIMITER ;|
+
+CREATE TABLE t1 (c1 INT);
+INSERT INTO t1 VALUES (10);
+INSERT INTO t1 VALUES (11);
+
+SELECT seq_1_to_2() as seq, COUNT(*) FROM t1 GROUP BY seq;
+SELECT FLOOR(seq_1_to_2() * 2) AS val, COUNT(*) FROM t1 GROUP BY val;
+SELECT val, COUNT(*) FROM (SELECT FLOOR(seq_1_to_2())+1 val FROM t1) x
+  GROUP BY x.val;
+
+DROP TABLE t1, tr;
+DROP FUNCTION seq_1_to_2;

sql/item.h

@@ -1663,9 +1663,16 @@ class Item : public Parse_tree_node
     Returns true if this is constant but its value may be not known yet.
     (Can be used for parameters of prep. stmts or of stored procedures.)
   */
-  virtual bool const_during_execution() const 
+  virtual bool const_during_execution() const
   { return (used_tables() & ~PARAM_TABLE_BIT) == 0; }
 
+  /**
+    @returns true if this item is non-deterministic, which means that a
+             has a component that must be evaluated once per row in
+             execution of a JOIN query.
+  */
+  bool is_non_deterministic() const { return used_tables() & RAND_TABLE_BIT; }
+
   /**
     This method is used for to:
       - to generate a view definition query (SELECT-statement);

sql/sql_tmp_table.cc

@@ -745,8 +745,15 @@ create_tmp_table(THD *thd, Temp_table_param *param, List<Item> &fields,
       (*tmp->item)->marker= 4;
       const uint char_len=
         (*tmp->item)->max_length / (*tmp->item)->collation.collation->mbmaxlen;
-      if (char_len > CONVERT_IF_BIGGER_TO_BLOB)
+      /*
+        Use hash key as the unique constraint if the group-by key is
+        big or if it is non-deterministic. Group-by items get evaluated
+        twice and a non-deterministic function would cause a discrepancy.
+      */
+      if (char_len > CONVERT_IF_BIGGER_TO_BLOB ||
+          (*tmp->item)->is_non_deterministic()) {
         using_unique_constraint= true;
+      }
     }
     if (group)
     {