Bug#21770798: OPTIMIZER DOES NOT USE INDEX FOR GENERATED EXPRESSIONS

kahatlen · kahatlen · commit 195bc49c1156 · 2015-09-09T20:06:06.000+02:00
WITH LOGICAL OPERATORS

Before this patch, only expressions with item type ITEM_FUNC were
eligible for substitution with an equivalent generated column. AND and
OR expressions have item type ITEM_COND, and such expressions were
therefore not replaced with a generated column.

For example, a predicate such as (a AND b) = 1 would not be replaced
with gcol = 1, even if there was an indexed generated column gcol
whose generation expression was (a AND b). This meant that some
opportunities for using an index were missed.

This patch enables substitution also for expressions that use AND or
OR.

Since the substitution code works on Item_func objects, and items of
type COND_ITEM already belong to subclasses of Item_func, not much has
to be changed in the substitution logic. The patch mainly loosens up
some type checks to allow both FUNC_ITEM and COND_ITEM to be
substituted. It also adds an override of eq() in Item_cond to make it
possible to check if two logical expressions are equal.
diff --git a/mysql-test/suite/gcol/inc/gcol_keys.inc b/mysql-test/suite/gcol/inc/gcol_keys.inc
@@ -694,3 +694,44 @@ DROP TABLE t;
 }
 
 --echo #
+--echo # Bug#21770798 OPTIMIZER DOES NOT USE INDEX FOR GENERATED EXPRESSIONS
+--echo #              WITH LOGICAL OPERATORS
+--echo #
+CREATE TABLE t (a INT, b INT,
+                gc_and INT GENERATED ALWAYS AS (a AND b) STORED,
+                gc_or INT GENERATED ALWAYS AS (a OR b) STORED,
+                gc_xor INT GENERATED ALWAYS AS (a XOR b) STORED,
+                gc_not INT GENERATED ALWAYS AS (NOT a) STORED,
+                gc_case INT GENERATED ALWAYS AS
+                (CASE WHEN (a AND b) THEN a ELSE b END) STORED,
+                INDEX(gc_and), INDEX(gc_or), INDEX(gc_xor), INDEX(gc_not),
+                INDEX(gc_case));
+INSERT INTO t (a, b) VALUES (0, 0), (0, 1), (1, 0), (1, 1);
+ANALYZE TABLE t;
+EXPLAIN SELECT a, b FROM t WHERE (a AND b) = 1;
+SELECT a, b FROM t WHERE (a AND b) = 1;
+EXPLAIN SELECT a, b FROM t WHERE 1 = (a AND b);
+SELECT a, b FROM t WHERE 1 = (a AND b);
+EXPLAIN SELECT a, b FROM t WHERE (a AND b) IN (1, 2, 3);
+SELECT a, b FROM t WHERE (a AND b) IN (1, 2, 3);
+EXPLAIN SELECT a, b FROM t WHERE (a OR b) = 1;
+--sorted_result
+SELECT a, b FROM t WHERE (a OR b) = 1;
+EXPLAIN SELECT a, b FROM t WHERE (a OR b) BETWEEN 1 AND 10;
+--sorted_result
+SELECT a, b FROM t WHERE (a OR b) BETWEEN 1 AND 10;
+# XOR and NOT worked even before the bug fix, but we test all logical
+# operators here for completeness.
+EXPLAIN SELECT a, b FROM t WHERE (a XOR b) = 1;
+--sorted_result
+SELECT a, b FROM t WHERE (a XOR b) = 1;
+EXPLAIN SELECT a FROM t WHERE (NOT a) = 1;
+SELECT a FROM t WHERE (NOT a) = 1;
+# Also verify that a logical expression nested inside another
+# expression doesn't prevent substitution.
+EXPLAIN SELECT a FROM t WHERE (CASE WHEN (a AND b) THEN a ELSE b END) = 1;
+--sorted_result
+SELECT a FROM t WHERE (CASE WHEN (a AND b) THEN a ELSE b END) = 1;
+DROP TABLE t;
+
+--echo #
diff --git a/mysql-test/suite/gcol/r/gcol_keys_innodb.result b/mysql-test/suite/gcol/r/gcol_keys_innodb.result
@@ -1228,6 +1228,95 @@ ERROR 22012: Division by 0
 CALL mtr.add_suppression("\\[Warning\\] InnoDB: Compute virtual column values failed");
 DROP TABLE t;
 #
