Bug#35889583: Server fails when we execute set of queries Bug#35996409: Failure in Query_expression::is_set_operation() Bug#36404149: Failing the server

Problem is that we attempt to inspect a query expression object that
has been abandoned due to condition elimination. The problem is with
equality operations that are transformed into semi-join conditions,
where we store the left and right parts of the equality in
sj_inner_exprs and sj_outer_exprs.

The fix is to remove the references in the semi-join expression arrays
when removing the corresponding equality condition. A dive within all
join nests of the query block is necessary, due to the fact that we
may have seen multiple transformations that add join nests so far.

Change-Id: I7ae6aca62564486d0261a65afdf54ba057c9687d

Author: roylyseng

sql/item.h

@@ -2910,6 +2910,7 @@ class Item : public Parse_tree_node {
     Query_block *const m_root;
 
     friend class Item;
+    friend class Item_func_eq;
     friend class Item_sum;
     friend class Item_subselect;
     friend class Item_ref;

sql/item_cmpfunc.cc

@@ -2610,6 +2610,22 @@ void Item_in_optimizer::update_used_tables() {
   }
 }
 
+bool Item_func_eq::clean_up_after_removal(uchar *arg) {
+  Cleanup_after_removal_context *const ctx =
+      pointer_cast<Cleanup_after_removal_context *>(arg);
+
+  if (ctx->is_stopped(this)) return false;
+
+  if (reference_count() > 1) {
+    (void)decrement_ref_count();
+    ctx->stop_at(this);
+  }
+
+  ctx->m_root->prune_sj_exprs(this, nullptr);
+
+  return false;
+}
+
 longlong Item_func_eq::val_int() {
   assert(fixed);
   const int value = cmp.compare();

sql/item_cmpfunc.h

@@ -1091,6 +1091,7 @@ class Item_func_eq final : public Item_eq_base {
   Item_func_comparison *negate_item() override;
   bool equality_substitution_analyzer(uchar **) override { return true; }
   Item *equality_substitution_transformer(uchar *arg) override;
+  bool clean_up_after_removal(uchar *arg) override;
 
   float get_filtering_effect(THD *thd, table_map filter_for_table,
                              table_map read_tables,

sql/sql_lex.h

@@ -1777,6 +1777,8 @@ class Query_block : public Query_term {
   */
   bool accept(Select_lex_visitor *visitor);
 
+  void prune_sj_exprs(Item_func_eq *item, mem_root_deque<Table_ref *> *nest);
+
   /**
     Cleanup this subtree (this Query_block and all nested Query_blockes and
     Query_expressions).

sql/sql_resolver.cc

@@ -5263,6 +5263,43 @@ bool validate_gc_assignment(const mem_root_deque<Item *> &fields,
   return false;
 }
 
+/// Minion of prune_sj_exprs, q.v.
+static void prune_sj_exprs_from_nest(Item_func_eq *item, Table_ref *nest) {
+  auto it1 = nest->nested_join->sj_outer_exprs.begin();
+  auto it2 = nest->nested_join->sj_inner_exprs.begin();
+  while (it1 != nest->nested_join->sj_outer_exprs.end() &&
+         it2 != nest->nested_join->sj_inner_exprs.end()) {
+    Item *outer = *it1;
+    Item *inner = *it2;
+    if ((outer == item->arguments()[0] && inner == item->arguments()[1]) ||
+        (outer == item->arguments()[1] && inner == item->arguments()[0])) {
+      nest->nested_join->sj_outer_exprs.erase(it1);
+      nest->nested_join->sj_inner_exprs.erase(it2);
+      break;
+    }
+    it1++;
+    it2++;
+  }
+}
+
+/**
+  Recursively look for removed item inside any nested joins'
+  sj_{inner,outer}_exprs. If target for removal is found, remove such entries
+  because the corresponding equality condition has been eliminated.
+
+  @param item   the equality which is being removed.
+  @param nest   the table nest (nullptr means top nest)
+*/
+void Query_block::prune_sj_exprs(Item_func_eq *item,
+                                 mem_root_deque<Table_ref *> *nest) {
+  if (nest == nullptr) nest = &m_table_nest;
+  for (Table_ref *table : *nest) {
+    if (table->nested_join == nullptr) continue;
+    prune_sj_exprs_from_nest(item, table);
+    prune_sj_exprs(item, &table->nested_join->m_tables);
+  }
+}
+
 /**
   Delete unused columns from merged tables.