mysql> select * from t1;
+------+
| a    |
+------+
|    1 |
|    2 |
|    2 |
+------+
mysql> select * from t3;
+------+
| a    |
+------+
|    2 |
|    3 |
|    3 |
|    2 |

mysql> select * from t1 intersect all select * from t3;
+------+
| a    |
+------+
|    2 |
|    2 |
+------+

mysql> select * from t1 intersect distinct select * from t3;
+------+
| a    |
+------+
|    2 |
+------+

mysql> select * from t3 except all select * from t1
    -> ;
+------+
| a    |
+------+
|    3 |
|    3 |
+------+

mysql> select * from t3 except distinct select * from t1;
+------+
| a    |
+------+
|    3 |
+------+

mysql> (select distinct * from t3 )order by a desc;
+------+
| a    |
+------+
|    3 |
|    2 |
+------+

mysql>  select * from t1 union all select * from t3;
+------+
| a    |
+------+
|    1 |
|    2 |
|    2 |
|    2 |
|    3 |
|    3 |
|    2 |
+------+

class Query_expression {
  /**
    The query block wherein this query expression is contained,
    NULL if the query block is the outer-most one.
  */
  Query_block *master;//父QB
  /// The first query block in this query expression.
  Query_block *slave;//孩子QB

  // The query set operation structure, see doc for Query_term.
  Query_term *m_query_term{nullptr}//用于描述集合运算，如果是Query_block类型代表最简单的QE,非set_op
}

Query_term
|__Query_block
|__Query_term_set_op
  |__Query_term_unary
  |__Query_term_union
  |__Query_term_intersect
  |__Query_term_except

class Query_term {
/**
    The query result for this term. Shared between n-ary set operands, the first
    one holds it, cf. owning_operand. Except at top level, this is always a
    Query_result_union.
  */
  Query_result *m_setop_query_result{nullptr};
  /**
    The operand of a n-ary set operation (that owns the common query result) has
    this set to true. It is always the first one.
  */
  bool m_owning_operand{false};
  /**
     Result temporary table for the set operation, if applicable
   */
  Table_ref *m_result_table{nullptr};
  /**
    Used only when streaming, i.e. not materialized result set
  */
  mem_root_deque<Item *> *m_fields{nullptr};
}

class Query_term_set_op : public Query_term {
Query_block *m_block{nullptr};//类似早先版本fake_select_lex,这个block上只有set结果表+orderby+limit
mem_root_deque<Query_term *> m_children;//union，itersect等的child QB或嵌套的set_op
bool m_is_materialized{true};//一般是true，除了顶层union all+no order，streaming输出，算一个特殊优化
}

/// Example:select * from t1 order by a limit 10;
/// Tree:
///      Query_expression---- slave----+  //slave,m_query_term指向同一个也是唯一child Queryblock
///               | m_query_term       |
///               V                    |
///        Query_block <---------------+ holds inner SELECT and its ORDER BY/LIMIT
/// Example: (SELECT * FROM .. ORDER BY .. LIMIT n) ORDER BY .. LIMIT m

/// Tree:
///      Query_expression
///               | m_query_term
///      Query_term_unary
///      +--------------------+
///      |      m_block ------+---->      Query_block which holds outer
///      |        :           |           ORDER BY and LIMIT
///      |      m_children[0] |
///      +--------|-----------+
///               V
///        Query_block   holds inner SELECT and its ORDER BY/LIMIT

(
    (/* select#1 */
     SELECT `test`.`t1`.`a` AS `a`
     FROM `test`.`t1`
     
     UNION /* select#2 */
     SELECT `test`.`t2`.`a` AS `a`
     FROM `test`.`t2`
     
     UNION ALL /* select#3 */
     SELECT `test`.`t3`.`a` AS `a`
     FROM `test`.`t3`
     
     ORDER BY `a`
     LIMIT 5
    )
    INTERSECT 
    (
        (/* select#4 */
         SELECT `test`.`t3`.`a` AS `a`
         FROM `test`.`t3`
         
         ORDER BY `test`.`t3`.`a`
         LIMIT 4
        )
        
        EXCEPT /* select#5 */
        SELECT `test`.`t4`.`a` AS `a`
        FROM `test`.`t4`
    )
    
    ORDER BY `a`
    LIMIT 4
) 
ORDER BY -(`a`)
LIMIT 3;