+# Bug#21770798 OPTIMIZER DOES NOT USE INDEX FOR GENERATED EXPRESSIONS
+#              WITH LOGICAL OPERATORS
+#
+CREATE TABLE t (a INT, b INT,
+gc_and INT GENERATED ALWAYS AS (a AND b) STORED,
+gc_or INT GENERATED ALWAYS AS (a OR b) STORED,
+gc_xor INT GENERATED ALWAYS AS (a XOR b) STORED,
+gc_not INT GENERATED ALWAYS AS (NOT a) STORED,
+gc_case INT GENERATED ALWAYS AS
+(CASE WHEN (a AND b) THEN a ELSE b END) STORED,
+INDEX(gc_and), INDEX(gc_or), INDEX(gc_xor), INDEX(gc_not),
+INDEX(gc_case));
+INSERT INTO t (a, b) VALUES (0, 0), (0, 1), (1, 0), (1, 1);
+ANALYZE TABLE t;
+Table	Op	Msg_type	Msg_text
+test.t	analyze	status	OK
+EXPLAIN SELECT a, b FROM t WHERE (a AND b) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_and	gc_and	5	const	1	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_and` = 1)
+SELECT a, b FROM t WHERE (a AND b) = 1;
+a	b
+1	1
+EXPLAIN SELECT a, b FROM t WHERE 1 = (a AND b);
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_and	gc_and	5	const	1	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (1 = `test`.`t`.`gc_and`)
+SELECT a, b FROM t WHERE 1 = (a AND b);
+a	b
+1	1
+EXPLAIN SELECT a, b FROM t WHERE (a AND b) IN (1, 2, 3);
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ALL	gc_and	NULL	NULL	NULL	4	75.00	Using where
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_and` in (1,2,3))
+SELECT a, b FROM t WHERE (a AND b) IN (1, 2, 3);
+a	b
+1	1
+EXPLAIN SELECT a, b FROM t WHERE (a OR b) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ALL	gc_or	NULL	NULL	NULL	4	75.00	Using where
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_or` = 1)
+SELECT a, b FROM t WHERE (a OR b) = 1;
+a	b
+0	1
+1	0
+1	1
+EXPLAIN SELECT a, b FROM t WHERE (a OR b) BETWEEN 1 AND 10;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ALL	gc_or	NULL	NULL	NULL	4	75.00	Using where
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_or` between 1 and 10)
+SELECT a, b FROM t WHERE (a OR b) BETWEEN 1 AND 10;
+a	b
+0	1
+1	0
+1	1
+EXPLAIN SELECT a, b FROM t WHERE (a XOR b) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_xor	gc_xor	5	const	2	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_xor` = 1)
+SELECT a, b FROM t WHERE (a XOR b) = 1;
+a	b
+0	1
+1	0
+EXPLAIN SELECT a FROM t WHERE (NOT a) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_not	gc_not	5	const	2	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a` from `test`.`t` where (`test`.`t`.`gc_not` = 1)
+SELECT a FROM t WHERE (NOT a) = 1;
+a
+0
+0
+EXPLAIN SELECT a FROM t WHERE (CASE WHEN (a AND b) THEN a ELSE b END) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_case	gc_case	5	const	2	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a` from `test`.`t` where (`test`.`t`.`gc_case` = 1)
+SELECT a FROM t WHERE (CASE WHEN (a AND b) THEN a ELSE b END) = 1;
+a
+0
+1
+DROP TABLE t;
+#
 #
 # BUG#21365158 WL8149:ASSERTION `!TABLE || (!TABLE->WRITE_SET 
 #
diff --git a/mysql-test/suite/gcol/r/gcol_keys_myisam.result b/mysql-test/suite/gcol/r/gcol_keys_myisam.result
@@ -800,6 +800,95 @@ Warnings:
 Note	1003	/* select#1 */ select ('7' + 1) AS `field1`,'7' AS `field2` from dual where 1 group by `col_int_gc_key`,`field2`
 DROP TABLE t1;
 #
+# Bug#21770798 OPTIMIZER DOES NOT USE INDEX FOR GENERATED EXPRESSIONS
+#              WITH LOGICAL OPERATORS
+#
+CREATE TABLE t (a INT, b INT,
+gc_and INT GENERATED ALWAYS AS (a AND b) STORED,
+gc_or INT GENERATED ALWAYS AS (a OR b) STORED,
+gc_xor INT GENERATED ALWAYS AS (a XOR b) STORED,
+gc_not INT GENERATED ALWAYS AS (NOT a) STORED,
+gc_case INT GENERATED ALWAYS AS
+(CASE WHEN (a AND b) THEN a ELSE b END) STORED,
+INDEX(gc_and), INDEX(gc_or), INDEX(gc_xor), INDEX(gc_not),
+INDEX(gc_case));
+INSERT INTO t (a, b) VALUES (0, 0), (0, 1), (1, 0), (1, 1);
+ANALYZE TABLE t;
+Table	Op	Msg_type	Msg_text
+test.t	analyze	status	OK
+EXPLAIN SELECT a, b FROM t WHERE (a AND b) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_and	gc_and	5	const	1	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_and` = 1)
+SELECT a, b FROM t WHERE (a AND b) = 1;
+a	b
+1	1
+EXPLAIN SELECT a, b FROM t WHERE 1 = (a AND b);
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_and	gc_and	5	const	1	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (1 = `test`.`t`.`gc_and`)
+SELECT a, b FROM t WHERE 1 = (a AND b);
+a	b
+1	1
+EXPLAIN SELECT a, b FROM t WHERE (a AND b) IN (1, 2, 3);
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ALL	gc_and	NULL	NULL	NULL	4	75.00	Using where
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_and` in (1,2,3))
+SELECT a, b FROM t WHERE (a AND b) IN (1, 2, 3);
+a	b
+1	1
+EXPLAIN SELECT a, b FROM t WHERE (a OR b) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_or	gc_or	5	const	2	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_or` = 1)
+SELECT a, b FROM t WHERE (a OR b) = 1;
+a	b
+0	1
+1	0
+1	1
+EXPLAIN SELECT a, b FROM t WHERE (a OR b) BETWEEN 1 AND 10;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	range	gc_or	gc_or	5	NULL	2	100.00	Using index condition
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_or` between 1 and 10)
+SELECT a, b FROM t WHERE (a OR b) BETWEEN 1 AND 10;
+a	b
+0	1
+1	0
+1	1
+EXPLAIN SELECT a, b FROM t WHERE (a XOR b) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_xor	gc_xor	5	const	2	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b` from `test`.`t` where (`test`.`t`.`gc_xor` = 1)
+SELECT a, b FROM t WHERE (a XOR b) = 1;
+a	b
+0	1
+1	0
+EXPLAIN SELECT a FROM t WHERE (NOT a) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_not	gc_not	5	const	2	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a` from `test`.`t` where (`test`.`t`.`gc_not` = 1)
+SELECT a FROM t WHERE (NOT a) = 1;
+a
+0
+0
+EXPLAIN SELECT a FROM t WHERE (CASE WHEN (a AND b) THEN a ELSE b END) = 1;
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t	NULL	ref	gc_case	gc_case	5	const	2	100.00	NULL
+Warnings:
+Note	1003	/* select#1 */ select `test`.`t`.`a` AS `a` from `test`.`t` where (`test`.`t`.`gc_case` = 1)
+SELECT a FROM t WHERE (CASE WHEN (a AND b) THEN a ELSE b END) = 1;
+a
+0
+1
+DROP TABLE t;
+#
 DROP VIEW  IF EXISTS v1,v2;
 DROP TABLE IF EXISTS t1,t2,t3;
 DROP PROCEDURE IF EXISTS p1;
