JOIN_TAB

typedef struct st_join_table {
  st_join_table() {}                          /* Remove gcc warning */
  TABLE        *table;
  KEYUSE    *keyuse;            /**< pointer to first used key */
  SQL_SELECT    *select;
  /**
    When doing filesort, the select object is used for building the
    sort index. After the sort index is built, the pointer to the
    select object is set to NULL to avoid that it is used when reading
    the result records (@see create_sort_index()). For subqueries that
    do filesort and that are executed multiple times, the pointer to
    the select object must be restored before the next execution both
    to ensure that the select object is used and to be able to cleanup
    the select object after the final execution of the subquery. In
    order to be able to restore the pointer to the select object, it
    is saved in saved_select in create_sort_index() and restored in
    JOIN::exec() after the main select is done.
  */
  SQL_SELECT    *saved_select;
  COND        *select_cond;
  QUICK_SELECT_I *quick;
  Item           **on_expr_ref;   /**< pointer to the associated on expression   */
  COND_EQUAL    *cond_equal;    /**< multiple equalities for the on expression */
  st_join_table *first_inner;   /**< first inner table for including outerjoin */
  bool           found;         /**< true after all matches or null complement */
  bool           not_null_compl;/**< true before null complement is added      */
  st_join_table *last_inner;    /**< last table table for embedding outer join */
  st_join_table *first_upper;  /**< first inner table for embedding outer join */
  st_join_table *first_unmatched; /**< used for optimization purposes only     */
  
  /* Special content for EXPLAIN 'Extra' column or NULL if none */
  const char    *info;
  /* 
    Bitmap of TAB_INFO_* bits that encodes special line for EXPLAIN 'Extra'
    column, or 0 if there is no info.
  */
  uint          packed_info;

  READ_RECORD::Setup_func read_first_record;
  Next_select_func next_select;
  READ_RECORD    read_record;
  /* 
    Currently the following two fields are used only for a [NOT] IN subquery
    if it is executed by an alternative full table scan when the left operand of
    the subquery predicate is evaluated to NULL.
  */  
  READ_RECORD::Setup_func save_read_first_record;/* to save read_first_record */
  READ_RECORD::Read_func save_read_record;/* to save read_record.read_record */
  double    worst_seeks;
  key_map    const_keys;            /**< Keys with constant part */
  key_map    checked_keys;            /**< Keys checked in find_best */
  key_map    needed_reg;
  key_map       keys;                           /**< all keys with can be used */

  /* Either #rows in the table or 1 for const table.  */
  ha_rows    records;
  /*
    Number of records that will be scanned (yes scanned, not returned) by the
    best 'independent' access method, i.e. table scan or QUICK_*_SELECT)
  */
  ha_rows       found_records;
  /*
    Cost of accessing the table using "ALL" or range/index_merge access
    method (but not 'index' for some reason), i.e. this matches method which
    E(#records) is in found_records.
  */
  ha_rows       read_time;
  
  table_map    dependent,key_dependent;
  uint        use_quick,index;
  uint        status;                ///< Save status for cache
  uint        used_fields,used_fieldlength,used_blobs;
  enum join_type type;
  bool        cached_eq_ref_table,eq_ref_table,not_used_in_distinct;
  bool        sorted;
  /* 
    If it's not 0 the number stored this field indicates that the index
    scan has been chosen to access the table data and we expect to scan 
    this number of rows for the table.
  */ 
  ha_rows       limit; 
  TABLE_REF    ref;
  JOIN_CACHE    cache;
  JOIN        *join;
  /** Bitmap of nested joins this table is part of */
  nested_join_map embedding_map;

  void cleanup();
  /*
    In cases where filesort reads rows from a table using Loose Index
    Scan, the fact that LIS was used is lost because
    create_sort_index() deletes join_tab->select->quick. MySQL needs
    this information during JOIN::exec().

    This variable is a hack for MySQL 5.5 only. A value of true means
    that filesort used LIS to read from the table. In MySQL 5.6 and
    later, join_tab->filesort is a separate structure with it's own
    select that can be inquired to get the same information. There is
    no need for this variable in MySQL 5.6 and later.
  */
  bool        filesort_used_loose_index_scan;
  /*
    Similar hack as for filesort_used_loose_index_scan. Not needed for
    MySQL 5.6 and later.
  */
  bool        filesort_used_loose_index_scan_agg_distinct;
  inline bool is_using_loose_index_scan()
  {
    return (filesort_used_loose_index_scan || 
            (select && select->quick &&
             (select->quick->get_type() ==
              QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX))
            );
  }
  bool is_using_agg_loose_index_scan ()
  {
    return (filesort_used_loose_index_scan_agg_distinct ||
            (select && select->quick &&
             (select->quick->get_type() ==
              QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX) &&
             ((QUICK_GROUP_MIN_MAX_SELECT *)select->quick)->is_agg_distinct())
            );
  }
} JOIN_TAB;