Bug#32824429 - SIGNAL 11 / VIRTUAL LONGLONG ITEM_FUNC_IN::VAL_INT():

		ASSERTION `IN_ITEM'

Problem:
	Floating point literal in query was identified as real number,
	then converted to zerofilled string to compare with
	zerofilled float column.
	Due to being identified as a real number the comparison was
	attempted in a real context, even after the value was converted
	to string.
Solution:
	Convert zerofill numbers to zerofilled Item_string only when
	used in a string context, eg. concat or comparing with a string
	constant.

(cherry picked from commit ce4d1d1b605535db3f00bedc810bce93e7b7ccc0)
Change-Id: Id1e3ddcb917471258ca5e003e075fcb0b4a09b21

Author: mbremyk

mysql-test/r/myisam_icp.result

@@ -599,7 +599,7 @@ id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered
 3	SUBQUERY	t3	NULL	system	NULL	NULL	NULL	NULL	1	100.00	NULL
 Warnings:
 Note	1276	Field or reference 'test.t1.c1' of SELECT #2 was resolved in SELECT #1
-Note	1003	/* select#1 */ select '2' AS `i1` from dual where exists(/* select#2 */ select `test`.`t2`.`c1` from `test`.`t2` where ((`test`.`t2`.`c1` = 'v') and (`test`.`t2`.`c2` = (/* select#3 */ select min('v') from dual))))
+Note	1003	/* select#1 */ select '2' AS `i1` from dual where exists(/* select#2 */ select `test`.`t2`.`c1` from `test`.`t2` where ((`test`.`t2`.`c1` = 'v') and (`test`.`t2`.`c2` = (/* select#3 */ select min('v') from dual)) and ((/* select#3 */ select min('v') from dual) <> 'w')))
 SELECT i1
 FROM t1
 WHERE EXISTS (SELECT t2.c1

mysql-test/r/myisam_icp_all.result

@@ -599,7 +599,7 @@ id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered
 3	SUBQUERY	t3	NULL	system	NULL	NULL	NULL	NULL	1	100.00	NULL
 Warnings:
 Note	1276	Field or reference 'test.t1.c1' of SELECT #2 was resolved in SELECT #1
-Note	1003	/* select#1 */ select '2' AS `i1` from dual where exists(/* select#2 */ select `test`.`t2`.`c1` from `test`.`t2` where ((`test`.`t2`.`c1` = 'v') and (`test`.`t2`.`c2` = (/* select#3 */ select min('v') from dual))))
+Note	1003	/* select#1 */ select '2' AS `i1` from dual where exists(/* select#2 */ select `test`.`t2`.`c1` from `test`.`t2` where ((`test`.`t2`.`c1` = 'v') and (`test`.`t2`.`c2` = (/* select#3 */ select min('v') from dual)) and ((/* select#3 */ select min('v') from dual) <> 'w')))
 SELECT i1
 FROM t1
 WHERE EXISTS (SELECT t2.c1

mysql-test/r/myisam_icp_none.result

@@ -598,7 +598,7 @@ id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered
 3	SUBQUERY	t3	NULL	system	NULL	NULL	NULL	NULL	1	100.00	NULL
 Warnings:
 Note	1276	Field or reference 'test.t1.c1' of SELECT #2 was resolved in SELECT #1
-Note	1003	/* select#1 */ select '2' AS `i1` from dual where exists(/* select#2 */ select `test`.`t2`.`c1` from `test`.`t2` where ((`test`.`t2`.`c1` = 'v') and (`test`.`t2`.`c2` = (/* select#3 */ select min('v') from dual))))
+Note	1003	/* select#1 */ select '2' AS `i1` from dual where exists(/* select#2 */ select `test`.`t2`.`c1` from `test`.`t2` where ((`test`.`t2`.`c1` = 'v') and (`test`.`t2`.`c2` = (/* select#3 */ select min('v') from dual)) and ((/* select#3 */ select min('v') from dual) <> 'w')))
 SELECT i1
 FROM t1
 WHERE EXISTS (SELECT t2.c1

mysql-test/suite/opt_trace/r/subquery_no_prot.result

@@ -431,6 +431,18 @@ t1.a= (SELECT a FROM t2 LIMIT 1)	{
               "steps": [
                 {
                   "transformation": "equality_propagation",
+                  "subselect_evaluation": [
+                  ] /* subselect_evaluation */,
+                  "resulting_condition": "(((/* select#2 */ select `t2`.`b` from `t2` limit 1) <> (/* select#3 */ select `t2`.`a` from `t2` limit 1)) and multiple equal((/* select#2 */ select `t2`.`b` from `t2` limit 1), `t1`.`a`))"
+                },
+                {
+                  "transformation": "constant_propagation",
+                  "subselect_evaluation": [
+                  ] /* subselect_evaluation */,
+                  "resulting_condition": "(((/* select#2 */ select `t2`.`b` from `t2` limit 1) <> (/* select#3 */ select `t2`.`a` from `t2` limit 1)) and multiple equal((/* select#2 */ select `t2`.`b` from `t2` limit 1), `t1`.`a`))"
+                },
+                {
+                  "transformation": "trivial_condition_removal",
                   "subselect_evaluation": [
                     {
                       "subselect_execution": {
@@ -477,27 +489,8 @@ t1.a= (SELECT a FROM t2 LIMIT 1)	{
                           }
                         ] /* steps */
                       } /* subselect_execution */
-                    },
-                    {
-                      "subselect_execution": {
-                        "select#": 2,
-                        "steps": [
-                        ] /* steps */
-                      } /* subselect_execution */
                     }
                   ] /* subselect_evaluation */,
-                  "resulting_condition": "((NULL <> (/* select#3 */ select `t2`.`a` from `t2` limit 1)) and multiple equal((/* select#2 */ select NULL from `t2` limit 1), `t1`.`a`))"
-                },
-                {
-                  "transformation": "constant_propagation",
-                  "subselect_evaluation": [
-                  ] /* subselect_evaluation */,
-                  "resulting_condition": "((NULL <> (/* select#3 */ select `t2`.`a` from `t2` limit 1)) and multiple equal((/* select#2 */ select NULL from `t2` limit 1), `t1`.`a`))"
-                },
-                {
-                  "transformation": "trivial_condition_removal",
-                  "subselect_evaluation": [
-                  ] /* subselect_evaluation */,
                   "resulting_condition": null
                 }
               ] /* steps */

mysql-test/suite/opt_trace/r/subquery_ps_prot.result

@@ -431,6 +431,18 @@ t1.a= (SELECT a FROM t2 LIMIT 1)	{
               "steps": [
                 {
                   "transformation": "equality_propagation",
+                  "subselect_evaluation": [
+                  ] /* subselect_evaluation */,
+                  "resulting_condition": "(((/* select#2 */ select `t2`.`b` from `t2` limit 1) <> (/* select#3 */ select `t2`.`a` from `t2` limit 1)) and multiple equal((/* select#2 */ select `t2`.`b` from `t2` limit 1), `t1`.`a`))"
+                },
+                {
+                  "transformation": "constant_propagation",
+                  "subselect_evaluation": [
+                  ] /* subselect_evaluation */,
+                  "resulting_condition": "(((/* select#2 */ select `t2`.`b` from `t2` limit 1) <> (/* select#3 */ select `t2`.`a` from `t2` limit 1)) and multiple equal((/* select#2 */ select `t2`.`b` from `t2` limit 1), `t1`.`a`))"
+                },
+                {
+                  "transformation": "trivial_condition_removal",
                   "subselect_evaluation": [
                     {
                       "subselect_execution": {
@@ -486,18 +498,6 @@ t1.a= (SELECT a FROM t2 LIMIT 1)	{
                       } /* subselect_execution */
                     }
                   ] /* subselect_evaluation */,
-                  "resulting_condition": "((NULL <> (/* select#3 */ select `t2`.`a` from `t2` limit 1)) and multiple equal((/* select#2 */ select NULL from `t2` limit 1), `t1`.`a`))"
-                },
-                {
-                  "transformation": "constant_propagation",
-                  "subselect_evaluation": [
-                  ] /* subselect_evaluation */,
-                  "resulting_condition": "((NULL <> (/* select#3 */ select `t2`.`a` from `t2` limit 1)) and multiple equal((/* select#2 */ select NULL from `t2` limit 1), `t1`.`a`))"
-                },
-                {
-                  "transformation": "trivial_condition_removal",
-                  "subselect_evaluation": [
-                  ] /* subselect_evaluation */,
                   "resulting_condition": null
                 }
               ] /* steps */

sql/item.cc

@@ -6187,16 +6187,15 @@ static void convert_zerofill_number_to_string(Item **item, Field_num *field)
 
 
 /**
-  Set a pointer to the multiple equality the field reference belongs to
-  (if any).
+  If field matches a multiple equality, set a pointer to that object in the
+  field. Also return a pointer to a constant value that can be substituted for
+  a field (if any).
 
-  The function looks for a multiple equality containing the field item
-  among those referenced by arg.
-  In the case such equality exists the function does the following.
-  If the found multiple equality contains a constant, then the field
-  reference is substituted for this constant, otherwise it sets a pointer
-  to the multiple equality in the field item.
+  A constant value is returned only if certain conditions are met (see
+  implementation).
 
+  In addition, a numeric field with a zerofill attribute can be substituted
+  with a zerofilled value if it is to be used in a character string context.
 
   @param arg    reference to list of multiple equalities where
                 the field (this object) is to be looked for
@@ -6210,37 +6209,35 @@ static void convert_zerofill_number_to_string(Item **item, Field_num *field)
     - pointer to the field item, otherwise.
 */
 
-Item *Item_field::equal_fields_propagator(uchar *arg)
-{
-  if (no_const_subst)
-    return this;
+Item *Item_field::equal_fields_propagator(uchar *arg) {
+  if (no_const_subst) return this;
   item_equal= find_item_equal((COND_EQUAL *) arg);
   Item *item= 0;
-  if (item_equal)
-    item= item_equal->get_const();
+  if (item_equal) item = item_equal->get_const();
   /*
-    Disable const propagation for items used in different comparison contexts.
-    This must be done because, for example, Item_hex_string->val_int() is not
-    the same as (Item_hex_string->val_str() in BINARY column)->val_int().
-    We cannot simply disable the replacement in a particular context (
-    e.g. <bin_col> = <int_col> AND <bin_col> = <hex_string>) since
-    Items don't know the context they are in and there are functions like 
-    IF (<hex_string>, 'yes', 'no').
+    Disable const propagation if the constant is nullable and this item is not.
+    If propagation was allowed in this case, it would also be necessary to
+    propagate the new nullability up to the parents of this item.
   */
-  if (!item || !has_compatible_context(item))
-    item= this;
-  else if (field && (field->flags & ZEROFILL_FLAG) && IS_NUM(field->type()))
-  {
+  if (!item || (item->maybe_null && !maybe_null)) {
+    return this;
+  }
+  if ((field->flags & ZEROFILL_FLAG) && cmp_context == STRING_RESULT &&
+      IS_NUM(field->type())) {
     /*
-      We don't need to zero-fill timestamp columns here because they will be 
-      first converted to a string (in date/time format) and compared as such if
-      compared with another string.
+      Convert numeric constant to a zero-filled string if the field has
+      the zerofill property and is wanted in a string context.
     */
-    if (item && field->type() != FIELD_TYPE_TIMESTAMP && cmp_context != INT_RESULT
-        && item->real_item()->type() != Item::REAL_ITEM)
-      convert_zerofill_number_to_string(&item, (Field_num *)field);
-    else
-      item= this;
+    convert_zerofill_number_to_string(&item, down_cast<Field_num *>(field));
+    return item;
+  }
+  if (!has_compatible_context(item)) {
+    /*
+      If the field does not have the zerofill property, the items must have
+      compatible comparison contexts, otherwise the resolved metadata for
+      the items and the referencing objects might become invalid.
+    */
+    return this;
   }
   return item;
 }

sql/item.h

@@ -2181,18 +2181,24 @@ class Item : public Parse_tree_node
             compared as DATETIME values by the Arg_comparator.
       FALSE otherwise.
   */
-  inline bool has_compatible_context(Item *item) const
-  {
-    /* Same context. */
-    if (cmp_context == (Item_result)-1 || item->cmp_context == cmp_context)
+  inline bool has_compatible_context(Item *item) const {
+    // If no explicit context has been set, assume the same type as the item
+    const Item_result this_context =
+        cmp_context == (Item_result)-1 ? result_type() : cmp_context;
+    const Item_result other_context = item->cmp_context == (Item_result)-1
+                                          ? item->result_type()
+                                          : item->cmp_context;
+
+    // Check if both items have the same context
+    if (this_context == other_context) {
       return TRUE;
+    }
     /* DATETIME comparison context. */
     if (is_temporal_with_date())
-      return item->is_temporal_with_date() ||
-             item->cmp_context == STRING_RESULT;
+      return item->is_temporal_with_date() || other_context == STRING_RESULT;
     if (item->is_temporal_with_date())
-      return is_temporal_with_date() || cmp_context == STRING_RESULT;
-    return FALSE;
+      return is_temporal_with_date() || this_context == STRING_RESULT;
+    return false;
   }
   virtual Field::geometry_type get_geometry_type() const
     { return Field::GEOM_GEOMETRY; };

sql/item_strfunc.cc

@@ -967,9 +967,10 @@ void Item_func_concat::fix_length_and_dec()
   if (agg_arg_charsets_for_string_result(collation, args, arg_count))
     return;
 
-  for (uint i=0 ; i < arg_count ; i++)
+  for (uint i=0 ; i < arg_count ; i++) {
+    args[i]->cmp_context = STRING_RESULT;
     char_length+= args[i]->max_char_length();
-
+  }
   fix_char_length_ulonglong(char_length);
 }
 
@@ -1233,8 +1234,10 @@ void Item_func_concat_ws::fix_length_and_dec()
      so, (arg_count - 2) is safe here.
   */
   char_length= (ulonglong) args[0]->max_char_length() * (arg_count - 2);
-  for (uint i=1 ; i < arg_count ; i++)
+  for (uint i=1 ; i < arg_count ; i++) {
+    args[i]->cmp_context = STRING_RESULT;
     char_length+= args[i]->max_char_length();
+  }
 
   fix_char_length_ulonglong(char_length);
 }