diff --git a/sql/item.h b/sql/item.h
@@ -2212,6 +2212,16 @@ class Item : public Parse_tree_node
     Transformer function for GC substitution. @see JOIN::substitute_gc()
   */
   virtual Item *gc_subst_transformer(uchar *arg) { return this; }
+  /**
+    Check if this item is of a type that is eligible for GC
+    substitution. All items that belong to subclasses of Item_func are
+    eligible for substitution. @see JOIN::substitute_gc()
+  */
+  bool can_be_substituted_for_gc() const
+  {
+    const Type t= type();
+    return t == FUNC_ITEM || t == COND_ITEM;
+  }
 private:
   virtual bool subq_opt_away_processor(uchar *arg) { return false; }
 };
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
@@ -5795,6 +5795,24 @@ void Item_cond::fix_after_pullout(st_select_lex *parent_select,
 }
 
 
+bool Item_cond::eq(const Item *item, bool binary_cmp) const
+{
+  if (this == item)
+    return true;
+  if (item->type() != COND_ITEM)
+    return false;
+  const Item_cond *item_cond= down_cast<const Item_cond *>(item);
+  if (functype() != item_cond->functype() ||
+      arg_count != item_cond->arg_count ||
+      func_name() != item_cond->func_name())
+    return false;
+  for (size_t i= 0; i < arg_count; ++i)
+    if (!args[i]->eq(item_cond->args[i], binary_cmp))
+      return false;
+  return true;
+}
+
+
 bool Item_cond::walk(Item_processor processor, enum_walk walk, uchar *arg)
 {
   if ((walk & WALK_PREFIX) && (this->*processor)(arg))
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
@@ -2035,6 +2035,7 @@ class Item_cond :public Item_bool_func
 
   enum Type type() const { return COND_ITEM; }
   List<Item>* argument_list() { return &list; }
+  bool eq(const Item *item, bool binary_cmp) const;
   table_map used_tables() const { return used_tables_cache; }
   void update_used_tables();
   virtual void print(String *str, enum_query_type query_type);
diff --git a/sql/item_func.cc b/sql/item_func.cc
@@ -963,11 +963,11 @@ Item_field *get_gc_for_expr(Item_func **func, Field *fld, Item_result type)
   if (!strcmp(expr->func_name(),"json_unquote") &&
       strcmp((*func)->func_name(),"json_unquote"))
   {
-    if (expr->arguments()[0]->type() != Item::FUNC_ITEM)
+    if (!expr->arguments()[0]->can_be_substituted_for_gc())
       return NULL;
-    expr= (Item_func*)expr->arguments()[0];
+    expr= down_cast<Item_func*>(expr->arguments()[0]);
   }
-  DBUG_ASSERT(expr->type() == Item::FUNC_ITEM);
+  DBUG_ASSERT(expr->can_be_substituted_for_gc());
 
   if (type == fld->result_type() && (*func)->eq(expr, false))
   {
@@ -1016,12 +1016,12 @@ Item *Item_func::gc_subst_transformer(uchar *arg)
     List<Field> *gc_fields= (List<Field> *)arg;
     List_iterator<Field> li(*gc_fields);
     // Check if we can substitute a function with a GC
-    if (args[0]->type() == FUNC_ITEM && args[1]->const_item())
+    if (args[0]->can_be_substituted_for_gc() && args[1]->const_item())
     {
       func= (Item_func**)args;
       val= args + 1;
     }
-    else if (args[1]->type() == FUNC_ITEM && args[0]->const_item())
+    else if (args[1]->can_be_substituted_for_gc() && args[0]->const_item())
     {
       func= (Item_func**)args + 1;
       val= args;
@@ -1056,7 +1056,7 @@ Item *Item_func::gc_subst_transformer(uchar *arg)
   {
     List<Field> *gc_fields= (List<Field> *)arg;
     List_iterator<Field> li(*gc_fields);
-    if (args[0]->type() != FUNC_ITEM)
+    if (!args[0]->can_be_substituted_for_gc())
       break;
     Item_result type= args[1]->result_type();
     bool can_do_subst= args[1]->const_item();
diff --git a/sql/sql_optimizer.cc b/sql/sql_optimizer.cc
@@ -780,12 +780,13 @@ void JOIN::substitute_gc()
     for (uint i= 0; i < tl->table->s->fields; i++)
     {
       Field *fld= tl->table->field[i];
-      if (!fld->gcol_info || fld->part_of_key.is_clear_all() ||
-           fld->gcol_info->expr_item->type() != Item::FUNC_ITEM)
-        continue;
-      // Don't check allowed keys here as conditions/group/order use
-      // different keymaps for that
-      indexed_gc.push_back(fld);
+      if (fld->is_gcol() && !fld->part_of_key.is_clear_all() &&
+          fld->gcol_info->expr_item->can_be_substituted_for_gc())
+      {
+        // Don't check allowed keys here as conditions/group/order use
+        // different keymaps for that.
+        indexed_gc.push_back(fld);
+      }
     }
   }
   // No GC in the tables used in the query
@@ -824,7 +825,7 @@ void JOIN::substitute_gc()
   for (ORDER *ord= list; ord; ord= ord->next)
   {
     li.rewind();
-    if ((*ord->item)->type() != Item::FUNC_ITEM)
+    if (!(*ord->item)->can_be_substituted_for_gc())
       continue;
     while ((gc= li++))
     {

Original file line number	Diff line number	Diff line change
`@@ -963,11 +963,11 @@ Item_field get_gc_for_expr(Item_func func, Field fld, Item_result type)`
`963`	`963`	`if (!strcmp(expr->func_name(),"json_unquote") &&`
`964`	`964`	`strcmp((*func)->func_name(),"json_unquote"))`
`965`	`965`	`{`
`966`		`- if (expr->arguments()[0]->type() != Item::FUNC_ITEM)`
	`966`	`+ if (!expr->arguments()[0]->can_be_substituted_for_gc())`
`967`	`967`	`return NULL;`
`968`		`- expr= (Item_func*)expr->arguments()[0];`
	`968`	`+ expr= down_cast<Item_func*>(expr->arguments()[0]);`
`969`	`969`	`}`
`970`		`- DBUG_ASSERT(expr->type() == Item::FUNC_ITEM);`
	`970`	`+ DBUG_ASSERT(expr->can_be_substituted_for_gc());`
`971`	`971`
`972`	`972`	`if (type == fld->result_type() && (*func)->eq(expr, false))`
`973`	`973`	`{`
`@@ -1016,12 +1016,12 @@ Item Item_func::gc_subst_transformer(uchar arg)`
`1016`	`1016`	`List<Field> gc_fields= (List<Field> )arg;`
`1017`	`1017`	`List_iterator<Field> li(*gc_fields);`
`1018`	`1018`	`// Check if we can substitute a function with a GC`
`1019`		`- if (args[0]->type() == FUNC_ITEM && args[1]->const_item())`
	`1019`	`+ if (args[0]->can_be_substituted_for_gc() && args[1]->const_item())`
`1020`	`1020`	`{`
`1021`	`1021`	`func= (Item_func**)args;`
`1022`	`1022`	`val= args + 1;`
`1023`	`1023`	`}`
`1024`		`- else if (args[1]->type() == FUNC_ITEM && args[0]->const_item())`
	`1024`	`+ else if (args[1]->can_be_substituted_for_gc() && args[0]->const_item())`
`1025`	`1025`	`{`
`1026`	`1026`	`func= (Item_func**)args + 1;`
`1027`	`1027`	`val= args;`
`@@ -1056,7 +1056,7 @@ Item Item_func::gc_subst_transformer(uchar arg)`
`1056`	`1056`	`{`
`1057`	`1057`	`List<Field> gc_fields= (List<Field> )arg;`
`1058`	`1058`	`List_iterator<Field> li(*gc_fields);`
`1059`		`- if (args[0]->type() != FUNC_ITEM)`
	`1059`	`+ if (!args[0]->can_be_substituted_for_gc())`
`1060`	`1060`	`break;`
`1061`	`1061`	`Item_result type= args[1]->result_type();`
`1062`	`1062`	`bool can_do_subst= args[1]->const_item();`
Original file line number	Diff line number	Diff line change
`@@ -780,12 +780,13 @@ void JOIN::substitute_gc()`
`780`	`780`	`for (uint i= 0; i < tl->table->s->fields; i++)`
`781`	`781`	`{`
`782`	`782`	`Field *fld= tl->table->field[i];`
`783`		`- if (!fld->gcol_info \|\| fld->part_of_key.is_clear_all() \|\|`
`784`		`- fld->gcol_info->expr_item->type() != Item::FUNC_ITEM)`
`785`		`- continue;`
`786`		`- // Don't check allowed keys here as conditions/group/order use`
`787`		`- // different keymaps for that`
`788`		`- indexed_gc.push_back(fld);`
	`783`	`+ if (fld->is_gcol() && !fld->part_of_key.is_clear_all() &&`
	`784`	`+ fld->gcol_info->expr_item->can_be_substituted_for_gc())`
	`785`	`+ {`
	`786`	`+ // Don't check allowed keys here as conditions/group/order use`
	`787`	`+ // different keymaps for that.`
	`788`	`+ indexed_gc.push_back(fld);`
	`789`	`+ }`
`789`	`790`	`}`
`790`	`791`	`}`
`791`	`792`	`// No GC in the tables used in the query`
`@@ -824,7 +825,7 @@ void JOIN::substitute_gc()`
`824`	`825`	`for (ORDER *ord= list; ord; ord= ord->next)`
`825`	`826`	`{`
`826`	`827`	`li.rewind();`
`827`		`- if ((*ord->item)->type() != Item::FUNC_ITEM)`
	`828`	`+ if (!(*ord->item)->can_be_substituted_for_gc())`
`828`	`829`	`continue;`
`829`	`830`	`while ((gc= li++))`
`830`	`831`	`{`