Bug#36652610 UNIONs are O(N^2) [1/2 noclose]

The space allocation during parsing/contextualization/flattening of
the parse tree for a large number of similar set operations[*] is not
linear in N, where N is the number of operations (e.g. UNION ALL as
shown in the bug report).

The problem lies within merge_descendants.

[*] It could be any set operations, both DISTINCT and ALL, except
for INTERSECT ALL which isn't flattened.

Contextualization is currently based on recursive dives on the parse
tree, and a large number of e.g. UNION ALL have a parse tree looking
like

                       UNION ALL
                       /       \
                   UNION ALL  query
                    :  \
                   :   query
                  :
               UNION ALL
               /      \
           query      query

The arrays holding the children (Query_term_set_op::m_children) on
each level will grow (and then be discarded) as we merge descendants
from the bottom up, ending up with

     UNION ALL
         |
    -----------
    | | ...   |
    1 2      N+1

On the way there we create N m_children arrays containing

     SELECT UNION ALL-> [query-1 query-2]
     SELECT UNION ALL-> [query-1 query-2 query-3]
     :
     SELECT UNION ALL-> [query-1 query-2 query-3 .. query-N+1]

the current logic appends the children of the lower set operation
to the list of children to the next level up set operation. This means
we get N arrays with an average of N/2 elements, which is not linear.

Solution: avoid this malign pattern by checking if the lower UNION ALL
has more childen than the upper: in that case add any upper's
child(ren) to the front of the lower UNION ALL's child list, then
using copy (std::move) that array the current array for the higher
level UNION ALL. That way we grow only a single array (moved up the
levels), which grows from 2 to N+1 elements after merge_descendants is
done.  Note that in the repro case, the number of children in the
upper set operation ("setop" in the code) is always zero, so we have
no need to add any elements to the front of the m_children array. The
new block for that level will be appended later in the loop for

    (Query_term *elt : ql.m_elts) {..}

Change-Id: I3658c27de3f9e20237f530ae2832f5aab80c9927

Author: Dag Wanvik

include/mem_root_deque.h

@@ -152,6 +152,7 @@ class mem_root_deque {
       : m_blocks(other.m_blocks),
         m_begin_idx(other.m_begin_idx),
         m_end_idx(other.m_end_idx),
+        m_capacity(other.m_capacity),
         m_root(other.m_root) {
     other.m_blocks = nullptr;
     other.m_begin_idx = other.m_end_idx = other.m_capacity = 0;

sql/parse_tree_nodes.cc

@@ -1491,6 +1491,30 @@ static Surrounding_context qt2sc(Query_term_type qtt) {
   return SC_TOP;
 }
 
+/// Append the children of 'lower' to those of 'setop'.  To avoid excessive
+/// space usage of a large number of similar set ops: instead of the "obvious"
+/// method of copying the operands of the child's array to the parent's array,
+/// we may use the (possibly much) larger lower setop's child array as a basis,
+/// inserting setop's childen at the front and then std::move'ing that (now
+/// discarded) array to be setop's child array.  This makes the space
+/// allocation ~= linear instead of O(N*N/2) in the worst case (N: # of set
+/// operations).
+void PT_set_operation::merge_children(Query_term_set_op *setop,
+                                      Query_term_set_op *lower) {
+  if (lower->m_children.size() <= setop->m_children.size()) {
+    for (auto child : lower->m_children) {
+      setop->m_children.push_back(child);
+    }
+  } else {
+    const size_t lim = setop->m_children.size() - 1;
+    for (size_t i = 0; i < setop->m_children.size(); ++i) {
+      lower->m_children.push_front(setop->m_children[lim - i]);
+    }
+    setop->m_children = std::move(lower->m_children);
+    // lower->m_children is now empty.
+  }
+}
+
 /**
   Possibly merge lower syntactic levels of set operations (UNION, INTERSECT and
   EXCEPT) into setop, and set new last DISTINCT index for setop. We only ever
@@ -1653,8 +1677,7 @@ void PT_set_operation::merge_descendants(Parse_context *pc,
         // distinct
         last_distinct = count + lower->m_children.size() - 1;
         count = count + lower->m_children.size();
-        // fold in children
-        for (auto child : lower->m_children) setop->m_children.push_back(child);
+        merge_children(setop, lower);
       } else {
         // similar kind of set operation, but contains limit, so do not merge
         count++;
@@ -1693,8 +1716,7 @@ void PT_set_operation::merge_descendants(Parse_context *pc,
             }
             last_distinct = count + lower->m_last_distinct;
             count = count + lower->m_children.size();
-            for (auto child : lower->m_children)
-              setop->m_children.push_back(child);
+            merge_children(setop, lower);
           }
         } else {
           // upper and lower level are both ALL, so ok to merge, unless we have
@@ -1705,8 +1727,7 @@ void PT_set_operation::merge_descendants(Parse_context *pc,
               first_distinct = count + lower->m_first_distinct;
             }
             count = count + lower->m_children.size();
-            for (auto child : lower->m_children)
-              setop->m_children.push_back(child);
+            merge_children(setop, lower);
           } else {
             // do not merge INTERSECT ALL: the execution time logic can only
             // handle binary INTERSECT ALL.
@@ -1725,7 +1746,7 @@ void PT_set_operation::merge_descendants(Parse_context *pc,
           first_distinct = count + lower->m_first_distinct;
         }
         count = count + lower->m_children.size();
-        for (auto child : lower->m_children) setop->m_children.push_back(child);
+        merge_children(setop, lower);
       } else {
         // do not merge
         count++;

sql/parse_tree_nodes.h

@@ -1822,6 +1822,7 @@ class PT_set_operation : public PT_query_expression_body {
  protected:
   bool contextualize_setop(Parse_context *pc, Query_term_type setop_type,
                            Surrounding_context context);
+  void merge_children(Query_term_set_op *setop, Query_term_set_op *lower);
   PT_query_expression_body *m_lhs;
   bool m_is_distinct;
   PT_query_expression_body *m_rhs;