->
              m_query_term   +------------------+     slave(s)
              +--------------|-Query_expression |------------------+
              |              +------------------+                  |
              V        post_                                       |
  +-------------------+processing_ +----------------------+        |
  | Query_term_unary  |block()     |Query_block           |        |
  |                   |----------->|order by -(`a) limit 3|        |
  +-------------------+            +----------------------+        |
   |m_children                                                     |
   | +-----------------------+   +----------------------+          |
   | |Query_term_intersect   |   |Query_block           |          |
   +>|last distinct index: 1 |-->|order by `a` limit 4  |          |
     +-----------------------+   +----------------------+          |
      |m_children                                                  |
      |  +-----------------------+   +----------------------+      |
      |  |Query_term_union       |   |Query_block           |      |
      +->|last distinct index: 1 |-->|order by `a`  limit 5 |      |
      |  +-----------------------+   +----------------------+      |
      |    |m_children                                             |
      |    |   +------------+        SELECT * FROM t1             /
      |    +-->|Query_block |  <---------------------------------+
      |    |   +------------+  ----------------------------------+ next
      |    |                                                      \
      |    |   +------------+        SELECT * FROM t2             /
      |    +-->|Query_block |  <---------------------------------+
      |    |   +------------+  ----------------------------------+ next
      |    |                                                      \
      |    |   +------------+        SELECT * FROM t3             /
      |    +-->|Query_block |  <---------------------------------+
      |        +------------+  ----------------------------------+ next
      |                                                           \
      |  +-----------------------+  +------------+                 |
      |  |Query_term_except      |->|Query_block |                 |
      +->|last distinct index: 1 |  +------------+                 |
         +-----------------------+                                 |
           |m_children                                             |
           |   +----------------------+                            |
           |   |Query_block           |      SELECT * FROM t3      /
           +-->|order by `a`  limit 4 |  <------------------------+
           |   +----------------------+  -------------------------+ next
           |                                                       \
           |   +------------+                SELECT * FROM t4      |
           +-->|Query_block | <------------------------------------+
               +------------+

 /* QB1 */ select * from t1 intersect distinct
 /* QB2 */ select * from t2

(select * /*+q1*/ from t1 UNION select * /*+q2*/ from t1) UNION ALL ( select * /*+q3*/ from t1 UNION ALL select * /*+q4*/ from t1);

materialize_iterator::QueryBlock：
struct QueryBlock {
  /// The number of operands (i.e. blocks) involved in the set operation:
  /// used for INTERSECT to determine if a value is present in all operands
  ulonglong m_total_operands{0};
  /// The current operand (i.e. block) number, starting at zero. We use this
  /// for INTERSECT and EXCEPT materialization operand.
  ulonglong m_operand_idx{0};
  /// Used for EXCEPT computation: the index of the first operand involved in
  /// a N-ary except operation which has DISTINCT. This is significant for
  /// calculating whether to set the counter to zero or just decrement it
  /// when we see a right side operand.
  uint m_first_distinct{0};
}

TABLE:
struct TABLE {
// ----------------------------------------------------------------------
  // The next few members are used if this (temporary) file is used solely for
  // the materialization/computation of an INTERSECT or EXCEPT set operation
  // (in addition to hash_field above used to detect duplicate rows).  For
  // INTERSECT and EXCEPT, we always use the hash field and compute the shape
  // of the result set using m_set_counter. The latter is a hidden field
  // located between the hash field and the row proper, only present for
  // INTERSECT or EXCEPT materialized in a temporary result table.  The
  // materialized table has no duplicate rows, relying instead of the embedded
  // counter to produce the correct number of duplicates with ALL semantics. If
  // we have distinct semantics, we squash duplicates. This all happens in the
  // reading step of the tmp table (TableScanIterator::Read),
  // cf. m_last_operation_is_distinct. For explanation if the logic of the set
  // counter, see MaterializeIterator<Profiler>::MaterializeQueryBlock.
  //
  /// A priori unlimited. We pass this on to TableScanIterator at construction
  /// time, q.v., to limit the number of rows out of an EXCEPT or INTERSECT.
  /// For these set operations, we do not know enough to enforce the limit at
  /// materialize time (as for UNION): only when reading the rows with
  /// TableScanIterator do we check the counters.
  /// @todo: Ideally, this limit should be communicated to TableScanIterator in
  /// some other way.
  ha_rows m_limit_rows{HA_POS_ERROR};
 private:
  /// The set counter. It points to the field in the materialized table
  /// holding the counter used to compute INTERSECT and EXCEPT, in record[0].
  /// For EXCEPT [DISTINCT | ALL] and INTERSECT DISTINCT this is a simple 64
  /// bits counter. For INTERSECT ALL, it is subdivided into two sub counters
  /// cf. class HalfCounter, cf. MaterializeQueryBlock. See set_counter().
  Field_longlong *m_set_counter{nullptr};
  /// True if we have EXCEPT, else we have INTERSECT. See is_except() and
  /// is_intersect().
  bool m_except{false};
  /// If m_set_counter is set: true if last block has DISTINCT semantics,
  /// either because it is marked as such, or because we have computed this
  /// to give an equivalent answer. If false, we have ALL semantics.
  /// It will be true if any DISTINCT is given in the merged N-ary set
  /// operation. See is_distinct().
  bool m_last_operation_is_distinct{false};
}

Temp_table_param:
class Temp_table_param {
  /// For INTERSECT and EXCEPT computation
  enum {
    TTP_UNION_OR_TABLE,
    TTP_EXCEPT,
    TTP_INTERSECT
  } m_operation{TTP_UNION_OR_TABLE};
  /// The tempoary table rows need a counter to keep track of its
  /// duplicates: needed for EXCEPT and INTERSECT computation.
  bool needs_set_counter() { return m_operation != TTP_UNION_OR_TABLE; }
  /// For INTERSECT and EXCEPT computation.
  /// Cf. TABLE::m_last_operation_is_distinct.
  bool m_last_operation_is_distinct{false};
}

int TableScanIterator::Read() {
  int tmp;
  if (table()->is_union_or_table()) {
   ...//基表或union op_set
  } else {
    while (true) {
      if (m_remaining_dups == 0) {  // always initially
        while ((tmp = table()->file->ha_rnd_next(m_record))) {
    
        }
        // Filter out rows not qualifying for INTERSECT, EXCEPT by reading
        // the counter.
        const ulonglong cnt =
            static_cast<ulonglong>(table()->set_counter()->val_int());
        if (table()->is_except()) {
          if (table()->is_distinct()) {
            // EXCEPT DISTINCT: any counter value larger than one yields
            // exactly one row
            if (cnt >= 1) break;
          } else {
            // EXCEPT ALL: we use m_remaining_dups to yield as many rows
            // as found in the counter.
            m_remaining_dups = cnt;
          }
        } else {
          // INTERSECT
          if (table()->is_distinct()) {
            if (cnt == 0) break;
          } else {
            HalfCounter c(cnt);
            // Use min(left side counter, right side counter)
            m_remaining_dups = std::min(c[0], c[1]);
          }
        }
      } else {
        --m_remaining_dups;  // return the same row once more.
        break;
      }
      // Skipping this row
    }