Bug#35634714: Derived condition pushdown return wrong results

When pushing a condition down to a derived table, we clone the
condition. While cloning, if the underlying field is a view
reference (field from a merged derived table), we strip off
the view reference and clone the expression that it references.
For the case in bugpage, this underlying expression happens
to be a constant expression from a table that is on the inner
side of an outer join. A constant expression in such a
case cannot be treated as a basic constant because of the
"NULLs" that need to be generated and this is handled carefully
in Item_view_ref::used_tables(). So when we strip off the view
reference, this information is lost and therefore we see wrong
results.
So the fix is to avoid condition pushdown for such a case.

Change-Id: I0d09d73649b7a9b5c22b27156b40dd56027e255d

Author: Chaithra Gopalareddy

mysql-test/r/derived_condition_pushdown.result

@@ -2411,3 +2411,20 @@ DEALLOCATE PREPARE ps_select_latin1_on;
 DEALLOCATE PREPARE ps_select_latin1_off;
 DROP VIEW v1;
 DROP TABLE t1, t2;
+#
+# Bug#35634714: Derived condition pushdown return wrong results
+#
+CREATE TABLE t1(f1 INTEGER);
+INSERT INTO t1 VALUES (NULL);
+CREATE TABLE t2(f1 INTEGER);
+SELECT dt3.f1
+FROM t1 JOIN (SELECT f1
+FROM (SELECT dt1.f1
+FROM t1
+LEFT JOIN (SELECT 1 AS f1
+FROM t2) AS dt1
+ON TRUE) AS dt2
+GROUP BY f1) AS dt3
+WHERE dt3.f1 IS NOT NULL;
+f1
+DROP TABLE t1,t2;

mysql-test/t/derived_condition_pushdown.test

@@ -1618,3 +1618,22 @@ DEALLOCATE PREPARE ps_select_latin1_off;
 
 DROP VIEW v1;
 DROP TABLE t1, t2;
+--echo #
+--echo # Bug#35634714: Derived condition pushdown return wrong results
+--echo #
+
+CREATE TABLE t1(f1 INTEGER);
+INSERT INTO t1 VALUES (NULL);
+CREATE TABLE t2(f1 INTEGER);
+
+SELECT dt3.f1
+FROM t1 JOIN (SELECT f1
+              FROM (SELECT dt1.f1
+                    FROM t1
+                         LEFT JOIN (SELECT 1 AS f1
+                                    FROM t2) AS dt1
+                         ON TRUE) AS dt2
+              GROUP BY f1) AS dt3
+WHERE dt3.f1 IS NOT NULL;
+
+DROP TABLE t1,t2;

sql/item.cc

@@ -960,7 +960,15 @@ bool Item_field::is_valid_for_pushdown(uchar *arg) {
     // having them.
     // Expressions which have system variables in the underlying derived
     // table cannot be pushed as of now because Item_func_get_system_var::print
-    // does not print the original expression which leads to an incorrect clone.
+    // does not print the original expression which leads to an incorrect
+    // clone.
+    // Constant expressions from a merged derived table (Item_view_ref to a
+    // const item) which is on the inner side of an outer join has special
+    // handling. However, when such expressions are cloned, they would be
+    // cloned as basic constants i.e. view references are stripped off after
+    // cloning. This leads to wrong results as the used_tables information
+    // (See Item_view_ref::used_tables()) is lost. So we disable condition
+    // pushdown if we have such expressions.
     Query_expression *derived_query_expression =
         derived_table->derived_query_expression();
     Item_result result_type = this->result_type();
@@ -970,24 +978,32 @@ bool Item_field::is_valid_for_pushdown(uchar *arg) {
       if (result_type != item->result_type()) {
         return true;
       }
-      bool has_trigger_field = false;
-      bool has_system_var = false;
-      WalkItem(item, enum_walk::PREFIX,
-               [&has_trigger_field, &has_system_var](Item *inner_item) {
-                 if (inner_item->type() == Item::TRIGGER_FIELD_ITEM) {
-                   has_trigger_field = true;
-                   return true;
-                 }
-                 if (inner_item->type() == Item::FUNC_ITEM &&
-                     down_cast<Item_func *>(inner_item)->functype() ==
-                         Item_func::GSYSVAR_FUNC) {
-                   has_system_var = true;
-                   return true;
-                 }
-                 return false;
-               });
-      if (item->has_subquery() || item->is_non_deterministic() ||
-          has_trigger_field || has_system_var)
+      if (item->has_subquery() || item->is_non_deterministic()) return true;
+      if (WalkItem(item, enum_walk::PREFIX, [](Item *inner_item) {
+            if (inner_item->type() == Item::TRIGGER_FIELD_ITEM) {
+              return true;
+            }
+            if (inner_item->type() == Item::FUNC_ITEM &&
+                down_cast<Item_func *>(inner_item)->functype() ==
+                    Item_func::GSYSVAR_FUNC) {
+              return true;
+            }
+            if (inner_item->type() == Item::REF_ITEM &&
+                down_cast<Item_ref *>(inner_item)->ref_type() ==
+                    Item_ref::VIEW_REF) {
+              Item *ref_item = down_cast<Item_ref *>(inner_item);
+              Item *real_item = ref_item->real_item();
+              // A const item from a merged derived inner table that
+              // is part of an outer join may return NULL values and
+              // is hence not const and cannot be pushed down. This is
+              // indicated by having the actual field const and the ref
+              // item non-const.
+              if (real_item->const_item() && !ref_item->const_item()) {
+                return true;
+              }
+            }
+            return false;
+          }))
         return true;
     }
     return false;